From d6eebd5a84fa2f95a36bb4ad38f124eff40f1abf Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 01:42:21 +0100 Subject: [PATCH 01/15] feat(target-health): track MCP and agent target health Add a per-replica, in-memory health tracker for MCP servers and A2A agents (target_health.go). The tracker records observations from real proxied traffic (handleTargetProxy, mcp_a2a.go) and federated calls (mcpFederatedToolsList/mcpFederatedToolsCall, mcp_federation.go), and derives a three-state readout (unknown, healthy, unhealthy) from a configurable consecutive-failure threshold. Add TargetHealthConfig to Config, validated at construction. The tracker never gates routing: federation and the target proxy keep contacting every configured server regardless of its recorded health. Extend proxyResult (routes_passthrough.go) with status and clientCanceled so handleTargetProxy can classify a proxied response without proxyUpstream knowing anything about target health. Add maybeSweepTargetHealth, an opt-in, lazy, single-flight active probe sweep with no timer and no long-lived goroutine, matching this plugin's lack of a Close hook under Traefik hot reload. A probe uses the initialize/close handshake for a Streamable HTTP MCP server, a plain unread GET for a legacy /sse server, and a GET of the agent card path for an A2A agent. handleMCPServers and handleAgents now trigger a sweep at the top of each call. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- llmgateway.go | 86 ++++++- mcp_a2a.go | 12 +- mcp_a2a_test.go | 226 ++++++++++++++++++ mcp_federation.go | 12 + mcp_federation_test.go | 122 ++++++++++ routes_passthrough.go | 29 ++- target_health.go | 524 +++++++++++++++++++++++++++++++++++++++++ target_health_test.go | 413 ++++++++++++++++++++++++++++++++ 8 files changed, 1413 insertions(+), 11 deletions(-) create mode 100644 target_health.go create mode 100644 target_health_test.go diff --git a/llmgateway.go b/llmgateway.go index ba90a94..116678b 100644 --- a/llmgateway.go +++ b/llmgateway.go @@ -111,6 +111,13 @@ type Config struct { // Cache is a struct value, not a pointer, for the same reason as Retry // above: its own Enabled field is the on/off signal. Cache CacheConfig `json:"cache"` + // TargetHealth configures feat/target-health's opt-in active probe + // sweep for MCP servers and A2A agents — see TargetHealthConfig's own + // doc comment. A struct value, not a pointer, for the same + // zero-means-default reason as Breaker above: passive recording and + // exposure (GET /admin/api/targets, llmgateway_target_healthy) stay + // on unconditionally regardless of this block's presence. + TargetHealth TargetHealthConfig `json:"targetHealth"` // MaxInFlightBodyRequests caps how many unified and media JSON/ // multipart requests (routes_unified.go's runUnified via // readAndDecodeUnifiedBody; routes_media.go's decodeMediaJSONRequest/ @@ -362,6 +369,39 @@ type BreakerConfig struct { FailureThreshold int `json:"failureThreshold,omitempty"` } +// TargetHealthConfig configures feat/target-health's OPT-IN active probe +// sweep for MCP servers and A2A agents (target_health.go). Passive +// recording from real request traffic, and exposure via GET +// /admin/api/targets and the llmgateway_target_healthy gauge, are ALWAYS +// on regardless of this block's presence — Enabled here gates ONLY the +// background probe sweep (maybeSweepTargetHealth, target_health.go). The +// zero value (Enabled: false) preserves prior behavior exactly: a +// deployment that predates this feature, or one that never configures +// this block, sends no active probe traffic to any MCP server or agent. +// Field order (string before the two scalars) is fieldalignment- +// sensitive, the same convention BreakerConfig's own doc comment above +// explains. +type TargetHealthConfig struct { + // ProbeInterval is the minimum time between sweeps (a Go duration + // string, e.g. "60s"). Empty (the default) uses + // defaultTargetHealthProbeInterval (target_health.go). Must be + // between minTargetHealthProbeInterval (10s) and + // maxTargetHealthProbeInterval (1h) when set, or construction fails. + ProbeInterval string `json:"probeInterval,omitempty"` + // FailureThreshold is how many CONSECUTIVE failed observations + // (probe or traffic) mark a target unhealthy — see + // targetHealthTracker's own doc comment (target_health.go) for the + // exact state rule. 0 (the default) uses + // defaultTargetHealthFailureThreshold (3). Must be between 1 and 100, + // or construction fails. + FailureThreshold int `json:"failureThreshold,omitempty"` + // Enabled opts into the active probe sweep. false (the default) + // means no MCP server or A2A agent is ever proactively contacted for + // health purposes — passive recording from real proxied traffic + // still runs either way. + Enabled bool `json:"enabled,omitempty"` +} + // AdminConfig configures the read-only admin dashboard (spec §4, v0.2). // The zero value (Enabled: false) disables it, preserving v0.1 behavior // exactly: no /admin* route is registered, so those paths fall through @@ -561,11 +601,22 @@ type Gateway struct { // degrades to "failover never skips a candidate for request health" // rather than a nil-pointer panic. failoverHealth *requestHealthTracker - limiter *limiter - registry *modelRegistry - adapters map[string]providerAdapter - cfg *Config - auth *authStore + // targetHealth is feat/target-health's own per-pod, in-memory health + // tracker for MCP servers and A2A agents (target_health.go) — always + // constructed, here, regardless of Config.TargetHealth.Enabled: + // passive recording (handleTargetProxy, mcp_a2a.go; + // mcpFederatedToolsList/mcpFederatedToolsCall, mcp_federation.go) and + // exposure (GET /admin/api/targets, llmgateway_target_healthy) both + // stay on unconditionally, mirroring g.latency/g.provenance's own + // "always-present, usually-empty, nil-receiver-safe" convention + // below. Enabled gates only maybeSweepTargetHealth's own active + // probe sweep. + targetHealth *targetHealthTracker + limiter *limiter + registry *modelRegistry + adapters map[string]providerAdapter + cfg *Config + auth *authStore // cache is nil whenever response caching is not configured or not // usable (cfg.Cache.Enabled is false, or true with no config.Redis — // see buildResponseCache, cache.go). Every call site checks for nil @@ -624,6 +675,10 @@ type Gateway struct { // failover is Config.Failover, validated and resolved once by // newGateway (validateFailoverConfig, failover.go). failover failoverConfig + // targetHealthCfg is Config.TargetHealth, validated and resolved once + // by validateTargetHealthConfig (target_health.go) — maybeSweepTargetHealth + // reads probeInterval/enabled from this, never the raw Config. + targetHealthCfg targetHealthConfig // targetTimeout is targetClient's own resolved request timeout — // Config.RequestTimeout only; an MCP/A2A target has no per-target // override the way a provider does. proxyUpstream's own callers @@ -631,6 +686,15 @@ type Gateway struct { // idle-progress body watchdog (timeout.go) matches the // ResponseHeaderTimeout already set on targetClient's Transport. targetTimeout time.Duration + // targetHealthLastSweepUnixNano/targetHealthSweeping back + // maybeSweepTargetHealth's own single-flight, at-most-one-sweep-per- + // interval gate (target_health.go): a UnixNano timestamp and a CAS + // flag, both atomic rather than mutex-guarded, since every caller + // (serveMetrics, serveAdminTargets, handleMCPServers, handleAgents) + // reaches maybeSweepTargetHealth on a live request path and must + // never block behind a lock another such call already holds. + targetHealthLastSweepUnixNano int64 + targetHealthSweeping int32 } // telemetryStartupOnce keeps the anonymous "plugin loaded" ping to one per @@ -749,6 +813,18 @@ func newGateway(ctx context.Context, next http.Handler, config *Config, name str } g.failover = failoverCfg g.failoverHealth = newRequestHealthTracker() + + // feat/target-health: validated once, here — passive recording and + // exposure stay always-on regardless of this block; Enabled gates + // only maybeSweepTargetHealth's own active probe sweep + // (target_health.go). + targetHealthCfg, err := validateTargetHealthConfig(config.TargetHealth) + if err != nil { + return nil, err + } + g.targetHealthCfg = targetHealthCfg + g.targetHealth = newTargetHealthTracker(targetHealthCfg.failureThreshold) + // feat: instrument upstream latency — always constructed, regardless // of whether Config.Metrics is nil/disabled; see g.latency's own doc // comment above for why an always-present, usually-empty store is the diff --git a/mcp_a2a.go b/mcp_a2a.go index a7168c7..1fc6c64 100644 --- a/mcp_a2a.go +++ b/mcp_a2a.go @@ -6,6 +6,7 @@ import ( "net/http" "net/url" "sort" + "time" ) // Target kinds handleTargetProxy and resolveTarget dispatch on, selecting @@ -63,6 +64,7 @@ type agentListing struct { // servers, filtered by group.allowsMCP and sorted by name for a // deterministic response. func (g *Gateway) handleMCPServers(w http.ResponseWriter, grp *group) { + g.maybeSweepTargetHealth() names := make([]string, 0, len(g.cfg.MCPServers)) for name := range g.cfg.MCPServers { if grp.allowsMCP(name) { @@ -86,6 +88,7 @@ func (g *Gateway) handleMCPServers(w http.ResponseWriter, grp *group) { // proxy URL plus its configured card path, defaulting to // defaultAgentCardPath when AgentConfig.Card is empty. func (g *Gateway) handleAgents(w http.ResponseWriter, grp *group) { + g.maybeSweepTargetHealth() names := make([]string, 0, len(g.cfg.Agents)) for name := range g.cfg.Agents { if grp.allowsAgent(name) { @@ -216,7 +219,14 @@ func (g *Gateway) handleTargetProxy(w http.ResponseWriter, r *http.Request, u *u upstreamURL += "?" + r.URL.RawQuery } - g.proxyUpstream(w, r, upstreamURL, g.targetClient, nil, nil, false, kind+" target (name "+name+")", g.targetTimeout) + // feat/target-health: passive recording (target_health.go) — latency + // measured around the whole proxyUpstream call, matching what an + // active probe of the same target measures. See + // recordTargetProxyHealth's own doc comment for the exact + // success/failure rule. + start := time.Now() + result, ok := g.proxyUpstream(w, r, upstreamURL, g.targetClient, nil, nil, false, kind+" target (name "+name+")", g.targetTimeout) + g.recordTargetProxyHealth(kind, name, result, ok, time.Since(start)) } // validateTargetURLs checks every configured MCP-server and agent entry at diff --git a/mcp_a2a_test.go b/mcp_a2a_test.go index 77842d0..7394d66 100644 --- a/mcp_a2a_test.go +++ b/mcp_a2a_test.go @@ -935,3 +935,229 @@ func TestHandleTargetProxy_PerTargetCounters_AttributedAndCollisionSafe(t *testi }) } } + +// --- feat/target-health: passive recording via handleTargetProxy --- + +func newTargetHealthProxyConfig(mcpURL string) *Config { + cfg := CreateConfig() + cfg.Providers = map[string]*ProviderConfig{"openai": {Type: "openai", APIKey: "k"}} + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: mcpURL}} + cfg.Groups = map[string]*GroupConfig{"default": {}} + cfg.Users = &UsersConfig{Inline: []*UserConfig{{Name: "alice", Group: "default", APIKey: "sk-alice"}}} + return cfg +} + +// TestHandleTargetProxy_TargetHealth_200_RecordsHealthy proves an +// ordinary successful proxy call records a healthy, "traffic"-sourced +// observation. +func TestHandleTargetProxy_TargetHealth_200_RecordsHealthy(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + })) + defer srv.Close() + + cfg := newTargetHealthProxyConfig(srv.URL) + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + req := httptest.NewRequest(http.MethodGet, "/mcp/alpha/tools/list", nil) + req.Header.Set("Authorization", "Bearer sk-alice") + h.ServeHTTP(httptest.NewRecorder(), req) + + snap := gw.targetHealth.snapshot(targetKindMCP, "alpha") + if snap.state != targetHealthHealthy { + t.Errorf("state = %q, want healthy", snap.state) + } + if snap.source != targetHealthSourceTraffic { + t.Errorf("source = %q, want %q", snap.source, targetHealthSourceTraffic) + } + if snap.consecutiveFailures != 0 { + t.Errorf("consecutiveFailures = %d, want 0", snap.consecutiveFailures) + } +} + +// TestHandleTargetProxy_TargetHealth_404_RecordsHealthy proves a 4xx +// upstream response still counts as reachable — only 5xx (or an outright +// failed attempt) is a failure. +func TestHandleTargetProxy_TargetHealth_404_RecordsHealthy(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotFound) + })) + defer srv.Close() + + cfg := newTargetHealthProxyConfig(srv.URL) + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + req := httptest.NewRequest(http.MethodGet, "/mcp/alpha/tools/list", nil) + req.Header.Set("Authorization", "Bearer sk-alice") + h.ServeHTTP(httptest.NewRecorder(), req) + + snap := gw.targetHealth.snapshot(targetKindMCP, "alpha") + if snap.state != targetHealthHealthy { + t.Errorf("state = %q, want healthy (a 4xx still proves the target answered)", snap.state) + } +} + +// TestHandleTargetProxy_TargetHealth_500_RecordsUnhealthy proves an +// upstream 5xx is a failure, distinct from a 4xx above. +func TestHandleTargetProxy_TargetHealth_500_RecordsUnhealthy(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusInternalServerError) + })) + defer srv.Close() + + cfg := newTargetHealthProxyConfig(srv.URL) + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + req := httptest.NewRequest(http.MethodGet, "/mcp/alpha/tools/list", nil) + req.Header.Set("Authorization", "Bearer sk-alice") + h.ServeHTTP(httptest.NewRecorder(), req) + + snap := gw.targetHealth.snapshot(targetKindMCP, "alpha") + if snap.state != targetHealthUnhealthy { + t.Errorf("state = %q, want unhealthy", snap.state) + } + if snap.lastError == "" { + t.Error("want a non-empty lastError naming the 500 status") + } +} + +// TestHandleTargetProxy_TargetHealth_DeadUpstream_RecordsUnhealthy +// proves an outright failed attempt (connection refused) is a failure, +// exercising proxyResult's status=0/clientCanceled=false shape. +func TestHandleTargetProxy_TargetHealth_DeadUpstream_RecordsUnhealthy(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {})) + deadURL := srv.URL + srv.Close() + + cfg := newTargetHealthProxyConfig(deadURL) + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + req := httptest.NewRequest(http.MethodGet, "/mcp/alpha/tools/list", nil) + req.Header.Set("Authorization", "Bearer sk-alice") + h.ServeHTTP(httptest.NewRecorder(), req) + + snap := gw.targetHealth.snapshot(targetKindMCP, "alpha") + if snap.state != targetHealthUnhealthy { + t.Errorf("state = %q, want unhealthy", snap.state) + } +} + +// TestHandleTargetProxy_TargetHealth_HangTripsWatchdog_RecordsUnhealthy +// proves a stalled upstream that trips the idle-progress watchdog +// (timeout.go) is recorded as a failure, not silently ignored — the +// hang fixture mirrors TestHandlePassthrough_StalledUpstream_AbortedAtTimeout +// (timeout_test.go). +func TestHandleTargetProxy_TargetHealth_HangTripsWatchdog_RecordsUnhealthy(t *testing.T) { + srv, release := newStallingServer(nil) + defer release() + + cfg := newTargetHealthProxyConfig(srv.URL) + cfg.RequestTimeout = "60ms" + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + req := httptest.NewRequest(http.MethodGet, "/mcp/alpha/tools/list", nil) + req.Header.Set("Authorization", "Bearer sk-alice") + rec := httptest.NewRecorder() + + start := time.Now() + h.ServeHTTP(rec, req) + if elapsed := time.Since(start); elapsed > 3*time.Second { + t.Errorf("target proxy took %s to abort a 60ms requestTimeout", elapsed) + } + if rec.Code != http.StatusBadGateway { + t.Fatalf("status = %d, want 502, body=%s", rec.Code, rec.Body.String()) + } + + snap := gw.targetHealth.snapshot(targetKindMCP, "alpha") + if snap.state != targetHealthUnhealthy { + t.Errorf("state = %q, want unhealthy (the watchdog firing must record a failure)", snap.state) + } +} + +// TestHandleTargetProxy_TargetHealth_ClientCanceled_RecordsNothing +// proves a canceled CLIENT request records nothing at all — the target's +// own health stays "unknown", not "unhealthy", since the client hanging +// up says nothing about the target. +func TestHandleTargetProxy_TargetHealth_ClientCanceled_RecordsNothing(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + time.Sleep(200 * time.Millisecond) + w.WriteHeader(http.StatusOK) + })) + defer srv.Close() + + cfg := newTargetHealthProxyConfig(srv.URL) + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + ctx, cancel := context.WithCancel(context.Background()) + go func() { + time.Sleep(30 * time.Millisecond) + cancel() + }() + req := httptest.NewRequest(http.MethodGet, "/mcp/alpha/tools/list", nil).WithContext(ctx) + req.Header.Set("Authorization", "Bearer sk-alice") + h.ServeHTTP(httptest.NewRecorder(), req) + + snap := gw.targetHealth.snapshot(targetKindMCP, "alpha") + if snap.state != targetHealthUnknown { + t.Errorf("state = %q, want unknown (a client cancel must record nothing)", snap.state) + } +} + +// TestHandleTargetProxy_TargetHealth_A2A_UsesAgentKind proves an A2A +// target proxy call records under targetKindAgent, independent of an MCP +// server sharing the same name. +func TestHandleTargetProxy_TargetHealth_A2A_UsesAgentKind(t *testing.T) { + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusOK) + })) + defer srv.Close() + + cfg := CreateConfig() + cfg.Providers = map[string]*ProviderConfig{"openai": {Type: "openai", APIKey: "k"}} + cfg.Agents = map[string]*AgentConfig{"alpha": {URL: srv.URL}} + cfg.Groups = map[string]*GroupConfig{"default": {}} + cfg.Users = &UsersConfig{Inline: []*UserConfig{{Name: "alice", Group: "default", APIKey: "sk-alice"}}} + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + req := httptest.NewRequest(http.MethodGet, "/a2a/alpha/tasks", nil) + req.Header.Set("Authorization", "Bearer sk-alice") + h.ServeHTTP(httptest.NewRecorder(), req) + + if gw.targetHealth.stateOf(targetKindAgent, "alpha") != targetHealthHealthy { + t.Errorf("agent/alpha state = %q, want healthy", gw.targetHealth.stateOf(targetKindAgent, "alpha")) + } + if gw.targetHealth.stateOf(targetKindMCP, "alpha") != targetHealthUnknown { + t.Errorf("mcp/alpha state = %q, want unknown (must not be conflated with the agent of the same name)", gw.targetHealth.stateOf(targetKindMCP, "alpha")) + } +} diff --git a/mcp_federation.go b/mcp_federation.go index b916bd1..e2dd4d3 100644 --- a/mcp_federation.go +++ b/mcp_federation.go @@ -974,7 +974,13 @@ func (g *Gateway) mcpFederatedToolsList(w http.ResponseWriter, format mcpRespons defer func() { <-sem }() targetURL := g.cfg.MCPServers[name].URL + // feat/target-health: passive recording (target_health.go) — + // err != nil is a failure; a JSON-RPC-level resp.Error is NOT + // (the server answered, it just reported its own error), so + // it is recorded separately, below, once the shape is known. + probeStart := time.Now() resp, err := g.mcpBackendCall(fanoutCtx, targetURL, "tools/list", struct{}{}, mcpBackendResponseMaxBytes) + g.targetHealth.record(targetKindMCP, name, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) mu.Lock() defer mu.Unlock() @@ -1091,7 +1097,13 @@ func (g *Gateway) mcpFederatedToolsCall(w http.ResponseWriter, format mcpRespons // important finding 4): tools/call always resolves to exactly ONE // backend, so the fan-out memory-amplification argument does not // apply here — see mcpBackendCallResponseMaxBytes' own doc comment. + // feat/target-health: passive recording (target_health.go) — measured + // around the whole outbound call, same rule as tools/list's own fan- + // out above: err != nil is a failure, a JSON-RPC-level resp.Error is + // not. + probeStart := time.Now() resp, err := g.mcpBackendCall(ctx, targetURL, "tools/call", mcpToolCallParams{Name: toolName, Arguments: params.Arguments}, mcpBackendCallResponseMaxBytes) + g.targetHealth.record(targetKindMCP, serverName, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) g.limiter.countTargetRequest(targetKindMCP, serverName) if err != nil { g.logf("federated tools/call: server %q: %v", serverName, err) diff --git a/mcp_federation_test.go b/mcp_federation_test.go index ed0e5a4..94933e2 100644 --- a/mcp_federation_test.go +++ b/mcp_federation_test.go @@ -1873,3 +1873,125 @@ func TestMcpBackendCall_SessionCloseFailure_NeverSurfacedToCaller(t *testing.T) t.Fatalf("tools = %+v, want alpha_search despite the session-close failure", result.Tools) } } + +// --- feat/target-health: passive recording from federation traffic --- + +// TestHandleMCPFederated_ToolsList_TargetHealth_RecordsPerServer proves +// tools/list's own fan-out records a failure for the one server that +// could not be reached, and a healthy observation for every server that +// answered — independent of the aggregate response degrading rather +// than failing (TestHandleMCPFederated_ToolsList_UnreachableServerDegradesNotFails +// already covers the response shape; this proves the target-health side +// effect). +func TestHandleMCPFederated_ToolsList_TargetHealth_RecordsPerServer(t *testing.T) { + alpha := newMockJSONRPCServer(t, []mcpTool{{Name: "lookup"}}) + cfg := newFederationTestConfig(alpha.srv.URL, "http://127.0.0.1:1", false) + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, newFederatedRequest(t, "sk-alice", jsonrpcRequest{JSONRPC: jsonrpcVersion, Method: "tools/list", ID: json.RawMessage("1")})) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + + if got := gw.targetHealth.stateOf(targetKindMCP, "alpha"); got != targetHealthHealthy { + t.Errorf("alpha state = %q, want healthy", got) + } + if got := gw.targetHealth.stateOf(targetKindMCP, "beta"); got != targetHealthUnhealthy { + t.Errorf("beta state = %q, want unhealthy (unreachable)", got) + } +} + +// TestHandleMCPFederated_ToolsList_TargetHealth_JSONRPCError_StillHealthy +// proves a server that ANSWERS with its own JSON-RPC-level error is +// still recorded healthy — it responded, which is what target-health +// cares about; only a transport-level failure (err != nil from +// mcpBackendCall) counts against it. +func TestHandleMCPFederated_ToolsList_TargetHealth_JSONRPCError_StillHealthy(t *testing.T) { + alpha := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + var req jsonrpcRequest + _ = json.NewDecoder(r.Body).Decode(&req) + w.Header().Set("Content-Type", "application/json") + _ = json.NewEncoder(w).Encode(jsonrpcResponse{ID: req.ID, Error: &jsonrpcError{Code: -32000, Message: "tools unavailable"}}) + })) + defer alpha.Close() + + cfg := newFederationTestConfig(alpha.URL, alpha.URL, false) + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, newFederatedRequest(t, "sk-alice", jsonrpcRequest{JSONRPC: jsonrpcVersion, Method: "tools/list", ID: json.RawMessage("1")})) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + + if got := gw.targetHealth.stateOf(targetKindMCP, "alpha"); got != targetHealthHealthy { + t.Errorf("alpha state = %q, want healthy — a JSON-RPC-level error still means the server answered", got) + } +} + +// TestHandleMCPFederated_ToolsCall_TargetHealth_RecordsResolvedServerOnly +// proves tools/call records health for the ONE resolved server, never +// the other configured-but-uncontacted one. +func TestHandleMCPFederated_ToolsCall_TargetHealth_RecordsResolvedServerOnly(t *testing.T) { + alpha := newMockJSONRPCServer(t, nil) + beta := newMockJSONRPCServer(t, nil) + cfg := newFederationTestConfig(alpha.srv.URL, beta.srv.URL, false) + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + callParams, _ := json.Marshal(mcpToolCallParams{Name: "alpha_lookup"}) + rec := httptest.NewRecorder() + h.ServeHTTP(rec, newFederatedRequest(t, "sk-alice", jsonrpcRequest{ + JSONRPC: jsonrpcVersion, Method: "tools/call", ID: json.RawMessage("5"), Params: callParams, + })) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + + if got := gw.targetHealth.stateOf(targetKindMCP, "alpha"); got != targetHealthHealthy { + t.Errorf("alpha state = %q, want healthy", got) + } + if got := gw.targetHealth.stateOf(targetKindMCP, "beta"); got != targetHealthUnknown { + t.Errorf("beta state = %q, want unknown (never contacted)", got) + } +} + +// TestHandleMCPFederated_ToolsCall_TargetHealth_UnreachableServer_RecordsUnhealthy +// proves a resolved-but-unreachable backend records a failure even +// though the client sees a generic JSON-RPC internal error, not a raw +// transport error. +func TestHandleMCPFederated_ToolsCall_TargetHealth_UnreachableServer_RecordsUnhealthy(t *testing.T) { + cfg := newFederationTestConfig("http://127.0.0.1:1", "http://127.0.0.1:1", false) + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + callParams, _ := json.Marshal(mcpToolCallParams{Name: "alpha_lookup"}) + rec := httptest.NewRecorder() + h.ServeHTTP(rec, newFederatedRequest(t, "sk-alice", jsonrpcRequest{ + JSONRPC: jsonrpcVersion, Method: "tools/call", ID: json.RawMessage("5"), Params: callParams, + })) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + + if got := gw.targetHealth.stateOf(targetKindMCP, "alpha"); got != targetHealthUnhealthy { + t.Errorf("alpha state = %q, want unhealthy", got) + } +} diff --git a/routes_passthrough.go b/routes_passthrough.go index 37fb3a0..dd99abb 100644 --- a/routes_passthrough.go +++ b/routes_passthrough.go @@ -910,8 +910,27 @@ func (g *Gateway) handlePassthrough(w http.ResponseWriter, r *http.Request, u *u // nil unless accountJSON was true and the response's Content-Type was // application/json. type proxyResult struct { - tee *cappedAccountingBuffer + tee *cappedAccountingBuffer + // status is the upstream response's own status code, once headers + // were actually written to w — 0 when proxyUpstream returned before + // ever writing them (a build/connection failure, or a client cancel + // before the request was even sent). Additive field for + // feat/target-health's passive recording (recordTargetProxyHealth, + // target_health.go): ok=false alone conflates "the upstream never + // answered at all" with "it answered with a 5xx", which that + // feature's failure rule needs to distinguish. Field order (pointer, + // then int, then the two bools) is fieldalignment-sensitive, the same + // convention this package's other structs already follow. + status int isJSON bool + // clientCanceled is true exactly when either of proxyUpstream's own + // errors.Is(err, context.Canceled) branches fired — the CLIENT, not + // the upstream, ended the request, whether before the upstream call + // was even sent or mid-copy of an already-started response. + // feat/target-health's passive recording must record NOTHING for + // this case (handleTargetProxy's own doc comment, mcp_a2a.go): a + // client hanging up says nothing about the target's own health. + clientCanceled bool } // proxyUpstream is the shared reverse-proxy core behind both native @@ -1054,7 +1073,7 @@ func (g *Gateway) proxyUpstream(w http.ResponseWriter, r *http.Request, upstream cancel() if errors.Is(err, context.Canceled) { g.logf("%s: client canceled request: %v", logPrefix, err) - return proxyResult{}, false + return proxyResult{clientCanceled: true}, false } g.errorf("%s: upstream connection error: %v", logPrefix, err) writeOAIError(w, http.StatusBadGateway, "server_error", "upstream connection error") @@ -1099,10 +1118,10 @@ func (g *Gateway) proxyUpstream(w http.ResponseWriter, r *http.Request, upstream // — the latter falls through to the errorf below, unchanged. if errors.Is(err, context.Canceled) { g.logf("%s: client canceled request: %v", logPrefix, err) - return proxyResult{isJSON: isJSON, tee: tee}, false + return proxyResult{isJSON: isJSON, tee: tee, status: resp.StatusCode, clientCanceled: true}, false } g.errorf("%s: stream response body: %v", logPrefix, err) - return proxyResult{isJSON: isJSON, tee: tee}, false + return proxyResult{isJSON: isJSON, tee: tee, status: resp.StatusCode}, false } - return proxyResult{isJSON: isJSON, tee: tee}, true + return proxyResult{isJSON: isJSON, tee: tee, status: resp.StatusCode}, true } diff --git a/target_health.go b/target_health.go new file mode 100644 index 0000000..33cdeb7 --- /dev/null +++ b/target_health.go @@ -0,0 +1,524 @@ +package traefikllmgateway + +import ( + "context" + "errors" + "fmt" + "net/http" + "sync" + "sync/atomic" + "time" +) + +// This file implements feat/target-health: a per-replica, in-memory +// health tracker for MCP servers and A2A agents ("targets"), which have +// no health signal today the way providers do (registry.go's discovery +// circuit breaker, failover.go's requestHealthTracker). Two feeds keep +// it current: always-on PASSIVE recording from real request traffic +// (handleTargetProxy, mcp_a2a.go; mcpFederatedToolsList/ +// mcpFederatedToolsCall, mcp_federation.go) and an opt-in, lazy ACTIVE +// probe sweep (maybeSweepTargetHealth, below). Exposure is always on +// too: GET /admin/api/targets (admin.go) and the llmgateway_target_healthy +// gauge (metrics.go) both read this tracker regardless of +// Config.TargetHealth.Enabled — that flag gates only the active probe +// sweep. This tracker is OBSERVE-ONLY: nothing in mcp_a2a.go or +// mcp_federation.go ever skips a server or agent because it reports +// unhealthy — federation routing behavior is unchanged by this feature. + +// targetHealthState is the tri-state health readout stateOf/snapshot +// report for one target, mirroring the discovery breaker's healthState +// string shape (registry.go's providerState) so the admin API and +// dashboard can treat both consistently. +type targetHealthState string + +const ( + // targetHealthUnknown: the tracker has never recorded an observation + // (probe or traffic) for this (kind, name) — a target configured but + // never yet reached. + targetHealthUnknown targetHealthState = "unknown" + // targetHealthHealthy: recorded at least once, and consecutiveFailures + // has not yet reached failureThreshold. This DELIBERATELY includes a + // target whose most recent single observation was itself a failure: + // 1 or 2 recent failures after a success still read "healthy" until + // the configured threshold is actually crossed — the same + // consecutive-failure gate the discovery circuit breaker uses + // (registry.go's providerState/recordHealthLocked), reimplemented + // independently here since this tracker carries no open/half-open + // state machine of its own (see this file's own package doc comment + // for why). + targetHealthHealthy targetHealthState = "healthy" + // targetHealthUnhealthy: consecutiveFailures >= failureThreshold. + targetHealthUnhealthy targetHealthState = "unhealthy" +) + +// Source values record's callers pass — which mechanism produced the +// last observation, exposed on GET /admin/api/targets and stored per +// entry. +const ( + targetHealthSourceProbe = "probe" + targetHealthSourceTraffic = "traffic" +) + +// targetHealthMaxErrorRunes bounds targetHealthEntry.lastError: an +// upstream MCP/A2A target's own error text is not operator-controlled +// the way its URL is, so a pathological error string must not grow this +// in-memory tracker unbounded. Runes, not bytes (truncateRunes, below) +// — a byte-level cut could split a multi-byte UTF-8 sequence. +const targetHealthMaxErrorRunes = 200 + +// targetHealthKey identifies one tracked target by routing kind +// (targetKindMCP or targetKindAgent, mcp_a2a.go — NOT scopeKindAgent, +// which is the limiter/admin-API-facing "agent" spelling for a2a +// targets) and configured name. +type targetHealthKey struct { + kind string + name string +} + +// targetHealthEntry is one target's current health state, guarded by its +// owning tracker's own mu (never its own) — mirrors latencyHistogram's +// identical "guarded by the parent store's lock" convention +// (metrics.go). +type targetHealthEntry struct { + lastCheck time.Time + lastError string + source string + latency time.Duration + consecutiveFailures int + lastOK bool +} + +// targetHealthTracker is feat/target-health's own per-pod, in-memory +// health signal for every configured MCP server and A2A agent. +// Deliberately separate from requestHealthTracker (failover.go) and the +// discovery circuit breaker (registry.go): this tracker carries no +// open/half-open/backoff state machine and never gates routing — it +// exists purely for operational visibility. +// +// Every method is nil-receiver-safe, matching this package's own +// nil-means-disabled convention (requestHealthTracker's own doc +// comment, failover.go) — a Gateway assembled directly in a test, +// bypassing newGateway, degrades to "every target reads unknown" rather +// than a nil-pointer panic, even though newGateway itself always +// constructs a real one (see Gateway.targetHealth's own doc comment, +// llmgateway.go). +type targetHealthTracker struct { + entries map[targetHealthKey]*targetHealthEntry + nowFn func() time.Time + // failureThreshold is TargetHealthConfig.FailureThreshold, validated + // and defaulted once at construction (validateTargetHealthConfig) — + // copied here rather than re-read from Config on every stateOf call, + // the same resolved-value-not-raw-config shape breakerConfig/ + // failoverConfig already use. + failureThreshold int + mu sync.Mutex +} + +// newTargetHealthTracker returns an empty tracker: every target reads +// "unknown" until its first recorded observation. threshold is the +// resolved (validated, defaulted) TargetHealthConfig.FailureThreshold. +func newTargetHealthTracker(threshold int) *targetHealthTracker { + return &targetHealthTracker{entries: make(map[targetHealthKey]*targetHealthEntry), nowFn: time.Now, failureThreshold: threshold} +} + +// record accounts one observation (a real proxied request, or an active +// probe) for (kind, name): success resets consecutiveFailures to 0 and +// clears lastError; failure increments consecutiveFailures and stores +// err's message, truncated to targetHealthMaxErrorRunes (err may be nil +// even on failure — a caller with no Go error to attach, e.g. a bad +// HTTP status alone, still leaves lastError at whatever it previously +// held rather than clearing it, since there IS a new failure to report). +// source is targetHealthSourceProbe or targetHealthSourceTraffic — +// whichever mechanism produced this observation. +func (t *targetHealthTracker) record(kind, name string, ok bool, err error, latency time.Duration, source string) { + if t == nil || name == "" { + return + } + t.mu.Lock() + defer t.mu.Unlock() + key := targetHealthKey{kind: kind, name: name} + e, exists := t.entries[key] + if !exists { + e = &targetHealthEntry{} + t.entries[key] = e + } + e.lastCheck = t.nowFn() + e.lastOK = ok + e.latency = latency + e.source = source + if ok { + e.consecutiveFailures = 0 + e.lastError = "" + return + } + e.consecutiveFailures++ + if err != nil { + e.lastError = truncateRunes(err.Error(), targetHealthMaxErrorRunes) + } +} + +// stateOf reports (kind, name)'s current targetHealthState — see this +// type's own doc comment for the exact unknown/healthy/unhealthy rule. +func (t *targetHealthTracker) stateOf(kind, name string) targetHealthState { + if t == nil { + return targetHealthUnknown + } + t.mu.Lock() + defer t.mu.Unlock() + e, ok := t.entries[targetHealthKey{kind: kind, name: name}] + if !ok { + return targetHealthUnknown + } + return t.stateForLocked(e) +} + +// stateForLocked derives e's targetHealthState. Caller must hold t.mu. +// Split out of stateOf/snapshot so both apply the identical rule. +func (t *targetHealthTracker) stateForLocked(e *targetHealthEntry) targetHealthState { + if e.consecutiveFailures >= t.failureThreshold { + return targetHealthUnhealthy + } + return targetHealthHealthy +} + +// targetHealthSnapshot is one target's fully-copied health state, safe +// to read after targetHealthTracker.snapshot returns without holding its +// lock — mirrors latencySnapshot's identical shape (metrics.go). +type targetHealthSnapshot struct { + lastCheck time.Time + state targetHealthState + lastError string + source string + latency time.Duration + consecutiveFailures int +} + +// snapshot returns a copy of (kind, name)'s current health state — +// buildAdminTargets (admin.go) and writeTargetMetrics (metrics.go) both +// read through this, once per configured target, rather than exposing +// t.entries directly. A target this tracker has never observed returns +// a zero-valued snapshot with state targetHealthUnknown. +func (t *targetHealthTracker) snapshot(kind, name string) targetHealthSnapshot { + if t == nil { + return targetHealthSnapshot{state: targetHealthUnknown} + } + t.mu.Lock() + defer t.mu.Unlock() + e, ok := t.entries[targetHealthKey{kind: kind, name: name}] + if !ok { + return targetHealthSnapshot{state: targetHealthUnknown} + } + return targetHealthSnapshot{ + state: t.stateForLocked(e), + lastCheck: e.lastCheck, + lastError: e.lastError, + source: e.source, + latency: e.latency, + consecutiveFailures: e.consecutiveFailures, + } +} + +// truncateRunes bounds s to at most n runes, decoding as UTF-8 rather +// than slicing raw bytes — a byte-level cut on an arbitrary upstream +// error string could split a multi-byte rune (escapeLabelValue's own +// doc comment, metrics.go, is the identical concern applied to a +// different string). +func truncateRunes(s string, n int) string { + r := []rune(s) + if len(r) <= n { + return s + } + return string(r[:n]) +} + +// --- config: TargetHealthConfig validation --- + +// defaultTargetHealthProbeInterval/min/max bound TargetHealthConfig. +// ProbeInterval; defaultTargetHealthFailureThreshold/max bound +// TargetHealthConfig.FailureThreshold. See TargetHealthConfig's own doc +// comment (llmgateway.go) for what each governs. +const ( + defaultTargetHealthProbeInterval = 60 * time.Second + minTargetHealthProbeInterval = 10 * time.Second + maxTargetHealthProbeInterval = time.Hour + defaultTargetHealthFailureThreshold = 3 + maxTargetHealthFailureThreshold = 100 +) + +// targetHealthConfig is TargetHealthConfig, validated and defaulted once +// at construction (newGateway, llmgateway.go) — mirrors breakerConfig/ +// failoverConfig's own resolved-value-not-raw-config shape. +type targetHealthConfig struct { + probeInterval time.Duration + failureThreshold int + enabled bool +} + +// validateTargetHealthConfig validates thc and returns the resolved +// targetHealthConfig newGateway attaches to the Gateway. thc's zero +// value (no targetHealth block at all) resolves to every default below +// unchanged: enabled stays false (a deployment that predates this +// feature, or never configures this block, sends no active probe +// traffic), matching FailoverConfig's own "off unless explicitly opted +// in" precedent (failover.go). +func validateTargetHealthConfig(thc TargetHealthConfig) (targetHealthConfig, error) { + interval := defaultTargetHealthProbeInterval + if thc.ProbeInterval != "" { + d, err := time.ParseDuration(thc.ProbeInterval) + if err != nil { + return targetHealthConfig{}, fmt.Errorf("llmgateway: targetHealth.probeInterval %q is invalid: %w", thc.ProbeInterval, err) + } + if d < minTargetHealthProbeInterval || d > maxTargetHealthProbeInterval { + return targetHealthConfig{}, fmt.Errorf("llmgateway: targetHealth.probeInterval must be between %s and %s, got %q", minTargetHealthProbeInterval, maxTargetHealthProbeInterval, thc.ProbeInterval) + } + interval = d + } + + threshold := thc.FailureThreshold + if threshold == 0 { + threshold = defaultTargetHealthFailureThreshold + } + if threshold < 1 || threshold > maxTargetHealthFailureThreshold { + return targetHealthConfig{}, fmt.Errorf("llmgateway: targetHealth.failureThreshold must be between 1 and %d, got %d", maxTargetHealthFailureThreshold, threshold) + } + + return targetHealthConfig{enabled: thc.Enabled, probeInterval: interval, failureThreshold: threshold}, nil +} + +// --- active probes: opt-in, lazy, single-flight --- + +// targetHealthMaxProbeTimeout caps how long any ONE active probe may +// run, regardless of Config.RequestTimeout — a probe is a cheap, +// synchronous health check, not real traffic, and defaultRequestTimeout +// (timeout.go) is 5 minutes: without this cap, one hung MCP server or +// agent could tie up a probe goroutine for that entire duration. +const targetHealthMaxProbeTimeout = 10 * time.Second + +// targetHealthProbeTimeout resolves the timeout ONE active probe gets: +// requestTimeout (g.targetTimeout), capped at +// targetHealthMaxProbeTimeout. Written as a small helper rather than the +// Go 1.21+ builtin min: this plugin runs interpreted under Yaegi, and +// this repo's own constraints call for stdlib-only, builtin-free helpers +// where a construct's interpreter support is unverified. +func targetHealthProbeTimeout(requestTimeout time.Duration) time.Duration { + if requestTimeout <= 0 || requestTimeout > targetHealthMaxProbeTimeout { + return targetHealthMaxProbeTimeout + } + return requestTimeout +} + +// maybeSweepTargetHealth is called at the top of every route a scrape or +// a dashboard poll can reach (serveMetrics, metrics.go; serveAdminTargets/ +// handleMCPServers/handleAgents, admin.go/mcp_a2a.go) — that traffic IS +// the heartbeat: this plugin has no Close hook under Traefik's hot +// reload (Gateway.Close's own doc comment, llmgateway.go) and therefore +// starts no timer or long-lived goroutine of its own here either, +// mirroring modelRegistry.maybeRefresh's identical reasoning +// (registry.go). +// +// Returns immediately when disabled. Otherwise: g.targetHealthSweeping +// is the single-flight gate (an atomic CAS, not a mutex, since every +// caller reaches this on a live request path and must never block +// behind a lock another such call already holds) — a CAS that fails +// means either a sweep is already in flight, in which case returning is +// exactly right regardless of how long ago it started, or another +// goroutine just won the race to start this interval's sweep, in which +// case returning is exactly right too. The interval check above the CAS +// is a cheap early-out only; the CAS itself is what actually enforces +// "at most one sweep in flight, and at most one starts per interval". +func (g *Gateway) maybeSweepTargetHealth() { + if !g.targetHealthCfg.enabled { + return + } + last := atomic.LoadInt64(&g.targetHealthLastSweepUnixNano) + if last != 0 && time.Duration(time.Now().UnixNano()-last) < g.targetHealthCfg.probeInterval { + return + } + if !atomic.CompareAndSwapInt32(&g.targetHealthSweeping, 0, 1) { + return + } + atomic.StoreInt64(&g.targetHealthLastSweepUnixNano, time.Now().UnixNano()) + go g.sweepTargetHealth() //nolint:gosec // G118: self-terminating, bounded by mcpFederatedFanoutConcurrency*targetHealthMaxProbeTimeout worst case, and always clears targetHealthSweeping on return (including on panic) — see maybeRefresh's identical reasoning, registry.go, for why this plugin accepts a bounded, self-terminating background goroutine despite having no Close hook to await it +} + +// sweepTargetHealth performs one active probe sweep: every configured +// MCP server and agent, concurrently, behind a semaphore of +// mcpFederatedFanoutConcurrency (mcp_federation.go) — reusing federation's +// own fan-out concurrency constant rather than adding a second one for +// an identical "how many outbound target requests at once" question. +// Always clears g.targetHealthSweeping on return, even on panic +// (mirrors modelRegistry.refreshProvider's own deferred-recover +// reasoning, registry.go — this goroutine has no ServeHTTP caller to +// unwind into either). +func (g *Gateway) sweepTargetHealth() { + defer atomic.StoreInt32(&g.targetHealthSweeping, 0) + defer func() { + if rec := recover(); rec != nil { + g.logf("target health: sweep panicked: %v", rec) + } + }() + + timeout := targetHealthProbeTimeout(g.targetTimeout) + + var wg sync.WaitGroup + sem := make(chan struct{}, mcpFederatedFanoutConcurrency) + + for name, tc := range g.cfg.MCPServers { + if tc == nil { + continue + } + wg.Add(1) + go func(name, url string) { + defer wg.Done() + defer func() { + if rec := recover(); rec != nil { + g.logf("target health: probe for mcp %q panicked: %v", name, rec) + } + }() + sem <- struct{}{} + defer func() { <-sem }() + g.probeMCPTarget(name, url, timeout) + }(name, tc.URL) + } + for name, ac := range g.cfg.Agents { + if ac == nil { + continue + } + wg.Add(1) + go func(name, url, card string) { + defer wg.Done() + defer func() { + if rec := recover(); rec != nil { + g.logf("target health: probe for agent %q panicked: %v", name, rec) + } + }() + sem <- struct{}{} + defer func() { <-sem }() + g.probeAgentTarget(name, url, card, timeout) + }(name, ac.URL, ac.Card) + } + wg.Wait() +} + +// probeMCPTarget performs one active probe of MCP server name at +// rawURL, bounded by timeout, and records the result with source +// "probe". A legacy HTTP+SSE-transport server (isLegacySSETransportURL, +// mcp_federation.go) gets a plain GET with its body closed unread +// (probeLegacySSE, below); every other server gets the same +// initialize/close handshake mcpBackendCall's own fallback path already +// uses (mcpBackendHandshake/mcpBackendCloseSession, mcp_federation.go) +// — a JSON-RPC error answering "initialize" is a failure carrying that +// message, exactly like a transport-level error. +func (g *Gateway) probeMCPTarget(name, rawURL string, timeout time.Duration) { + start := time.Now() + + if isLegacySSETransportURL(rawURL) { + ctx, cancel := context.WithTimeout(context.Background(), timeout) + ok, err := g.probeLegacySSE(ctx, rawURL) + cancel() + g.targetHealth.record(targetKindMCP, name, ok, err, time.Since(start), targetHealthSourceProbe) + return + } + + ctx, cancel := context.WithTimeout(context.Background(), timeout) + sessionID, err := g.mcpBackendHandshake(ctx, rawURL, mcpBackendResponseMaxBytes) + cancel() + ok := err == nil + if ok && sessionID != "" { + closeCtx, closeCancel := context.WithTimeout(context.Background(), mcpSessionCloseTimeout) + g.mcpBackendCloseSession(closeCtx, rawURL, sessionID) + closeCancel() + } + g.targetHealth.record(targetKindMCP, name, ok, err, time.Since(start), targetHealthSourceProbe) +} + +// probeLegacySSE probes a legacy HTTP+SSE-transport MCP server (URL path +// ends "/sse", isLegacySSETransportURL) with a plain GET: ok iff no +// transport error and the response status is under 500. The body is +// closed IMMEDIATELY after headers, never read — an SSE endpoint streams +// indefinitely, so reading it would hang the probe for its entire +// timeout budget on every sweep. +func (g *Gateway) probeLegacySSE(ctx context.Context, rawURL string) (bool, error) { + req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil) //nolint:gosec // operator-configured target URL, validated at construction (validateTargetURLs, mcp_a2a.go) + if err != nil { + return false, err + } + resp, err := g.targetClient.Do(req) + if err != nil { + return false, err + } + _ = resp.Body.Close() //nolint:errcheck // deliberately unread — see this function's own doc comment + if resp.StatusCode >= http.StatusInternalServerError { + return false, fmt.Errorf("legacy sse probe: upstream returned HTTP %d", resp.StatusCode) + } + return true, nil +} + +// probeAgentTarget performs one active probe of agent name: a GET of +// baseURL+cardPath (AgentConfig.Card, or defaultAgentCardPath when empty +// — mcp_a2a.go), bounded by timeout. ok iff no transport error and the +// response status is under 500 — a 404 counts as reachable (e.g. an +// umbrella agent whose root has no card of its own), the identical +// "any status under 500 proves the target answered" rule handleTargetProxy's +// own passive recording applies (recordTargetProxyHealth, below). The +// body is closed without being read: an agent-card probe only needs the +// status. +func (g *Gateway) probeAgentTarget(name, baseURL, cardPath string, timeout time.Duration) { + if cardPath == "" { + cardPath = defaultAgentCardPath + } + start := time.Now() + ctx, cancel := context.WithTimeout(context.Background(), timeout) + defer cancel() + + req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+cardPath, nil) //nolint:gosec // operator-configured target URL, validated at construction (validateTargetURLs, mcp_a2a.go) + if err != nil { + g.targetHealth.record(targetKindAgent, name, false, err, time.Since(start), targetHealthSourceProbe) + return + } + resp, err := g.targetClient.Do(req) + if err != nil { + g.targetHealth.record(targetKindAgent, name, false, err, time.Since(start), targetHealthSourceProbe) + return + } + _ = resp.Body.Close() //nolint:errcheck // read-side close; nothing actionable on failure + ok := resp.StatusCode < http.StatusInternalServerError + var probeErr error + if !ok { + probeErr = fmt.Errorf("agent probe: upstream returned HTTP %d", resp.StatusCode) + } + g.targetHealth.record(targetKindAgent, name, ok, probeErr, time.Since(start), targetHealthSourceProbe) +} + +// --- passive recording: handleTargetProxy (mcp_a2a.go) --- + +// recordTargetProxyHealth applies handleTargetProxy's own passive +// recording rule to one proxyUpstream result (routes_passthrough.go): +// failure iff the proxy attempt itself failed for a reason other than +// the client canceling, OR the upstream answered with a 5xx; otherwise +// success — any status under 500 counts as reachable, 4xx included, +// since a 4xx still proves the target itself answered. A client cancel +// (result.clientCanceled) records nothing at all: a caller hanging up +// says nothing about the target's own health. +func (g *Gateway) recordTargetProxyHealth(kind, name string, result proxyResult, ok bool, latency time.Duration) { + if result.clientCanceled { + return + } + failed := !ok || result.status >= http.StatusInternalServerError + var err error + if failed { + err = targetProxyHealthError(ok, result.status) + } + g.targetHealth.record(kind, name, !failed, err, latency, targetHealthSourceTraffic) +} + +// targetProxyHealthError builds a short, bounded description for a +// failed passive observation. proxyUpstream itself already logged the +// real underlying error; this is only what targetHealthEntry.lastError +// — exposed via GET /admin/api/targets — shows an operator. +func targetProxyHealthError(ok bool, status int) error { + if !ok { + return errors.New("target proxy: upstream request failed") + } + return fmt.Errorf("target proxy: upstream returned HTTP %d", status) +} diff --git a/target_health_test.go b/target_health_test.go new file mode 100644 index 0000000..fc6f1cc --- /dev/null +++ b/target_health_test.go @@ -0,0 +1,413 @@ +package traefikllmgateway + +import ( + "context" + "errors" + "net/http" + "net/http/httptest" + "strings" + "sync" + "sync/atomic" + "testing" + "time" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +// --- targetHealthTracker: state machine --- + +func TestTargetHealthTracker_NeverRecorded_ReadsUnknown(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + assert.Equal(t, targetHealthUnknown, tr.stateOf(targetKindMCP, "alpha")) +} + +func TestTargetHealthTracker_NilReceiver_Safe(t *testing.T) { + t.Parallel() + var tr *targetHealthTracker + assert.NotPanics(t, func() { + tr.record(targetKindMCP, "alpha", true, nil, time.Millisecond, targetHealthSourceTraffic) + }) + assert.Equal(t, targetHealthUnknown, tr.stateOf(targetKindMCP, "alpha")) + snap := tr.snapshot(targetKindMCP, "alpha") + assert.Equal(t, targetHealthUnknown, snap.state) +} + +func TestTargetHealthTracker_SingleSuccess_ReadsHealthy(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + tr.record(targetKindMCP, "alpha", true, nil, 5*time.Millisecond, targetHealthSourceTraffic) + assert.Equal(t, targetHealthHealthy, tr.stateOf(targetKindMCP, "alpha")) +} + +// TestTargetHealthTracker_BelowThreshold_StaysHealthy proves the +// documented exception: 1 or 2 recent failures after a success still +// reads "healthy" until consecutiveFailures actually reaches the +// configured threshold (targetHealthTracker's own doc comment). +func TestTargetHealthTracker_BelowThreshold_StaysHealthy(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + tr.record(targetKindMCP, "alpha", true, nil, 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", false, errors.New("boom"), 0, targetHealthSourceTraffic) + assert.Equal(t, targetHealthHealthy, tr.stateOf(targetKindMCP, "alpha"), "1 failure of threshold 3 must still read healthy") + tr.record(targetKindMCP, "alpha", false, errors.New("boom again"), 0, targetHealthSourceTraffic) + assert.Equal(t, targetHealthHealthy, tr.stateOf(targetKindMCP, "alpha"), "2 failures of threshold 3 must still read healthy") +} + +func TestTargetHealthTracker_ReachesThreshold_ReadsUnhealthy(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + for i := 0; i < 3; i++ { + tr.record(targetKindMCP, "alpha", false, errors.New("boom"), 0, targetHealthSourceTraffic) + } + assert.Equal(t, targetHealthUnhealthy, tr.stateOf(targetKindMCP, "alpha")) +} + +func TestTargetHealthTracker_SuccessAfterUnhealthy_RecoversToHealthy(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(2) + tr.record(targetKindMCP, "alpha", false, errors.New("boom"), 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", false, errors.New("boom"), 0, targetHealthSourceTraffic) + require.Equal(t, targetHealthUnhealthy, tr.stateOf(targetKindMCP, "alpha")) + + tr.record(targetKindMCP, "alpha", true, nil, 0, targetHealthSourceTraffic) + assert.Equal(t, targetHealthHealthy, tr.stateOf(targetKindMCP, "alpha")) + snap := tr.snapshot(targetKindMCP, "alpha") + assert.Equal(t, 0, snap.consecutiveFailures, "a success must reset consecutiveFailures to 0") + assert.Empty(t, snap.lastError, "a success must clear lastError") +} + +func TestTargetHealthTracker_ErrorString_BoundedLength(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + long := strings.Repeat("x", targetHealthMaxErrorRunes+500) + tr.record(targetKindMCP, "alpha", false, errors.New(long), 0, targetHealthSourceProbe) + snap := tr.snapshot(targetKindMCP, "alpha") + assert.LessOrEqual(t, len([]rune(snap.lastError)), targetHealthMaxErrorRunes) + assert.Equal(t, strings.Repeat("x", targetHealthMaxErrorRunes), snap.lastError) +} + +func TestTargetHealthTracker_ShortError_Unchanged(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + tr.record(targetKindMCP, "alpha", false, errors.New("dial tcp: connection refused"), 0, targetHealthSourceProbe) + snap := tr.snapshot(targetKindMCP, "alpha") + assert.Equal(t, "dial tcp: connection refused", snap.lastError) +} + +func TestTargetHealthTracker_KeyedByKindAndName_Independent(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(1) + tr.record(targetKindMCP, "shared", false, errors.New("boom"), 0, targetHealthSourceTraffic) + assert.Equal(t, targetHealthUnhealthy, tr.stateOf(targetKindMCP, "shared")) + assert.Equal(t, targetHealthUnknown, tr.stateOf(targetKindAgent, "shared"), "an mcp server and an agent sharing a name must track independently") +} + +func TestTargetHealthTracker_Snapshot_FieldsPopulated(t *testing.T) { + t.Parallel() + now := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC) + tr := newTargetHealthTracker(3) + tr.nowFn = func() time.Time { return now } + tr.record(targetKindAgent, "beta", true, nil, 42*time.Millisecond, targetHealthSourceProbe) + + snap := tr.snapshot(targetKindAgent, "beta") + assert.Equal(t, targetHealthHealthy, snap.state) + assert.Equal(t, now, snap.lastCheck) + assert.Equal(t, 42*time.Millisecond, snap.latency) + assert.Equal(t, targetHealthSourceProbe, snap.source) + assert.Equal(t, 0, snap.consecutiveFailures) +} + +func TestTargetHealthTracker_ConcurrentRecord_NoRace(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + var wg sync.WaitGroup + for i := 0; i < 50; i++ { + wg.Add(1) + go func(i int) { + defer wg.Done() + tr.record(targetKindMCP, "alpha", i%2 == 0, errors.New("x"), time.Millisecond, targetHealthSourceTraffic) + }(i) + } + wg.Wait() + _ = tr.stateOf(targetKindMCP, "alpha") +} + +// --- TargetHealthConfig validation --- + +func TestValidateTargetHealthConfig_Defaults(t *testing.T) { + t.Parallel() + thc, err := validateTargetHealthConfig(TargetHealthConfig{}) + require.NoError(t, err) + assert.False(t, thc.enabled) + assert.Equal(t, defaultTargetHealthProbeInterval, thc.probeInterval) + assert.Equal(t, defaultTargetHealthFailureThreshold, thc.failureThreshold) +} + +func TestValidateTargetHealthConfig_ExplicitEnable(t *testing.T) { + t.Parallel() + thc, err := validateTargetHealthConfig(TargetHealthConfig{Enabled: true}) + require.NoError(t, err) + assert.True(t, thc.enabled) +} + +func TestValidateTargetHealthConfig_ProbeIntervalBounds(t *testing.T) { + t.Parallel() + _, err := validateTargetHealthConfig(TargetHealthConfig{ProbeInterval: "1s"}) + assert.Error(t, err, "below the 10s floor must be rejected") + + _, err = validateTargetHealthConfig(TargetHealthConfig{ProbeInterval: "2h"}) + assert.Error(t, err, "above the 1h ceiling must be rejected") + + _, err = validateTargetHealthConfig(TargetHealthConfig{ProbeInterval: "not-a-duration"}) + assert.Error(t, err) + + thc, err := validateTargetHealthConfig(TargetHealthConfig{ProbeInterval: "30s"}) + require.NoError(t, err) + assert.Equal(t, 30*time.Second, thc.probeInterval) +} + +func TestValidateTargetHealthConfig_FailureThresholdBounds(t *testing.T) { + t.Parallel() + _, err := validateTargetHealthConfig(TargetHealthConfig{FailureThreshold: -1}) + assert.Error(t, err) + + _, err = validateTargetHealthConfig(TargetHealthConfig{FailureThreshold: maxTargetHealthFailureThreshold + 1}) + assert.Error(t, err) + + thc, err := validateTargetHealthConfig(TargetHealthConfig{FailureThreshold: 10}) + require.NoError(t, err) + assert.Equal(t, 10, thc.failureThreshold) +} + +func TestNewGateway_TargetHealth_InvalidConfig_ConstructionError(t *testing.T) { + t.Parallel() + cfg := CreateConfig() + cfg.Providers = map[string]*ProviderConfig{"openai": {Type: "openai", APIKey: "k"}} + cfg.TargetHealth = TargetHealthConfig{ProbeInterval: "1s"} + _, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + assert.Error(t, err) +} + +func TestNewGateway_TargetHealth_DisabledByDefault_TrackerStillConstructed(t *testing.T) { + t.Parallel() + cfg := CreateConfig() + cfg.Providers = map[string]*ProviderConfig{"openai": {Type: "openai", APIKey: "k"}} + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + require.NoError(t, err) + gw, ok := h.(*Gateway) + require.True(t, ok) + require.NotNil(t, gw.targetHealth, "the tracker must always be constructed regardless of Enabled — passive recording/exposure stay on unconditionally") + assert.False(t, gw.targetHealthCfg.enabled) +} + +// --- maybeSweepTargetHealth: disabled / enabled / single-flight --- + +func newTargetHealthSweepGateway(t *testing.T, enabled bool, probeInterval time.Duration, mcpURL string) *Gateway { + t.Helper() + adapters := map[string]providerAdapter{"openai": newFakeAdapter("openai")} + cfg := &Config{ + Providers: map[string]*ProviderConfig{"openai": {}}, + MCPServers: map[string]*TargetConfig{"alpha": {URL: mcpURL}}, + } + reg, err := newModelRegistry(adapters, cfg, func(string, ...any) {}) + require.NoError(t, err) + return &Gateway{ + cfg: cfg, + registry: reg, + targetHealth: newTargetHealthTracker(3), + targetHealthCfg: targetHealthConfig{enabled: enabled, probeInterval: probeInterval, failureThreshold: 3}, + targetClient: http.DefaultClient, + targetTimeout: 5 * time.Second, + name: "test", + } +} + +func TestMaybeSweepTargetHealth_Disabled_NoOutboundRequests(t *testing.T) { + t.Parallel() + hits := 0 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + hits++ + w.WriteHeader(http.StatusOK) + })) + defer srv.Close() + + gw := newTargetHealthSweepGateway(t, false, 10*time.Millisecond, srv.URL) + gw.maybeSweepTargetHealth() + // maybeSweepTargetHealth spawns a goroutine when it decides to sweep; + // since it must return immediately when disabled, there is nothing to + // wait on — a brief sleep would only prove absence of a signal we + // never expect to see. + time.Sleep(20 * time.Millisecond) + assert.Equal(t, 0, hits, "a disabled targetHealth must never send an outbound probe") + assert.Equal(t, targetHealthUnknown, gw.targetHealth.stateOf(targetKindMCP, "alpha")) +} + +func TestMaybeSweepTargetHealth_Enabled_ProbesConfiguredServer(t *testing.T) { + t.Parallel() + var hits int32 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + atomic.AddInt32(&hits, 1) + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"jsonrpc":"2.0","id":"federated","result":{"protocolVersion":"2025-11-25","capabilities":{}}}`)) + })) + defer srv.Close() + + gw := newTargetHealthSweepGateway(t, true, time.Hour, srv.URL) + gw.maybeSweepTargetHealth() + waitForCondition(t, func() bool { return atomic.LoadInt32(&hits) > 0 }, time.Second) + waitForCondition(t, func() bool { return gw.targetHealth.stateOf(targetKindMCP, "alpha") == targetHealthHealthy }, time.Second) + + snap := gw.targetHealth.snapshot(targetKindMCP, "alpha") + assert.Equal(t, targetHealthSourceProbe, snap.source) +} + +func TestMaybeSweepTargetHealth_ConcurrentTriggers_SingleFlight(t *testing.T) { + t.Parallel() + var hits int32 + release := make(chan struct{}) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + atomic.AddInt32(&hits, 1) + <-release + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"jsonrpc":"2.0","id":"federated","result":{}}`)) + })) + defer srv.Close() + + gw := newTargetHealthSweepGateway(t, true, time.Hour, srv.URL) + + var wg sync.WaitGroup + for i := 0; i < 20; i++ { + wg.Add(1) + go func() { + defer wg.Done() + gw.maybeSweepTargetHealth() + }() + } + wg.Wait() + + // Give the single in-flight probe time to actually reach the server, + // then release it — regardless of how many goroutines called + // maybeSweepTargetHealth concurrently, at most one outbound request + // must have been sent. + waitForCondition(t, func() bool { return atomic.LoadInt32(&hits) > 0 }, time.Second) + close(release) + waitForCondition(t, func() bool { return gw.targetHealth.stateOf(targetKindMCP, "alpha") != targetHealthUnknown }, time.Second) + assert.Equal(t, int32(1), atomic.LoadInt32(&hits), "concurrent triggers within one interval must produce exactly one sweep") +} + +// TestMaybeSweepTargetHealth_LegacySSE_ClosesBodyWithoutReading proves a +// legacy "/sse" MCP server's probe uses a plain GET and closes the body +// immediately: a test server that never closes its stream must not hang +// the probe. +func TestMaybeSweepTargetHealth_LegacySSE_ClosesBodyWithoutReading(t *testing.T) { + t.Parallel() + headersSent := make(chan struct{}) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "text/event-stream") + w.WriteHeader(http.StatusOK) + close(headersSent) + flusher, ok := w.(http.Flusher) + if ok { + flusher.Flush() + } + <-r.Context().Done() // never closes on its own; relies on the probe not reading + })) + defer srv.Close() + + adapters := map[string]providerAdapter{"openai": newFakeAdapter("openai")} + cfg := &Config{ + Providers: map[string]*ProviderConfig{"openai": {}}, + MCPServers: map[string]*TargetConfig{"alpha": {URL: srv.URL + "/sse"}}, + } + reg, err := newModelRegistry(adapters, cfg, func(string, ...any) {}) + require.NoError(t, err) + gw := &Gateway{ + cfg: cfg, + registry: reg, + targetHealth: newTargetHealthTracker(3), + targetHealthCfg: targetHealthConfig{enabled: true, probeInterval: time.Hour, failureThreshold: 3}, + targetClient: http.DefaultClient, + targetTimeout: 5 * time.Second, + name: "test", + } + gw.maybeSweepTargetHealth() + waitForCondition(t, func() bool { return gw.targetHealth.stateOf(targetKindMCP, "alpha") != targetHealthUnknown }, 2*time.Second) + assert.Equal(t, targetHealthHealthy, gw.targetHealth.stateOf(targetKindMCP, "alpha")) +} + +func TestMaybeSweepTargetHealth_AgentReturns404_ReadsHealthy(t *testing.T) { + t.Parallel() + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusNotFound) + })) + defer srv.Close() + + adapters := map[string]providerAdapter{"openai": newFakeAdapter("openai")} + cfg := &Config{ + Providers: map[string]*ProviderConfig{"openai": {}}, + Agents: map[string]*AgentConfig{"beta": {URL: srv.URL}}, + } + reg, err := newModelRegistry(adapters, cfg, func(string, ...any) {}) + require.NoError(t, err) + gw := &Gateway{ + cfg: cfg, + registry: reg, + targetHealth: newTargetHealthTracker(3), + targetHealthCfg: targetHealthConfig{enabled: true, probeInterval: time.Hour, failureThreshold: 3}, + targetClient: http.DefaultClient, + targetTimeout: 5 * time.Second, + name: "test", + } + gw.maybeSweepTargetHealth() + waitForCondition(t, func() bool { return gw.targetHealth.stateOf(targetKindAgent, "beta") != targetHealthUnknown }, time.Second) + assert.Equal(t, targetHealthHealthy, gw.targetHealth.stateOf(targetKindAgent, "beta"), "a 404 agent-card fetch counts as reachable") +} + +func TestMaybeSweepTargetHealth_AgentReturns503_RecordsFailure(t *testing.T) { + t.Parallel() + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.WriteHeader(http.StatusServiceUnavailable) + })) + defer srv.Close() + + adapters := map[string]providerAdapter{"openai": newFakeAdapter("openai")} + cfg := &Config{ + Providers: map[string]*ProviderConfig{"openai": {}}, + Agents: map[string]*AgentConfig{"beta": {URL: srv.URL}}, + } + reg, err := newModelRegistry(adapters, cfg, func(string, ...any) {}) + require.NoError(t, err) + gw := &Gateway{ + cfg: cfg, + registry: reg, + targetHealth: newTargetHealthTracker(1), + targetHealthCfg: targetHealthConfig{enabled: true, probeInterval: time.Hour, failureThreshold: 1}, + targetClient: http.DefaultClient, + targetTimeout: 5 * time.Second, + name: "test", + } + gw.maybeSweepTargetHealth() + waitForCondition(t, func() bool { return gw.targetHealth.stateOf(targetKindAgent, "beta") != targetHealthUnknown }, time.Second) + assert.Equal(t, targetHealthUnhealthy, gw.targetHealth.stateOf(targetKindAgent, "beta")) +} + +// waitForCondition polls cond until it returns true or deadline elapses, +// failing the test on timeout — used throughout this file's sweep tests +// since the sweep itself runs in a background goroutine with no +// synchronous completion signal (maybeSweepTargetHealth's own doc +// comment: no timers, no long-lived goroutines, fire-and-forget). +func waitForCondition(t *testing.T, cond func() bool, timeout time.Duration) { + t.Helper() + deadline := time.Now().Add(timeout) + for time.Now().Before(deadline) { + if cond() { + return + } + time.Sleep(2 * time.Millisecond) + } + if !cond() { + t.Fatalf("condition not met within %s", timeout) + } +} From a31647f652f093827b2670cc78b05e70923bf552 Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 01:42:49 +0100 Subject: [PATCH 02/15] feat(target-health): expose target health on admin API and metrics Add a health object to each row of GET /admin/api/targets (adminTargetHealthView, admin.go): state, an RFC3339 lastCheck, lastError, source, and latencyMs, every optional field omitted while the target has never been observed. Both serveAdminTargets and the MCP/agent listing routes (handleMCPServers, handleAgents) trigger the active probe sweep before responding, so admin polling and client listings double as the heartbeat that drives it. Add llmgateway_target_healthy to /metrics (metrics.go): a 1/0 gauge labeled by kind (mcp or agent) and target name, with no sample at all for a target the tracker has never observed. serveMetrics triggers the sweep too, so a Prometheus scrape becomes a heartbeat as well. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- admin.go | 44 +++++++++++++++++ admin_test.go | 127 ++++++++++++++++++++++++++++++++++++++++++++++++ metrics.go | 49 +++++++++++++++++++ metrics_test.go | 75 ++++++++++++++++++++++++++++ 4 files changed, 295 insertions(+) diff --git a/admin.go b/admin.go index a1c66b7..748b8f2 100644 --- a/admin.go +++ b/admin.go @@ -1235,13 +1235,54 @@ type adminTargetCountersView struct { // convention (adminUsageEntryView) — rather than always listing every // group name, which would grow with the group catalog for no reason once // nothing is actually restricted. +// +// Health is feat/target-health's own readout (targetHealthView, below). +// Field order (Health first, the struct-typed field, then the strings/ +// slice, then Counters last) is fieldalignment-sensitive, derived +// against a scratch copy the same way this package's other structs +// already document (Config's own doc comment, llmgateway.go). type adminTargetView struct { + Health adminTargetHealthView `json:"health"` Name string `json:"name"` URL string `json:"url"` Access []string `json:"access,omitempty"` Counters adminTargetCountersView `json:"counters"` } +// adminTargetHealthView is one target's feat/target-health readout in +// GET /admin/api/targets — the exact JSON contract the webui's MCP & +// Agents panel codes against. State and ConsecutiveFailures are always +// present; every other field is omitted while State is +// targetHealthUnknown (this tracker has never observed the target), +// since none of them carry a meaningful value yet. LatencyMs is a +// pointer so a genuine 0ms observation still serializes as +// "latencyMs":0 rather than being indistinguishable from "omitted". +// Field order is fieldalignment-derived, the same convention +// adminTargetView's own doc comment above explains. +type adminTargetHealthView struct { + LatencyMs *int64 `json:"latencyMs,omitempty"` + State targetHealthState `json:"state"` + LastCheck string `json:"lastCheck,omitempty"` + LastError string `json:"lastError,omitempty"` + Source string `json:"source,omitempty"` + ConsecutiveFailures int `json:"consecutiveFailures"` +} + +// targetHealthView converts one targetHealthTracker.snapshot result +// (target_health.go) into its JSON view. +func targetHealthView(snap targetHealthSnapshot) adminTargetHealthView { + view := adminTargetHealthView{State: snap.state, ConsecutiveFailures: snap.consecutiveFailures} + if snap.state == targetHealthUnknown { + return view + } + view.LastCheck = snap.lastCheck.UTC().Format(time.RFC3339) + view.LastError = snap.lastError + view.Source = snap.source + ms := snap.latency.Milliseconds() + view.LatencyMs = &ms + return view +} + // adminTargetsResponse is the full body of GET /admin/api/targets (Feature // B, v0.21): every configured MCP server and every configured agent, each // with its own access list and current-window request counters. Both @@ -1339,6 +1380,7 @@ func (g *Gateway) buildAdminTargets() adminTargetsResponse { mcpServers := make([]adminTargetView, len(mcpNames)) for i, name := range mcpNames { mcpServers[i] = adminTargetView{ + Health: targetHealthView(g.targetHealth.snapshot(targetKindMCP, name)), Name: name, URL: sanitizeBaseURL(g.cfg.MCPServers[name].URL), Access: adminTargetAccess(groupSummaries, func(gs groupSummary) []string { return gs.mcpServers }, name), @@ -1348,6 +1390,7 @@ func (g *Gateway) buildAdminTargets() adminTargetsResponse { agents := make([]adminTargetView, len(agentNames)) for i, name := range agentNames { agents[i] = adminTargetView{ + Health: targetHealthView(g.targetHealth.snapshot(targetKindAgent, name)), Name: name, URL: sanitizeBaseURL(g.cfg.Agents[name].URL), Access: adminTargetAccess(groupSummaries, func(gs groupSummary) []string { return gs.agents }, name), @@ -1360,6 +1403,7 @@ func (g *Gateway) buildAdminTargets() adminTargetsResponse { // serveAdminTargets writes buildAdminTargets's result as JSON. func (g *Gateway) serveAdminTargets(w http.ResponseWriter) { + g.maybeSweepTargetHealth() setAdminJSONHeaders(w) _ = json.NewEncoder(w).Encode(g.buildAdminTargets()) } diff --git a/admin_test.go b/admin_test.go index 93b26c2..92bb80f 100644 --- a/admin_test.go +++ b/admin_test.go @@ -6,6 +6,7 @@ import ( "crypto/sha256" "encoding/hex" "encoding/json" + "errors" "fmt" "math" "net/http" @@ -2436,3 +2437,129 @@ func TestParseHistoryScope_ModelIDKeepsLaterSeparators(t *testing.T) { t.Errorf("parseHistoryScope = (%q, %q, %v), want the full model id preserved", kind, id, ok) } } + +// --- feat/target-health: GET /admin/api/targets "health" field --- + +// TestAdminTargets_Health_NeverObserved_UnknownWithOmittedFields proves +// the exact JSON contract for a target this tracker has never observed: +// "state":"unknown", consecutiveFailures present as 0, and every other +// health field (lastCheck/lastError/latencyMs/source) omitted entirely. +func TestAdminTargets_Health_NeverObserved_UnknownWithOmittedFields(t *testing.T) { + t.Parallel() + cfg := newAdminTestConfig() + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: "http://mcp-alpha.internal"}} + h, _ := newAdminGatewayHandle(t, cfg) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, adminRequest(http.MethodGet, adminTargetsPath, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + body := rec.Body.String() + if !strings.Contains(body, `"health":{"state":"unknown","consecutiveFailures":0}`) { + t.Errorf("body = %s, want an unknown target's health object to carry only state and consecutiveFailures", body) + } +} + +// TestAdminTargets_Health_Recorded_AllFieldsPresent proves a target with +// at least one recorded observation carries every health field, and that +// state/source/consecutiveFailures reflect the tracker exactly. +func TestAdminTargets_Health_Recorded_AllFieldsPresent(t *testing.T) { + t.Parallel() + cfg := newAdminTestConfig() + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: "http://mcp-alpha.internal"}} + h, gw := newAdminGatewayHandle(t, cfg) + + gw.targetHealth.record(targetKindMCP, "alpha", true, nil, 12*time.Millisecond, targetHealthSourceTraffic) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, adminRequest(http.MethodGet, adminTargetsPath, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + var got adminTargetsResponse + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { + t.Fatalf("decode: %v", err) + } + if len(got.MCPServers) != 1 { + t.Fatalf("mcpServers = %+v, want exactly 1", got.MCPServers) + } + health := got.MCPServers[0].Health + if health.State != targetHealthHealthy { + t.Errorf("state = %q, want healthy", health.State) + } + if health.LastCheck == "" { + t.Error("want a non-empty lastCheck (RFC3339)") + } + if _, err := time.Parse(time.RFC3339, health.LastCheck); err != nil { + t.Errorf("lastCheck = %q, want RFC3339: %v", health.LastCheck, err) + } + if health.Source != targetHealthSourceTraffic { + t.Errorf("source = %q, want %q", health.Source, targetHealthSourceTraffic) + } + if health.LatencyMs == nil || *health.LatencyMs != 12 { + t.Errorf("latencyMs = %v, want *12", health.LatencyMs) + } + if health.ConsecutiveFailures != 0 { + t.Errorf("consecutiveFailures = %d, want 0", health.ConsecutiveFailures) + } + if health.LastError != "" { + t.Errorf("lastError = %q, want empty (omitted) after a success", health.LastError) + } +} + +// TestAdminTargets_Health_Unhealthy_LastErrorPresent proves an unhealthy +// target's lastError is populated and non-empty. +func TestAdminTargets_Health_Unhealthy_LastErrorPresent(t *testing.T) { + t.Parallel() + cfg := newAdminTestConfig() + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: "http://mcp-alpha.internal"}} + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} + h, gw := newAdminGatewayHandle(t, cfg) + + gw.targetHealth.record(targetKindMCP, "alpha", false, errors.New("dial tcp: connection refused"), 3*time.Millisecond, targetHealthSourceProbe) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, adminRequest(http.MethodGet, adminTargetsPath, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + var got adminTargetsResponse + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { + t.Fatalf("decode: %v", err) + } + health := got.MCPServers[0].Health + if health.State != targetHealthUnhealthy { + t.Errorf("state = %q, want unhealthy", health.State) + } + if health.LastError != "dial tcp: connection refused" { + t.Errorf("lastError = %q, want the recorded error text", health.LastError) + } + if health.Source != targetHealthSourceProbe { + t.Errorf("source = %q, want %q", health.Source, targetHealthSourceProbe) + } +} + +// TestAdminTargets_Health_AgentUsesAgentKind proves an agent row's health +// is read under targetKindAgent, not the mcp kind. +func TestAdminTargets_Health_AgentUsesAgentKind(t *testing.T) { + t.Parallel() + cfg := newAdminTestConfig() + cfg.Agents = map[string]*AgentConfig{"bot1": {URL: "http://agent-bot1.internal"}} + h, gw := newAdminGatewayHandle(t, cfg) + + gw.targetHealth.record(targetKindAgent, "bot1", true, nil, time.Millisecond, targetHealthSourceTraffic) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, adminRequest(http.MethodGet, adminTargetsPath, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + var got adminTargetsResponse + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { + t.Fatalf("decode: %v", err) + } + if len(got.Agents) != 1 || got.Agents[0].Health.State != targetHealthHealthy { + t.Fatalf("agents = %+v, want bot1 healthy", got.Agents) + } +} diff --git a/metrics.go b/metrics.go index f8207ce..b39ad8b 100644 --- a/metrics.go +++ b/metrics.go @@ -170,6 +170,7 @@ func (g *Gateway) metricsSourceAllowed(r *http.Request) bool { // disk cache, and its declared Content-Type must never be second-guessed // by a client's MIME sniffer. func (g *Gateway) serveMetrics(w http.ResponseWriter) { + g.maybeSweepTargetHealth() w.Header().Set("Content-Type", "text/plain; version=0.0.4; charset=utf-8") w.Header().Set("X-Content-Type-Options", "nosniff") w.Header().Set("Cache-Control", "no-store") @@ -448,6 +449,16 @@ const aggregationNotePerProcess = " AGGREGATION ACROSS REPLICAS: this counter li // instant (e.g. one mid-backoff, one already recovered). const aggregationNoteProviderHealthy = " AGGREGATION ACROSS REPLICAS: each replica runs its own discovery circuit breaker in-process, never shared via Redis, so this can legitimately differ per replica. Read it per-instance where possible; if you must aggregate, use min() to surface \"at least one replica sees this provider as unhealthy\" — sum() is meaningless for a 0/1 gauge." +// aggregationNoteTargetHealthy is appended to llmgateway_target_healthy's +// HELP text (feat/target-health): the tracker behind this gauge +// (target_health.go) is per-process, in-memory state, fed by each +// replica's own passive traffic and, when enabled, its own active probe +// sweep — never shared via Redis. A sibling to +// aggregationNoteProviderHealthy above, not a reuse of it: this +// tracker has no discovery step of its own, so that note's own +// reference to "discovery circuit breaker" would not apply here. +const aggregationNoteTargetHealthy = " AGGREGATION ACROSS REPLICAS: each replica tracks this target's health independently from its own passive traffic and, if enabled, its own active probes — never shared via Redis — so this can legitimately differ per replica. Read it per-instance where possible; if you must aggregate, use min() to surface \"at least one replica sees this target as unhealthy\" — sum() is meaningless for a 0/1 gauge." + // aggregationNoteStoreHealth is appended to llmgateway_limit_store_up's // HELP text: whether THIS replica's own connection to the configured // limit store is currently healthy is, by definition, discovered @@ -470,6 +481,7 @@ func (g *Gateway) renderMetrics() []byte { var m metricWriter g.writeUsageMetrics(&m) g.writeProviderMetrics(&m) + g.writeTargetMetrics(&m) g.writeLatencyMetrics(&m) g.writeProvenanceMetrics(&m) g.writeRejectionMetrics(&m) @@ -673,6 +685,43 @@ func (g *Gateway) writeProviderMetrics(m *metricWriter) { } } +// writeTargetMetrics emits llmgateway_target_healthy (feat/target-health): +// 1 for a healthy MCP server or A2A agent, 0 for an unhealthy one, and NO +// sample at all for a target this tracker has never observed — the +// identical "a gap is honest, a fabricated value is not" convention +// writeUsageMetrics/writeProviderMetrics already apply to a storeDown +// read, applied here to "never yet observed" instead of "currently +// unreadable". Iterates every CONFIGURED MCP server and agent (not just +// ones the tracker happens to have an entry for), so a target removed +// from config since its last observation contributes no stale series. +func (g *Gateway) writeTargetMetrics(m *metricWriter) { + m.family("llmgateway_target_healthy", "gauge", + "1 when an MCP server or A2A agent's health (last passive observation or active probe) is healthy, 0 when its consecutive-failure count has reached targetHealth.failureThreshold. No sample while never yet observed."+aggregationNoteTargetHealthy) + + for _, name := range sortedMCPServerNames(g.cfg.MCPServers) { + writeTargetHealthySample(m, g.targetHealth.snapshot(targetKindMCP, name), targetScopeKind(targetKindMCP), name) + } + for _, name := range sortedAgentNames(g.cfg.Agents) { + writeTargetHealthySample(m, g.targetHealth.snapshot(targetKindAgent, name), targetScopeKind(targetKindAgent), name) + } +} + +// writeTargetHealthySample writes llmgateway_target_healthy's one sample +// for (kindLabel, name), skipped entirely while snap's state is unknown +// — see writeTargetMetrics' own doc comment for why. kindLabel is the +// external "mcp"/"agent" spelling (targetScopeKind), never the internal +// routing kind ("a2a") targetHealthTracker itself keys on. +func writeTargetHealthySample(m *metricWriter, snap targetHealthSnapshot, kindLabel, name string) { + if snap.state == targetHealthUnknown { + return + } + healthy := int64(1) + if snap.state == targetHealthUnhealthy { + healthy = 0 + } + m.sampleInt("llmgateway_target_healthy", []metricLabel{{"kind", kindLabel}, {"target", name}}, healthy) +} + // --- upstream latency (feat: instrument upstream latency) --- // // The task: "priority-based throttling that engages when providers are diff --git a/metrics_test.go b/metrics_test.go index 3a0c4f2..6cc675e 100644 --- a/metrics_test.go +++ b/metrics_test.go @@ -3,6 +3,7 @@ package traefikllmgateway import ( "context" "encoding/json" + "errors" "fmt" "math" "net/http" @@ -1494,3 +1495,77 @@ func TestRecordLatency_MetricsDisabled_NoObservationCollected(t *testing.T) { t.Errorf("g.latency has %d entries after a request with metrics disabled, want 0 — no latency observation should ever be collected when metrics is off", len(snaps)) } } + +// --- feat/target-health: llmgateway_target_healthy --- + +// TestMetrics_TargetHealthy_NoSampleWhileUnknown proves a configured but +// never-observed target contributes NO sample at all — the same +// "a gap is honest, a fabricated value is not" rule the store-backed +// families apply to storeDown, applied here to "never yet observed". +func TestMetrics_TargetHealthy_NoSampleWhileUnknown(t *testing.T) { + t.Parallel() + cfg := newMetricsTestConfig() + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: "http://mcp-alpha.internal"}} + h, _ := newMetricsGatewayHandle(t, cfg) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, metricsRequest(http.MethodGet, metricsPathDefault, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200", rec.Code) + } + _, samples := parsePrometheusText(t, rec.Body.Bytes()) + for _, s := range samples { + if s.name == "llmgateway_target_healthy" { + t.Errorf("unexpected sample %v — a never-observed target must emit nothing", s) + } + } +} + +// TestMetrics_TargetHealthy_ReflectsRecordedState proves the gauge +// renders 1 for a healthy MCP server and 0 for an unhealthy agent, with +// the documented kind label values ("mcp"/"agent" — NOT the internal +// routing kind "a2a"). +func TestMetrics_TargetHealthy_ReflectsRecordedState(t *testing.T) { + t.Parallel() + cfg := newMetricsTestConfig() + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: "http://mcp-alpha.internal"}} + cfg.Agents = map[string]*AgentConfig{"bot1": {URL: "http://agent-bot1.internal"}} + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} + h, gw := newMetricsGatewayHandle(t, cfg) + + gw.targetHealth.record(targetKindMCP, "alpha", true, nil, time.Millisecond, targetHealthSourceTraffic) + gw.targetHealth.record(targetKindAgent, "bot1", false, errors.New("boom"), time.Millisecond, targetHealthSourceProbe) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, metricsRequest(http.MethodGet, metricsPathDefault, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200", rec.Code) + } + _, samples := parsePrometheusText(t, rec.Body.Bytes()) + assertSample(t, samples, "llmgateway_target_healthy", map[string]string{"kind": "mcp", "target": "alpha"}, "1") + assertSample(t, samples, "llmgateway_target_healthy", map[string]string{"kind": "agent", "target": "bot1"}, "0") +} + +// TestMetrics_TargetHealthy_UnaffectedByStoreOutage proves this gauge is +// unaffected by a limit-store outage — it reads the in-process +// target-health tracker only, never the store, mirroring +// llmgateway_provider_healthy's own identical independence +// (TestMetrics_StoreDown_SkipsRatherThanFabricatesZero's own doc +// comment explains why that one is asserted present during an outage; +// this is the same claim for this feature's gauge). +func TestMetrics_TargetHealthy_UnaffectedByStoreOutage(t *testing.T) { + t.Parallel() + cfg := newMetricsTestConfig() + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: "http://mcp-alpha.internal"}} + h, gw := newMetricsGatewayHandle(t, cfg) + gw.targetHealth.record(targetKindMCP, "alpha", true, nil, time.Millisecond, targetHealthSourceTraffic) + gw.limiter.store = alwaysErrStore{} + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, metricsRequest(http.MethodGet, metricsPathDefault, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200", rec.Code) + } + _, samples := parsePrometheusText(t, rec.Body.Bytes()) + assertSample(t, samples, "llmgateway_target_healthy", map[string]string{"kind": "mcp", "target": "alpha"}, "1") +} From 9e425a3343a98c71921b365733373e5a9f9d6aff Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 01:46:36 +0100 Subject: [PATCH 03/15] test(yaegi-check): exercise target health under the interpreter Add a second MCP server (target-health-down) pointed at a closed listener, and enable targetHealth in the harness config. After the existing federated tools/call probe, exerciseTargetHealth reads GET /admin/api/targets and asserts the probe server reads healthy with source traffic, then drives targetHealthFailureThreshold consecutive failures through the direct per-server proxy path against the dead server and asserts it flips to unhealthy on both GET /admin/api/targets and llmgateway_target_healthy on /metrics. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- tools/yaegi-check/main.go | 159 +++++++++++++++++++++++++++++++++++++- 1 file changed, 158 insertions(+), 1 deletion(-) diff --git a/tools/yaegi-check/main.go b/tools/yaegi-check/main.go index 878cf05..136e370 100644 --- a/tools/yaegi-check/main.go +++ b/tools/yaegi-check/main.go @@ -404,6 +404,17 @@ func run() error { _, _ = w.Write([]byte(`"}]}}`)) })) defer mcpProbeUpstream.Close() + // targetHealthDownUpstream is opened only to capture a real, unique + // "http://127.0.0.1:PORT" URL, then immediately closed — feat/ + // target-health's own exerciseTargetHealth (below) drives real 502s + // through this dead target's per-server proxy path + // (/mcp/target-health-down/...) to prove the interpreted tracker + // flips it to "unhealthy" after targetHealthFailureThreshold + // consecutive failures, without disturbing mcpProbeUpstream's own + // (successful, federation-routed) traffic above. + targetHealthDownUpstream := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) + targetHealthDownURL := targetHealthDownUpstream.URL + targetHealthDownUpstream.Close() // anthropicProbeUpstream answers an Anthropic Messages API call with a // real Anthropic-shaped body, so the /v1/messages passthrough branch // (callAnthropicMessagesPassthrough) runs interpreted. A body @@ -587,7 +598,16 @@ func run() error { // runs correctly under Yaegi too, not just the config-override // one testDataWantModel already exercises. `"modelMeta":{"` + testDataWantModel + `":{"contextTokens":` + yaegiMetaContextTokens + `,"inputCostPerMTokMicroUsd":1250000,"outputCostPerMTokMicroUsd":10000000}},` + - `"mcpServers":{"` + mcpProbeServerName + `":{"url":"` + mcpProbeUpstream.URL + `"}},` + + `"mcpServers":{"` + mcpProbeServerName + `":{"url":"` + mcpProbeUpstream.URL + `"},"` + targetHealthDownServerName + `":{"url":"` + targetHealthDownURL + `"}},` + + // targetHealth (feat/target-health): enabled with a short + // probeInterval so a future active-probe assertion could run + // quickly if this harness ever adds one — exerciseTargetHealth + // (below) currently exercises the passive-recording and + // admin/metrics-exposure paths only, driven by real traffic + // (exerciseFederatedTooLarge's own federated call, and + // exerciseTargetHealth's own direct proxy calls against + // targetHealthDownServerName), never the active sweep itself. + `"targetHealth":{"enabled":true,"probeInterval":"10s"},` + // metrics (Prometheus text-exposition endpoint): enabled with // modelLabel on, so exerciseMetricsRoute below exercises the // opt-in per-(provider,model) breakdown under the interpreter @@ -646,6 +666,17 @@ func run() error { if err := exerciseHandler(handler, builtinLookupContextTokens, failoverBHits); err != nil { return err } + // exerciseTargetHealth (feat/target-health) runs right after + // exerciseHandler: its own part (a) reads the passive-recording + // side effect of exerciseFederatedTooLarge's federated tools/call, + // already driven above as one of exerciseHandler's own sub-probes, + // so it must not run before that attempt has happened. Its part (b) + // drives its own, independent target (targetHealthDownServerName), + // so it cannot perturb any later probe's own counters or /metrics + // assertions. + if err := exerciseTargetHealth(handler); err != nil { + return err + } // exerciseBareWinnerGroupAware (fix/group-aware-bare-winner, // 2026-08-27) runs right after exerciseHandler and before // exerciseBreaker: it drives its own, freshly named providers and @@ -753,6 +784,20 @@ const ( mcpProbeToolName = mcpProbeServerName + "_big" ) +// targetHealthDownServerName is the second MCP server run() configures, +// against targetHealthDownUpstream — a URL nothing listens on, opened +// then immediately closed (feat/target-health, exerciseTargetHealth, +// below). targetHealthFailureThreshold mirrors the plugin's own +// defaultTargetHealthFailureThreshold (target_health.go): this harness +// module cannot import that unexported constant across the Yaegi +// reflection boundary, so it is copied here, the same independent- +// literal approach every other harness constant mirroring plugin +// internals already takes in this file (e.g. testDataWantModel). +const ( + targetHealthDownServerName = "target-health-down" + targetHealthFailureThreshold = 3 +) + // metricsProbeAllowedCIDR is the CIDR block attemptAccountingOverride's // own metrics.allowedCIDRs names — see that literal's own comment for why // this must contain httptest.NewRequest's default RemoteAddr. @@ -1716,6 +1761,118 @@ func exerciseFederatedTooLarge(handler http.Handler) error { return nil } +// targetHealthProbeView is a shape-tolerant decode of one adminTargetView +// entry's own "health" object (admin.go's adminTargetHealthView) — +// this harness module cannot import the plugin's unexported type across +// the Yaegi reflection boundary (New is resolved and called by +// reflection, not a normal Go import — this whole file's own doc +// comment explains why), so it decodes the JSON shape independently, the +// same approach readHealth/readProviderAttemptCounters already take for +// other admin responses. +type targetHealthProbeView struct { + State string `json:"state"` + Source string `json:"source"` +} + +// readTargetHealth returns name's own "health" object from GET +// /admin/api/targets, searching both mcpServers and agents (mcpProbeServerName +// and targetHealthDownServerName are both MCP servers, but this checks +// both arrays so a future agent-shaped call site can reuse it unchanged). +func readTargetHealth(handler http.Handler, name string) (targetHealthProbeView, error) { + req := httptest.NewRequest(http.MethodGet, "/admin/api/targets", nil) + req.Header.Set("Authorization", "Bearer "+attemptAccountingAdminAPIKey) + rec := httptest.NewRecorder() + handler.ServeHTTP(rec, req) + if rec.Code != http.StatusOK { + return targetHealthProbeView{}, fmt.Errorf("GET /admin/api/targets: status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + var body struct { + MCPServers []struct { + Name string `json:"name"` + Health targetHealthProbeView `json:"health"` + } `json:"mcpServers"` + Agents []struct { + Name string `json:"name"` + Health targetHealthProbeView `json:"health"` + } `json:"agents"` + } + if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { + return targetHealthProbeView{}, fmt.Errorf("decode GET /admin/api/targets body: %w (body=%s)", err, rec.Body.String()) + } + for _, s := range body.MCPServers { + if s.Name == name { + return s.Health, nil + } + } + for _, a := range body.Agents { + if a.Name == name { + return a.Health, nil + } + } + return targetHealthProbeView{}, fmt.Errorf("target %q not in GET /admin/api/targets: %s", name, rec.Body.String()) +} + +// exerciseTargetHealth proves feat/target-health end to end under the +// REAL interpreter. Part (a): mcpProbeServerName already received one +// real federated tools/call attempt via exerciseFederatedTooLarge, +// above — its oversized response trips errMCPResponseTooLarge, a +// transport-level failure from doBackendJSONRPC's own perspective +// (mcp_federation.go), which mcpFederatedToolsCall records as a +// target-health failure. One failure stays well under +// targetHealthFailureThreshold, so the target still reads "healthy" — +// target_health.go's own doc comment explains why 1-2 recent failures +// short of the threshold stay healthy. Part (b): drives +// targetHealthFailureThreshold consecutive failures through the direct +// per-server proxy path (/mcp/{name}/..., handleTargetProxy) against +// targetHealthDownServerName's dead upstream, then asserts the SAME +// tracker flips that target to "unhealthy" on both GET +// /admin/api/targets and llmgateway_target_healthy on /metrics. +func exerciseTargetHealth(handler http.Handler) error { + probeHealth, err := readTargetHealth(handler, mcpProbeServerName) + if err != nil { + return err + } + if probeHealth.State != "healthy" { + return fmt.Errorf("TARGETHEALTH-1: GET /admin/api/targets: %q health.state = %q, want healthy (after one federated tools/call attempt, below threshold): %+v", mcpProbeServerName, probeHealth.State, probeHealth) + } + if probeHealth.Source != "traffic" { + return fmt.Errorf("TARGETHEALTH-2: GET /admin/api/targets: %q health.source = %q, want %q", mcpProbeServerName, probeHealth.Source, "traffic") + } + + for i := 0; i < targetHealthFailureThreshold; i++ { + req := httptest.NewRequest(http.MethodGet, "/mcp/"+targetHealthDownServerName+"/tools/list", nil) + req.Header.Set("Authorization", "Bearer "+testDataUserAPIKey) + rec := httptest.NewRecorder() + handler.ServeHTTP(rec, req) + if rec.Code != http.StatusBadGateway { + return fmt.Errorf("TARGETHEALTH-3: GET /mcp/%s/tools/list attempt %d: status = %d, want 502 (dead upstream), body=%s", targetHealthDownServerName, i, rec.Code, rec.Body.String()) + } + } + + downHealth, err := readTargetHealth(handler, targetHealthDownServerName) + if err != nil { + return err + } + if downHealth.State != "unhealthy" { + return fmt.Errorf("TARGETHEALTH-4: GET /admin/api/targets: %q health.state = %q, want unhealthy after %d consecutive failures: %+v", targetHealthDownServerName, downHealth.State, targetHealthFailureThreshold, downHealth) + } + + metricsReq := httptest.NewRequest(http.MethodGet, "/metrics", nil) + metricsReq.Header.Set("Authorization", "Bearer "+attemptAccountingAdminAPIKey) + metricsRec := httptest.NewRecorder() + handler.ServeHTTP(metricsRec, metricsReq) + if metricsRec.Code != http.StatusOK { + return fmt.Errorf("GET /metrics: status = %d, want 200, body=%s", metricsRec.Code, metricsRec.Body.String()) + } + wantSample := `llmgateway_target_healthy{kind="mcp",target="` + targetHealthDownServerName + `"} 0` + if !strings.Contains(metricsRec.Body.String(), wantSample) { + return fmt.Errorf("TARGETHEALTH-5: GET /metrics missing %q — interpreted target-health metric diverged from the compiled shape; body=%s", wantSample, metricsRec.Body.String()) + } + + fmt.Println("yaegi-check: target health tracked and exposed correctly interpreted (admin API + /metrics)") + return nil +} + // exerciseFederatedSSENegotiation drives two real POST /mcp "ping" calls // against the interpreted handler — one carrying no Accept header // (today's plain JSON framing) and one carrying the reported client's From e9eac5248ea104fc5933af8e07f042626fa55cdc Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 01:48:25 +0100 Subject: [PATCH 04/15] docs: document target health Add the targetHealth config row and a TargetHealthConfig reference section, a Target health section under MCP and A2A describing the passive recording rules and the active probe rules per target kind, the health field on GET /admin/api/targets, and the llmgateway_target_healthy gauge with its aggregation-across-replicas note. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- README.md | 84 ++++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 80 insertions(+), 4 deletions(-) diff --git a/README.md b/README.md index 47d80d8..4bd9de3 100644 --- a/README.md +++ b/README.md @@ -197,6 +197,7 @@ config accepts them as YAML, which decodes to the same JSON shape. | `requestTimeout` | `string` (Go duration) | `5m` | Progress-based upstream request timeout, applied to every provider adapter call, native passthrough, and the MCP/A2A target proxy — see [Request timeout](#request-timeout). **Behavior change for every deployment**: before this field existed, no timeout was set at all, so a provider that accepted a connection and then went silent hung the request forever. A provider's own `requestTimeout` (`ProviderConfig`) overrides this. Empty means the default; a value that fails to parse, or parses to zero or a negative duration, is a construction error. | | `cache` | `CacheConfig` | `{}` (disabled) | Opt-in Redis-backed response cache for unified non-streaming chat/embeddings — see [Caching](#caching). Omitted or `enabled: false` means no caching, byte-identical to a gateway built before this field existed. | | `breaker` | `BreakerConfig` | `{}` (every default) | Per-provider discovery circuit breaker — see [Provider health (discovery circuit breaker)](#provider-health-discovery-circuit-breaker). Every field is individually zero-means-default; a provider whose discovery never fails is unaffected regardless of what this block contains. | +| `targetHealth` | `TargetHealthConfig` | `{}` (probes off) | Health tracking for MCP servers and A2A agents — see [MCP and A2A](#mcp-and-a2a)'s "Target health" section. Passive recording and exposure stay on regardless of this block; `enabled` gates only the active probe sweep. | | `admin` | `*AdminConfig` | `nil` (disabled) | Read-only admin dashboard — see [Admin](#admin). `nil` or `enabled: false` means the `/admin*` routes are not registered at all. | | `metrics` | `*MetricsConfig` | `nil` (disabled) | Prometheus text-exposition endpoint — see [Metrics](#metrics). `nil` or `enabled: false` means the metrics route is not registered at all. | | `modelAliases` | `map[string]string` | `{}` | Operator-defined alias id → target model id — see [Model aliases](#model-aliases). Omitted or empty means no aliases, byte-identical to a gateway built before this field existed. | @@ -325,6 +326,21 @@ own is governed purely by their group's — see | `openDuration` | `string` (Go duration) | `1m` | Base backoff a newly opened breaker waits before its first half-open probe; doubles on every further failed probe, capped at `maxOpenDuration`. Invalid or non-positive duration string is a construction error. | | `maxOpenDuration` | `string` (Go duration) | `6h` | Ceiling on the backoff `openDuration` doubles into. Must be `>= openDuration` and no more than `24h`, or construction fails. Deliberately longer than the default `discoveryInterval` (1h) — see [Provider health](#provider-health-discovery-circuit-breaker) for why a value at or below `discoveryInterval` suppresses nothing. | +### `TargetHealthConfig` + +Configures the opt-in active probe sweep for MCP servers and A2A agents +— see [MCP and A2A](#mcp-and-a2a)'s "Target health" section for the full +contract. **Passive recording from real proxied traffic, and exposure +through `GET /admin/api/targets` and the `llmgateway_target_healthy` +gauge, stay on unconditionally, regardless of this block.** `enabled` +gates only the background probe sweep. + +| Field | Type | Default | Semantics | +|---|---|---|---| +| `enabled` | `bool` | `false` | `false`: no MCP server or A2A agent is ever proactively contacted for health purposes. `true`: the active probe sweep runs, at most once per `probeInterval`, triggered by `/metrics`, `GET /admin/api/targets`, `GET /v1/mcp/servers`, or `GET /v1/agents` — never a timer. | +| `probeInterval` | `string` (Go duration) | `60s` | Minimum time between sweeps. Must be between `10s` and `1h`, or construction fails. | +| `failureThreshold` | `int` | `3` | Consecutive failed observations (probe or passive traffic) that mark a target unhealthy. `0` uses the default. Must be between `1` and `100`, or construction fails. | + ### `AdminConfig` | Field | Type | Default | Semantics | @@ -1521,7 +1537,7 @@ or in CI. - **`GET /admin/api/targets`** returns every configured MCP server and agent for the dashboard's "MCP & Agents" tab: `{"mcpServers":[...],"agents":[...]}`, each entry - `{"name","url","access","counters"}`. `url` has any userinfo/query + `{"name","url","access","counters","health"}`. `url` has any userinfo/query string stripped, same as a provider's `baseUrl` in `overview`. `access` is the list of group names actually allowed to reach that target, computed via the identical glob match `mcpServers`/`agents` @@ -1529,8 +1545,17 @@ or in CI. view can never disagree with what the proxy enforces; omitted when every configured group can reach it. `counters` is `requestsPerMinute`/`requestsPerDay`/`requestsPerMonth` — requests - only, no tokens or cost (see [MCP and A2A](#mcp-and-a2a) for why). Polled - every 5 seconds, in the same batch as `overview` and `usage`. + only, no tokens or cost (see [MCP and A2A](#mcp-and-a2a) for why). + `health` is `{"state","lastCheck","lastError","consecutiveFailures","latencyMs","source"}` + — see [MCP and A2A](#mcp-and-a2a)'s "Target health" section for the + full contract. `state` is `"unknown"`, `"healthy"`, or `"unhealthy"`, + and `consecutiveFailures` is always present; every other field is + omitted while `state` is `"unknown"` (this target has never been + observed). This route always reads existing state; when + `targetHealth.enabled`, it additionally triggers a background probe + sweep when one is due, so the response itself never waits on that + sweep. Polled every 5 seconds, in the same batch as `overview` and + `usage`. - **What's exposed**: provider names, types, base URLs (with any userinfo/query string stripped before it's ever echoed), model counts, discovery status, group/user names, membership, limits, MCP/agent @@ -1656,6 +1681,10 @@ plugin's config. - `llmgateway_provider_healthy{provider}` — `1`/`0` gauge from the discovery circuit breaker (`healthState` in the admin API); see [Provider health](#provider-health-discovery-circuit-breaker). + - `llmgateway_target_healthy{kind,target}` — `1`/`0` gauge for an MCP + server or A2A agent's tracked health; `kind` is `"mcp"` or `"agent"`. + No sample at all for a target this tracker has never observed — see + [MCP and A2A](#mcp-and-a2a)'s "Target health" section. - `llmgateway_limit_store_up` — `1`/`0` gauge for this replica's own connection to the configured limit store (Redis); absent entirely when no store is configured. Every store-backed family above simply @@ -1692,7 +1721,7 @@ plugin's config. identical families become genuinely **per-replica** instead — each replica counts only the traffic it personally handled — and `sum()` becomes the correct aggregation instead. This flips on that one config - bit; know which one you are running before wiring an alert. Three + bit; know which one you are running before wiring an alert. Four families do **not** follow this rule: - `llmgateway_rate_limit_rejections_total` lives only in each replica's own process memory, **never** in Redis, regardless of the `redis` @@ -1704,6 +1733,11 @@ plugin's config. possible; if you must aggregate, `min()` surfaces "at least one replica sees this provider as unhealthy" — `sum()` is meaningless for a 0/1 gauge. + - `llmgateway_target_healthy` reflects each replica's own tracker, + fed by its own passive traffic and, if enabled, its own active + probes — never shared via Redis. Same guidance as + `llmgateway_provider_healthy`: read per-instance, `min()` if you must + aggregate. - `llmgateway_limit_store_up` reflects each replica's own, locally -discovered connection health to the configured store — it cannot itself be read from the store it describes, so it is inherently @@ -1843,6 +1877,48 @@ plugin's config. /admin/api/targets` above and the request-rate note below. Applies to MCP servers only, not agents: there is no equivalent aggregated `/a2a` endpoint. +- **Target health**: a per-replica, in-memory health tracker for every + configured MCP server and A2A agent — providers already have a health + signal (the discovery circuit breaker); this is the equivalent for + targets. Exposed via `GET /admin/api/targets`'s own `health` field + (above) and the `llmgateway_target_healthy` gauge (see + [Metrics](#metrics)). **Never gates routing**: federation and the + per-server proxy keep contacting every configured target regardless of + its recorded health — this tracker is observe-only. + - **Passive recording, always on**, independent of `targetHealth.enabled`: + the per-server proxy (`/mcp/{name}/...`, `/a2a/{name}/...`) records a + failure when the proxy attempt itself fails (excluding a client + cancel, which records nothing) or the upstream answers `5xx`; any + status under `500`, `4xx` included, counts as reachable. Federated + `POST /mcp`'s `tools/list` fan-out and `tools/call` record a failure + only when the outbound call itself fails (`err != nil` from the + backend call) — a JSON-RPC-level `error` in the backend's own + response still counts as reachable, since the server answered. + - **Active probes are opt-in** (`targetHealth.enabled: true`) and lazy: + no timer, no background goroutine running on its own. A probe sweep + is triggered by `/metrics`, `GET /admin/api/targets`, `GET + /v1/mcp/servers`, or `GET /v1/agents` — whichever is polled first + once `targetHealth.probeInterval` has elapsed since the last sweep — + and runs at most one sweep at a time, contacting every configured MCP + server and agent concurrently. Each probe gets its own timeout: the + configured `requestTimeout`, capped at `10s`. + - An MCP server on the Streamable HTTP transport gets an + `initialize`/session-close handshake; a JSON-RPC error answering + `initialize` is a failure carrying that message. + - An MCP server whose URL ends `/sse` (legacy HTTP+SSE transport, + same exclusion federation itself applies) gets a plain `GET`; the + response body is closed immediately, **never read** — an SSE + endpoint streams indefinitely. Reachable iff no transport error and + the status is under `500`. + - An A2A agent gets a `GET` of its agent-card path (`AgentConfig.card`, + or the default `/.well-known/agent-card.json`); a `404` still + counts as reachable — for example an umbrella agent whose root + carries no card of its own. + - **State**: `"unknown"` (never observed), `"healthy"` (recorded at + least once, `consecutiveFailures` below `targetHealth.failureThreshold`), + or `"unhealthy"` (`consecutiveFailures` at or above the threshold). A + target with one or two recent failures after a success still reads + `"healthy"` until the threshold is actually crossed. ## Security notes From d2152b169cbb78a8607999cb951e5ad68a8380a8 Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 02:42:01 +0100 Subject: [PATCH 05/15] fix(target-health): scrub lastError URLs and fix unknown-state gaps MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Combines three closely-coupled target_health.go fixes that all touch targetHealthTracker.record/stateForLocked in the same commit, since splitting them would leave an intermediate commit that fails to compile or a test asserting behaviour its own commit does not yet implement. F1: record gains a rawURL parameter and scrubs err's text through sanitizeProviderErr before storing lastError, so a target URL configured with an embedded credential can never leak through GET /admin/api/targets. The scrub runs before truncateRunes so a long embedded URL cannot survive truncation unscrubbed. Every probe, the per-server proxy hook (mcp_a2a.go), and both federation record sites (mcp_federation.go) now pass their target's configured URL through. F3: maybeSweepTargetHealth re-checks the elapsed interval after winning the single-flight CAS, closing a window where a caller's own stale interval read could still win the CAS once a separate, faster sweep had already started and finished within the same interval. F4: targetHealthEntry gains everOK, set on record's success branch. stateForLocked now reads a target that has never once succeeded as unknown rather than healthy, even below failureThreshold — the threshold still protects against a single transient first failure, it just does not promote a target this tracker has never seen answer to healthy. targetHealthSnapshot gains observed so the admin view can still tell apart never-observed (omit every other field) from observed-but-never-succeeded (keep them) despite both reading state unknown. The now-redundant lastOK field is removed. Also included: target_health_test.go's own test-hygiene fixes (F6) — an idempotent, t.Cleanup-registered unblock ahead of srv.Close so a failing assertion cannot leave a released server handler blocked until the test binary's own timeout, and an atomic hit counter in the disabled-sweep test — since they land in the same file as the tests above. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- admin.go | 26 ++++-- admin_test.go | 85 +++++++++++++++++- mcp_a2a.go | 2 +- mcp_federation.go | 4 +- metrics_test.go | 6 +- target_health.go | 125 ++++++++++++++++++++------ target_health_test.go | 204 +++++++++++++++++++++++++++++++++++++----- 7 files changed, 387 insertions(+), 65 deletions(-) diff --git a/admin.go b/admin.go index 748b8f2..bda3379 100644 --- a/admin.go +++ b/admin.go @@ -1252,11 +1252,20 @@ type adminTargetView struct { // adminTargetHealthView is one target's feat/target-health readout in // GET /admin/api/targets — the exact JSON contract the webui's MCP & // Agents panel codes against. State and ConsecutiveFailures are always -// present; every other field is omitted while State is -// targetHealthUnknown (this tracker has never observed the target), -// since none of them carry a meaningful value yet. LatencyMs is a -// pointer so a genuine 0ms observation still serializes as -// "latencyMs":0 rather than being indistinguishable from "omitted". +// present. State "unknown" (targetHealthUnknown) covers two different +// situations (F4, feat/target-health review) — see that constant's own +// doc comment — and this view tells them apart by whether the tracker +// has ever observed the target at all, NOT by State alone: +// - never observed: every other field is omitted, since none of them +// carry a meaningful value yet. +// - observed, but never once succeeded (still below +// targetHealth.failureThreshold): every field below is still +// present, exactly as for "healthy"/"unhealthy" — there IS a real +// lastCheck/lastError/source/latencyMs to show, the tracker simply +// has not seen this target succeed yet. +// +// LatencyMs is a pointer so a genuine 0ms observation still serializes +// as "latencyMs":0 rather than being indistinguishable from "omitted". // Field order is fieldalignment-derived, the same convention // adminTargetView's own doc comment above explains. type adminTargetHealthView struct { @@ -1269,10 +1278,13 @@ type adminTargetHealthView struct { } // targetHealthView converts one targetHealthTracker.snapshot result -// (target_health.go) into its JSON view. +// (target_health.go) into its JSON view. Whether to omit the non-always- +// present fields is decided by snap.observed, NOT snap.state == +// targetHealthUnknown (adminTargetHealthView's own doc comment explains +// why those are different questions since F4). func targetHealthView(snap targetHealthSnapshot) adminTargetHealthView { view := adminTargetHealthView{State: snap.state, ConsecutiveFailures: snap.consecutiveFailures} - if snap.state == targetHealthUnknown { + if !snap.observed { return view } view.LastCheck = snap.lastCheck.UTC().Format(time.RFC3339) diff --git a/admin_test.go b/admin_test.go index 92bb80f..cc49aa1 100644 --- a/admin_test.go +++ b/admin_test.go @@ -2461,6 +2461,51 @@ func TestAdminTargets_Health_NeverObserved_UnknownWithOmittedFields(t *testing.T } } +// TestAdminTargets_Health_NeverSucceeded_UnknownWithFieldsPresent proves +// F4's second "unknown" case: a target that HAS been observed, but never +// once succeeded, and is still below failureThreshold, reads "unknown" — +// yet carries every other health field, unlike a target this tracker has +// never observed at all (the test above). The omit-when-unknown rule +// applies only to a NEVER-OBSERVED entry, not to "unknown because never +// succeeded yet". +func TestAdminTargets_Health_NeverSucceeded_UnknownWithFieldsPresent(t *testing.T) { + t.Parallel() + cfg := newAdminTestConfig() + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: "http://mcp-alpha.internal"}} + h, gw := newAdminGatewayHandle(t, cfg) + + gw.targetHealth.record(targetKindMCP, "alpha", "", false, errors.New("dial tcp: connection refused"), 7*time.Millisecond, targetHealthSourceProbe) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, adminRequest(http.MethodGet, adminTargetsPath, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + var got adminTargetsResponse + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { + t.Fatalf("decode: %v", err) + } + health := got.MCPServers[0].Health + if health.State != targetHealthUnknown { + t.Errorf("state = %q, want unknown (never succeeded, still below threshold)", health.State) + } + if health.LastCheck == "" { + t.Error("want a non-empty lastCheck even though state is unknown — this target HAS been observed") + } + if health.LastError != "dial tcp: connection refused" { + t.Errorf("lastError = %q, want the recorded error text", health.LastError) + } + if health.Source != targetHealthSourceProbe { + t.Errorf("source = %q, want %q", health.Source, targetHealthSourceProbe) + } + if health.LatencyMs == nil || *health.LatencyMs != 7 { + t.Errorf("latencyMs = %v, want *7", health.LatencyMs) + } + if health.ConsecutiveFailures != 1 { + t.Errorf("consecutiveFailures = %d, want 1", health.ConsecutiveFailures) + } +} + // TestAdminTargets_Health_Recorded_AllFieldsPresent proves a target with // at least one recorded observation carries every health field, and that // state/source/consecutiveFailures reflect the tracker exactly. @@ -2470,7 +2515,7 @@ func TestAdminTargets_Health_Recorded_AllFieldsPresent(t *testing.T) { cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: "http://mcp-alpha.internal"}} h, gw := newAdminGatewayHandle(t, cfg) - gw.targetHealth.record(targetKindMCP, "alpha", true, nil, 12*time.Millisecond, targetHealthSourceTraffic) + gw.targetHealth.record(targetKindMCP, "alpha", "", true, nil, 12*time.Millisecond, targetHealthSourceTraffic) rec := httptest.NewRecorder() h.ServeHTTP(rec, adminRequest(http.MethodGet, adminTargetsPath, "sk-admin1")) @@ -2517,7 +2562,7 @@ func TestAdminTargets_Health_Unhealthy_LastErrorPresent(t *testing.T) { cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} h, gw := newAdminGatewayHandle(t, cfg) - gw.targetHealth.record(targetKindMCP, "alpha", false, errors.New("dial tcp: connection refused"), 3*time.Millisecond, targetHealthSourceProbe) + gw.targetHealth.record(targetKindMCP, "alpha", "", false, errors.New("dial tcp: connection refused"), 3*time.Millisecond, targetHealthSourceProbe) rec := httptest.NewRecorder() h.ServeHTTP(rec, adminRequest(http.MethodGet, adminTargetsPath, "sk-admin1")) @@ -2548,7 +2593,7 @@ func TestAdminTargets_Health_AgentUsesAgentKind(t *testing.T) { cfg.Agents = map[string]*AgentConfig{"bot1": {URL: "http://agent-bot1.internal"}} h, gw := newAdminGatewayHandle(t, cfg) - gw.targetHealth.record(targetKindAgent, "bot1", true, nil, time.Millisecond, targetHealthSourceTraffic) + gw.targetHealth.record(targetKindAgent, "bot1", "", true, nil, time.Millisecond, targetHealthSourceTraffic) rec := httptest.NewRecorder() h.ServeHTTP(rec, adminRequest(http.MethodGet, adminTargetsPath, "sk-admin1")) @@ -2563,3 +2608,37 @@ func TestAdminTargets_Health_AgentUsesAgentKind(t *testing.T) { t.Fatalf("agents = %+v, want bot1 healthy", got.Agents) } } + +// TestAdminTargets_Health_LastError_ScrubsTargetCredentials proves F1 end +// to end: a target URL configured with an embedded credential never +// reaches GET /admin/api/targets through lastError, even though the +// recorded probe error text embeds the exact configured URL — mirroring +// the credential scrub sanitizeBaseURL already applies to the sibling +// "url" field. +func TestAdminTargets_Health_LastError_ScrubsTargetCredentials(t *testing.T) { + t.Parallel() + rawURL := "https://svc.internal/mcp?api-key=SECRETVALUE" + cfg := newAdminTestConfig() + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: rawURL}} + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} + h, gw := newAdminGatewayHandle(t, cfg) + + gw.targetHealth.record(targetKindMCP, "alpha", rawURL, false, errors.New(`Get "`+rawURL+`": dial tcp: connection refused`), 3*time.Millisecond, targetHealthSourceProbe) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, adminRequest(http.MethodGet, adminTargetsPath, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + body := rec.Body.String() + if strings.Contains(body, "SECRETVALUE") { + t.Errorf("body = %s, want lastError scrubbed of the target's api-key", body) + } + var got adminTargetsResponse + if err := json.Unmarshal(rec.Body.Bytes(), &got); err != nil { + t.Fatalf("decode: %v", err) + } + if strings.Contains(got.MCPServers[0].Health.LastError, "SECRETVALUE") { + t.Errorf("lastError = %q, want scrubbed", got.MCPServers[0].Health.LastError) + } +} diff --git a/mcp_a2a.go b/mcp_a2a.go index 1fc6c64..32df7e9 100644 --- a/mcp_a2a.go +++ b/mcp_a2a.go @@ -226,7 +226,7 @@ func (g *Gateway) handleTargetProxy(w http.ResponseWriter, r *http.Request, u *u // success/failure rule. start := time.Now() result, ok := g.proxyUpstream(w, r, upstreamURL, g.targetClient, nil, nil, false, kind+" target (name "+name+")", g.targetTimeout) - g.recordTargetProxyHealth(kind, name, result, ok, time.Since(start)) + g.recordTargetProxyHealth(kind, name, targetURL, result, ok, time.Since(start)) } // validateTargetURLs checks every configured MCP-server and agent entry at diff --git a/mcp_federation.go b/mcp_federation.go index e2dd4d3..223bbd2 100644 --- a/mcp_federation.go +++ b/mcp_federation.go @@ -980,7 +980,7 @@ func (g *Gateway) mcpFederatedToolsList(w http.ResponseWriter, format mcpRespons // it is recorded separately, below, once the shape is known. probeStart := time.Now() resp, err := g.mcpBackendCall(fanoutCtx, targetURL, "tools/list", struct{}{}, mcpBackendResponseMaxBytes) - g.targetHealth.record(targetKindMCP, name, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) + g.targetHealth.record(targetKindMCP, name, targetURL, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) mu.Lock() defer mu.Unlock() @@ -1103,7 +1103,7 @@ func (g *Gateway) mcpFederatedToolsCall(w http.ResponseWriter, format mcpRespons // not. probeStart := time.Now() resp, err := g.mcpBackendCall(ctx, targetURL, "tools/call", mcpToolCallParams{Name: toolName, Arguments: params.Arguments}, mcpBackendCallResponseMaxBytes) - g.targetHealth.record(targetKindMCP, serverName, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) + g.targetHealth.record(targetKindMCP, serverName, targetURL, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) g.limiter.countTargetRequest(targetKindMCP, serverName) if err != nil { g.logf("federated tools/call: server %q: %v", serverName, err) diff --git a/metrics_test.go b/metrics_test.go index 6cc675e..0bf64a3 100644 --- a/metrics_test.go +++ b/metrics_test.go @@ -1533,8 +1533,8 @@ func TestMetrics_TargetHealthy_ReflectsRecordedState(t *testing.T) { cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} h, gw := newMetricsGatewayHandle(t, cfg) - gw.targetHealth.record(targetKindMCP, "alpha", true, nil, time.Millisecond, targetHealthSourceTraffic) - gw.targetHealth.record(targetKindAgent, "bot1", false, errors.New("boom"), time.Millisecond, targetHealthSourceProbe) + gw.targetHealth.record(targetKindMCP, "alpha", "", true, nil, time.Millisecond, targetHealthSourceTraffic) + gw.targetHealth.record(targetKindAgent, "bot1", "", false, errors.New("boom"), time.Millisecond, targetHealthSourceProbe) rec := httptest.NewRecorder() h.ServeHTTP(rec, metricsRequest(http.MethodGet, metricsPathDefault, "sk-admin1")) @@ -1558,7 +1558,7 @@ func TestMetrics_TargetHealthy_UnaffectedByStoreOutage(t *testing.T) { cfg := newMetricsTestConfig() cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: "http://mcp-alpha.internal"}} h, gw := newMetricsGatewayHandle(t, cfg) - gw.targetHealth.record(targetKindMCP, "alpha", true, nil, time.Millisecond, targetHealthSourceTraffic) + gw.targetHealth.record(targetKindMCP, "alpha", "", true, nil, time.Millisecond, targetHealthSourceTraffic) gw.limiter.store = alwaysErrStore{} rec := httptest.NewRecorder() diff --git a/target_health.go b/target_health.go index 33cdeb7..a16b485 100644 --- a/target_health.go +++ b/target_health.go @@ -32,11 +32,22 @@ import ( type targetHealthState string const ( - // targetHealthUnknown: the tracker has never recorded an observation - // (probe or traffic) for this (kind, name) — a target configured but - // never yet reached. + // targetHealthUnknown covers two distinct situations (F4, + // feat/target-health review), both read the SAME state on purpose — + // neither has ever demonstrated the target actually works: + // 1. never observed at all — the tracker has no entry for this + // (kind, name) yet, a target configured but never yet reached. + // 2. observed, but never once succeeded — every observation so far + // is a failure, and consecutiveFailures has not yet reached + // failureThreshold. Reading "healthy" here (the pre-F4 behavior) + // would be a false claim from a target this tracker has never + // actually seen answer; reading "unhealthy" before the threshold + // is reached would discard the threshold's own protection + // against a single transient first failure. See + // targetHealthSnapshot.observed for how the admin view (admin.go) + // tells these two apart despite sharing this one state. targetHealthUnknown targetHealthState = "unknown" - // targetHealthHealthy: recorded at least once, and consecutiveFailures + // targetHealthHealthy: succeeded at least once, and consecutiveFailures // has not yet reached failureThreshold. This DELIBERATELY includes a // target whose most recent single observation was itself a failure: // 1 or 2 recent failures after a success still read "healthy" until @@ -47,7 +58,10 @@ const ( // state machine of its own (see this file's own package doc comment // for why). targetHealthHealthy targetHealthState = "healthy" - // targetHealthUnhealthy: consecutiveFailures >= failureThreshold. + // targetHealthUnhealthy: consecutiveFailures >= failureThreshold, + // regardless of whether the target has ever succeeded — the + // threshold gate always takes priority over the never-succeeded + // check above. targetHealthUnhealthy targetHealthState = "unhealthy" ) @@ -85,7 +99,11 @@ type targetHealthEntry struct { source string latency time.Duration consecutiveFailures int - lastOK bool + // everOK is set true the first time record observes a success for + // this entry, and never cleared afterward — stateForLocked's F4 + // "never succeeded yet reads unknown, not healthy" rule reads this, + // not consecutiveFailures alone. + everOK bool } // targetHealthTracker is feat/target-health's own per-pod, in-memory @@ -128,9 +146,20 @@ func newTargetHealthTracker(threshold int) *targetHealthTracker { // even on failure — a caller with no Go error to attach, e.g. a bad // HTTP status alone, still leaves lastError at whatever it previously // held rather than clearing it, since there IS a new failure to report). -// source is targetHealthSourceProbe or targetHealthSourceTraffic — -// whichever mechanism produced this observation. -func (t *targetHealthTracker) record(kind, name string, ok bool, err error, latency time.Duration, source string) { +// rawURL is (kind, name)'s configured target URL — the exact string a +// caller dialed, used ONLY to scrub err's text through sanitizeProviderErr +// (admin.go) before it is stored: a Go *url.Error embeds the dialed URL +// verbatim, so an operator-configured target URL carrying credentials +// (an "api-key" query parameter, userinfo) would otherwise leak through +// GET /admin/api/targets' lastError field the same way an unsanitized +// provider error once could (F1, feat/target-health review). The scrub +// runs BEFORE truncateRunes, not after: truncating first could cut a long +// embedded URL in half, leaving sanitizeProviderErr's exact-substring +// match unable to find it and a fragment of the credential in the +// truncated result. source is targetHealthSourceProbe or +// targetHealthSourceTraffic — whichever mechanism produced this +// observation. +func (t *targetHealthTracker) record(kind, name, rawURL string, ok bool, err error, latency time.Duration, source string) { if t == nil || name == "" { return } @@ -143,17 +172,17 @@ func (t *targetHealthTracker) record(kind, name string, ok bool, err error, late t.entries[key] = e } e.lastCheck = t.nowFn() - e.lastOK = ok e.latency = latency e.source = source if ok { + e.everOK = true e.consecutiveFailures = 0 e.lastError = "" return } e.consecutiveFailures++ if err != nil { - e.lastError = truncateRunes(err.Error(), targetHealthMaxErrorRunes) + e.lastError = truncateRunes(sanitizeProviderErr(err.Error(), rawURL), targetHealthMaxErrorRunes) } } @@ -173,11 +202,19 @@ func (t *targetHealthTracker) stateOf(kind, name string) targetHealthState { } // stateForLocked derives e's targetHealthState. Caller must hold t.mu. -// Split out of stateOf/snapshot so both apply the identical rule. +// Split out of stateOf/snapshot so both apply the identical rule. The +// threshold check runs first and always wins (F4): a target that has +// failed failureThreshold times straight reads unhealthy whether or not +// it has ever succeeded. Below threshold, a target that has never once +// succeeded reads unknown rather than healthy — see targetHealthUnknown's +// own doc comment for why. func (t *targetHealthTracker) stateForLocked(e *targetHealthEntry) targetHealthState { if e.consecutiveFailures >= t.failureThreshold { return targetHealthUnhealthy } + if !e.everOK { + return targetHealthUnknown + } return targetHealthHealthy } @@ -191,13 +228,21 @@ type targetHealthSnapshot struct { source string latency time.Duration consecutiveFailures int + // observed is true iff this tracker holds an entry for (kind, name) + // — i.e. record has been called at least once, regardless of + // success or failure. F4, feat/target-health review: state alone + // cannot tell apart targetHealthUnknown's two cases (never observed + // vs. observed-but-never-succeeded), so targetHealthView (admin.go) + // reads this field, not state, to decide whether to omit + // lastCheck/lastError/source/latencyMs — omit only while !observed. + observed bool } // snapshot returns a copy of (kind, name)'s current health state — // buildAdminTargets (admin.go) and writeTargetMetrics (metrics.go) both // read through this, once per configured target, rather than exposing // t.entries directly. A target this tracker has never observed returns -// a zero-valued snapshot with state targetHealthUnknown. +// a zero-valued, !observed snapshot with state targetHealthUnknown. func (t *targetHealthTracker) snapshot(kind, name string) targetHealthSnapshot { if t == nil { return targetHealthSnapshot{state: targetHealthUnknown} @@ -209,6 +254,7 @@ func (t *targetHealthTracker) snapshot(kind, name string) targetHealthSnapshot { return targetHealthSnapshot{state: targetHealthUnknown} } return targetHealthSnapshot{ + observed: true, state: t.stateForLocked(e), lastCheck: e.lastCheck, lastError: e.lastError, @@ -321,26 +367,49 @@ func targetHealthProbeTimeout(requestTimeout time.Duration) time.Duration { // caller reaches this on a live request path and must never block // behind a lock another such call already holds) — a CAS that fails // means either a sweep is already in flight, in which case returning is -// exactly right regardless of how long ago it started, or another -// goroutine just won the race to start this interval's sweep, in which -// case returning is exactly right too. The interval check above the CAS -// is a cheap early-out only; the CAS itself is what actually enforces -// "at most one sweep in flight, and at most one starts per interval". +// exactly right, or another goroutine just won the race to start this +// interval's sweep, in which case returning is exactly right too. The +// CAS alone enforces only single-flight — "at most one sweep in flight +// at a time" — NOT the probe interval: the interval load above it and +// the CAS are not atomic with each other, so a caller whose own interval +// read predates an entirely separate sweep's full start-and-finish could +// still win the CAS once that sweep clears the flag (worst at startup, +// when every caller's first read sees last == 0). F3, feat/target-health +// review: re-check the interval AFTER winning the CAS, against +// whatever targetHealthLastSweepUnixNano holds now — set by the sweep +// that raced ahead, if any — and back out without spawning when that +// sweep already started within the interval. func (g *Gateway) maybeSweepTargetHealth() { if !g.targetHealthCfg.enabled { return } - last := atomic.LoadInt64(&g.targetHealthLastSweepUnixNano) - if last != 0 && time.Duration(time.Now().UnixNano()-last) < g.targetHealthCfg.probeInterval { + if !targetHealthIntervalElapsed(atomic.LoadInt64(&g.targetHealthLastSweepUnixNano), g.targetHealthCfg.probeInterval) { return } if !atomic.CompareAndSwapInt32(&g.targetHealthSweeping, 0, 1) { return } - atomic.StoreInt64(&g.targetHealthLastSweepUnixNano, time.Now().UnixNano()) + now := time.Now().UnixNano() + if !targetHealthIntervalElapsed(atomic.LoadInt64(&g.targetHealthLastSweepUnixNano), g.targetHealthCfg.probeInterval) { + // Lost the race: some other sweep already started (and, since + // the flag was 0 again for this CAS to succeed, already + // finished) within the interval while this call was still + // working from its own, now-stale, interval read above. + atomic.StoreInt32(&g.targetHealthSweeping, 0) + return + } + atomic.StoreInt64(&g.targetHealthLastSweepUnixNano, now) go g.sweepTargetHealth() //nolint:gosec // G118: self-terminating, bounded by mcpFederatedFanoutConcurrency*targetHealthMaxProbeTimeout worst case, and always clears targetHealthSweeping on return (including on panic) — see maybeRefresh's identical reasoning, registry.go, for why this plugin accepts a bounded, self-terminating background goroutine despite having no Close hook to await it } +// targetHealthIntervalElapsed reports whether probeInterval has passed +// since lastSweepUnixNano (0 meaning "never swept", which always counts +// as elapsed) — the exact rule maybeSweepTargetHealth applies both above +// and, again, under the CAS. +func targetHealthIntervalElapsed(lastSweepUnixNano int64, probeInterval time.Duration) bool { + return lastSweepUnixNano == 0 || time.Duration(time.Now().UnixNano()-lastSweepUnixNano) >= probeInterval +} + // sweepTargetHealth performs one active probe sweep: every configured // MCP server and agent, concurrently, behind a semaphore of // mcpFederatedFanoutConcurrency (mcp_federation.go) — reusing federation's @@ -416,7 +485,7 @@ func (g *Gateway) probeMCPTarget(name, rawURL string, timeout time.Duration) { ctx, cancel := context.WithTimeout(context.Background(), timeout) ok, err := g.probeLegacySSE(ctx, rawURL) cancel() - g.targetHealth.record(targetKindMCP, name, ok, err, time.Since(start), targetHealthSourceProbe) + g.targetHealth.record(targetKindMCP, name, rawURL, ok, err, time.Since(start), targetHealthSourceProbe) return } @@ -429,7 +498,7 @@ func (g *Gateway) probeMCPTarget(name, rawURL string, timeout time.Duration) { g.mcpBackendCloseSession(closeCtx, rawURL, sessionID) closeCancel() } - g.targetHealth.record(targetKindMCP, name, ok, err, time.Since(start), targetHealthSourceProbe) + g.targetHealth.record(targetKindMCP, name, rawURL, ok, err, time.Since(start), targetHealthSourceProbe) } // probeLegacySSE probes a legacy HTTP+SSE-transport MCP server (URL path @@ -473,12 +542,12 @@ func (g *Gateway) probeAgentTarget(name, baseURL, cardPath string, timeout time. req, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL+cardPath, nil) //nolint:gosec // operator-configured target URL, validated at construction (validateTargetURLs, mcp_a2a.go) if err != nil { - g.targetHealth.record(targetKindAgent, name, false, err, time.Since(start), targetHealthSourceProbe) + g.targetHealth.record(targetKindAgent, name, baseURL, false, err, time.Since(start), targetHealthSourceProbe) return } resp, err := g.targetClient.Do(req) if err != nil { - g.targetHealth.record(targetKindAgent, name, false, err, time.Since(start), targetHealthSourceProbe) + g.targetHealth.record(targetKindAgent, name, baseURL, false, err, time.Since(start), targetHealthSourceProbe) return } _ = resp.Body.Close() //nolint:errcheck // read-side close; nothing actionable on failure @@ -487,7 +556,7 @@ func (g *Gateway) probeAgentTarget(name, baseURL, cardPath string, timeout time. if !ok { probeErr = fmt.Errorf("agent probe: upstream returned HTTP %d", resp.StatusCode) } - g.targetHealth.record(targetKindAgent, name, ok, probeErr, time.Since(start), targetHealthSourceProbe) + g.targetHealth.record(targetKindAgent, name, baseURL, ok, probeErr, time.Since(start), targetHealthSourceProbe) } // --- passive recording: handleTargetProxy (mcp_a2a.go) --- @@ -500,7 +569,7 @@ func (g *Gateway) probeAgentTarget(name, baseURL, cardPath string, timeout time. // since a 4xx still proves the target itself answered. A client cancel // (result.clientCanceled) records nothing at all: a caller hanging up // says nothing about the target's own health. -func (g *Gateway) recordTargetProxyHealth(kind, name string, result proxyResult, ok bool, latency time.Duration) { +func (g *Gateway) recordTargetProxyHealth(kind, name, rawURL string, result proxyResult, ok bool, latency time.Duration) { if result.clientCanceled { return } @@ -509,7 +578,7 @@ func (g *Gateway) recordTargetProxyHealth(kind, name string, result proxyResult, if failed { err = targetProxyHealthError(ok, result.status) } - g.targetHealth.record(kind, name, !failed, err, latency, targetHealthSourceTraffic) + g.targetHealth.record(kind, name, rawURL, !failed, err, latency, targetHealthSourceTraffic) } // targetProxyHealthError builds a short, bounded description for a diff --git a/target_health_test.go b/target_health_test.go index fc6f1cc..3ae3424 100644 --- a/target_health_test.go +++ b/target_health_test.go @@ -27,7 +27,7 @@ func TestTargetHealthTracker_NilReceiver_Safe(t *testing.T) { t.Parallel() var tr *targetHealthTracker assert.NotPanics(t, func() { - tr.record(targetKindMCP, "alpha", true, nil, time.Millisecond, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", true, nil, time.Millisecond, targetHealthSourceTraffic) }) assert.Equal(t, targetHealthUnknown, tr.stateOf(targetKindMCP, "alpha")) snap := tr.snapshot(targetKindMCP, "alpha") @@ -37,7 +37,7 @@ func TestTargetHealthTracker_NilReceiver_Safe(t *testing.T) { func TestTargetHealthTracker_SingleSuccess_ReadsHealthy(t *testing.T) { t.Parallel() tr := newTargetHealthTracker(3) - tr.record(targetKindMCP, "alpha", true, nil, 5*time.Millisecond, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", true, nil, 5*time.Millisecond, targetHealthSourceTraffic) assert.Equal(t, targetHealthHealthy, tr.stateOf(targetKindMCP, "alpha")) } @@ -48,10 +48,10 @@ func TestTargetHealthTracker_SingleSuccess_ReadsHealthy(t *testing.T) { func TestTargetHealthTracker_BelowThreshold_StaysHealthy(t *testing.T) { t.Parallel() tr := newTargetHealthTracker(3) - tr.record(targetKindMCP, "alpha", true, nil, 0, targetHealthSourceTraffic) - tr.record(targetKindMCP, "alpha", false, errors.New("boom"), 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", true, nil, 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", false, errors.New("boom"), 0, targetHealthSourceTraffic) assert.Equal(t, targetHealthHealthy, tr.stateOf(targetKindMCP, "alpha"), "1 failure of threshold 3 must still read healthy") - tr.record(targetKindMCP, "alpha", false, errors.New("boom again"), 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", false, errors.New("boom again"), 0, targetHealthSourceTraffic) assert.Equal(t, targetHealthHealthy, tr.stateOf(targetKindMCP, "alpha"), "2 failures of threshold 3 must still read healthy") } @@ -59,19 +59,50 @@ func TestTargetHealthTracker_ReachesThreshold_ReadsUnhealthy(t *testing.T) { t.Parallel() tr := newTargetHealthTracker(3) for i := 0; i < 3; i++ { - tr.record(targetKindMCP, "alpha", false, errors.New("boom"), 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", false, errors.New("boom"), 0, targetHealthSourceTraffic) } assert.Equal(t, targetHealthUnhealthy, tr.stateOf(targetKindMCP, "alpha")) } +// TestTargetHealthTracker_FirstObservationFailure_ReadsUnknown proves F4: +// a target whose only observations so far are failures below +// failureThreshold reads "unknown", not "healthy" — the tracker has +// never actually seen it succeed, so "healthy" would be a false claim +// even though the failure-threshold gate has not fired. The threshold +// still protects against a transient first failure: this stays +// "unknown", it does not jump straight to "unhealthy". +func TestTargetHealthTracker_FirstObservationFailure_ReadsUnknown(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + tr.record(targetKindMCP, "alpha", "", false, errors.New("boom"), 0, targetHealthSourceTraffic) + assert.Equal(t, targetHealthUnknown, tr.stateOf(targetKindMCP, "alpha"), "never having succeeded must read unknown, not healthy, below threshold") + + tr.record(targetKindMCP, "alpha", "", false, errors.New("boom again"), 0, targetHealthSourceTraffic) + assert.Equal(t, targetHealthUnknown, tr.stateOf(targetKindMCP, "alpha"), "still unknown after a second failure, still below threshold") +} + +// TestTargetHealthTracker_SuccessThenFewFailures_ReadsHealthy re-proves +// TestTargetHealthTracker_BelowThreshold_StaysHealthy's claim in F4 +// terms: once a target HAS succeeded at least once, 1-2 subsequent +// failures below threshold still read "healthy" — F4 only changes the +// NEVER-succeeded case. +func TestTargetHealthTracker_SuccessThenFewFailures_ReadsHealthy(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + tr.record(targetKindMCP, "alpha", "", true, nil, 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", false, errors.New("boom"), 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", false, errors.New("boom again"), 0, targetHealthSourceTraffic) + assert.Equal(t, targetHealthHealthy, tr.stateOf(targetKindMCP, "alpha")) +} + func TestTargetHealthTracker_SuccessAfterUnhealthy_RecoversToHealthy(t *testing.T) { t.Parallel() tr := newTargetHealthTracker(2) - tr.record(targetKindMCP, "alpha", false, errors.New("boom"), 0, targetHealthSourceTraffic) - tr.record(targetKindMCP, "alpha", false, errors.New("boom"), 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", false, errors.New("boom"), 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", false, errors.New("boom"), 0, targetHealthSourceTraffic) require.Equal(t, targetHealthUnhealthy, tr.stateOf(targetKindMCP, "alpha")) - tr.record(targetKindMCP, "alpha", true, nil, 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", true, nil, 0, targetHealthSourceTraffic) assert.Equal(t, targetHealthHealthy, tr.stateOf(targetKindMCP, "alpha")) snap := tr.snapshot(targetKindMCP, "alpha") assert.Equal(t, 0, snap.consecutiveFailures, "a success must reset consecutiveFailures to 0") @@ -82,7 +113,7 @@ func TestTargetHealthTracker_ErrorString_BoundedLength(t *testing.T) { t.Parallel() tr := newTargetHealthTracker(3) long := strings.Repeat("x", targetHealthMaxErrorRunes+500) - tr.record(targetKindMCP, "alpha", false, errors.New(long), 0, targetHealthSourceProbe) + tr.record(targetKindMCP, "alpha", "", false, errors.New(long), 0, targetHealthSourceProbe) snap := tr.snapshot(targetKindMCP, "alpha") assert.LessOrEqual(t, len([]rune(snap.lastError)), targetHealthMaxErrorRunes) assert.Equal(t, strings.Repeat("x", targetHealthMaxErrorRunes), snap.lastError) @@ -91,15 +122,65 @@ func TestTargetHealthTracker_ErrorString_BoundedLength(t *testing.T) { func TestTargetHealthTracker_ShortError_Unchanged(t *testing.T) { t.Parallel() tr := newTargetHealthTracker(3) - tr.record(targetKindMCP, "alpha", false, errors.New("dial tcp: connection refused"), 0, targetHealthSourceProbe) + tr.record(targetKindMCP, "alpha", "", false, errors.New("dial tcp: connection refused"), 0, targetHealthSourceProbe) snap := tr.snapshot(targetKindMCP, "alpha") assert.Equal(t, "dial tcp: connection refused", snap.lastError) } +// TestTargetHealthTracker_Record_ScrubsCredentialsFromLastError proves F1: +// record scrubs an error's embedded target URL through sanitizeProviderErr +// before storing lastError, so a target URL configured with an embedded +// credential (an "api-key" query parameter, or userinfo) never survives +// into GET /admin/api/targets. +func TestTargetHealthTracker_Record_ScrubsCredentialsFromLastError(t *testing.T) { + t.Parallel() + + t.Run("query parameter credential", func(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + rawURL := "https://svc.internal/mcp?api-key=SECRETVALUE" + err := errors.New(`Get "` + rawURL + `": dial tcp: connection refused`) + tr.record(targetKindMCP, "alpha", rawURL, false, err, 0, targetHealthSourceProbe) + snap := tr.snapshot(targetKindMCP, "alpha") + assert.NotContains(t, snap.lastError, "SECRETVALUE") + assert.NotContains(t, snap.lastError, "api-key=") + }) + + t.Run("userinfo credential", func(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + rawURL := "https://tok3n@svc.internal/mcp" + err := errors.New(`Get "` + rawURL + `": dial tcp: connection refused`) + tr.record(targetKindMCP, "alpha", rawURL, false, err, 0, targetHealthSourceProbe) + snap := tr.snapshot(targetKindMCP, "alpha") + assert.NotContains(t, snap.lastError, "tok3n") + }) +} + +// TestTargetHealthTracker_Record_ScrubsBeforeTruncate proves F1: the URL +// scrub runs against err.Error() BEFORE truncateRunes bounds it to +// targetHealthMaxErrorRunes — even when the embedded URL straddles the +// truncation point, no fragment of the secret survives. +func TestTargetHealthTracker_Record_ScrubsBeforeTruncate(t *testing.T) { + t.Parallel() + tr := newTargetHealthTracker(3) + rawURL := "https://svc.internal/mcp?api-key=" + strings.Repeat("S", 60) + prefix := strings.Repeat("p", 180) + require.Less(t, len([]rune(prefix)), targetHealthMaxErrorRunes, "prefix must start before the truncation point") + require.Greater(t, len([]rune(prefix))+len([]rune(rawURL)), targetHealthMaxErrorRunes, "the url must straddle the truncation point") + errText := prefix + " " + rawURL + " connection refused" + + tr.record(targetKindMCP, "alpha", rawURL, false, errors.New(errText), 0, targetHealthSourceProbe) + snap := tr.snapshot(targetKindMCP, "alpha") + assert.LessOrEqual(t, len([]rune(snap.lastError)), targetHealthMaxErrorRunes) + assert.NotContains(t, snap.lastError, "SSSS", "no fragment of the secret must survive truncation") + assert.NotContains(t, snap.lastError, "api-key=") +} + func TestTargetHealthTracker_KeyedByKindAndName_Independent(t *testing.T) { t.Parallel() tr := newTargetHealthTracker(1) - tr.record(targetKindMCP, "shared", false, errors.New("boom"), 0, targetHealthSourceTraffic) + tr.record(targetKindMCP, "shared", "", false, errors.New("boom"), 0, targetHealthSourceTraffic) assert.Equal(t, targetHealthUnhealthy, tr.stateOf(targetKindMCP, "shared")) assert.Equal(t, targetHealthUnknown, tr.stateOf(targetKindAgent, "shared"), "an mcp server and an agent sharing a name must track independently") } @@ -109,7 +190,7 @@ func TestTargetHealthTracker_Snapshot_FieldsPopulated(t *testing.T) { now := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC) tr := newTargetHealthTracker(3) tr.nowFn = func() time.Time { return now } - tr.record(targetKindAgent, "beta", true, nil, 42*time.Millisecond, targetHealthSourceProbe) + tr.record(targetKindAgent, "beta", "", true, nil, 42*time.Millisecond, targetHealthSourceProbe) snap := tr.snapshot(targetKindAgent, "beta") assert.Equal(t, targetHealthHealthy, snap.state) @@ -127,7 +208,7 @@ func TestTargetHealthTracker_ConcurrentRecord_NoRace(t *testing.T) { wg.Add(1) go func(i int) { defer wg.Done() - tr.record(targetKindMCP, "alpha", i%2 == 0, errors.New("x"), time.Millisecond, targetHealthSourceTraffic) + tr.record(targetKindMCP, "alpha", "", i%2 == 0, errors.New("x"), time.Millisecond, targetHealthSourceTraffic) }(i) } wg.Wait() @@ -226,9 +307,14 @@ func newTargetHealthSweepGateway(t *testing.T, enabled bool, probeInterval time. func TestMaybeSweepTargetHealth_Disabled_NoOutboundRequests(t *testing.T) { t.Parallel() - hits := 0 + // F6, feat/target-health review: atomic even though a disabled sweep + // must never actually invoke this handler — a regression that DID + // invoke it would otherwise race this counter's read below under + // -race, obscuring the real bug (an unexpected outbound probe) behind + // a data-race report instead of the intended assert.Equal failure. + var hits int32 srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - hits++ + atomic.AddInt32(&hits, 1) w.WriteHeader(http.StatusOK) })) defer srv.Close() @@ -240,7 +326,7 @@ func TestMaybeSweepTargetHealth_Disabled_NoOutboundRequests(t *testing.T) { // wait on — a brief sleep would only prove absence of a signal we // never expect to see. time.Sleep(20 * time.Millisecond) - assert.Equal(t, 0, hits, "a disabled targetHealth must never send an outbound probe") + assert.Equal(t, int32(0), atomic.LoadInt32(&hits), "a disabled targetHealth must never send an outbound probe") assert.Equal(t, targetHealthUnknown, gw.targetHealth.stateOf(targetKindMCP, "alpha")) } @@ -273,7 +359,20 @@ func TestMaybeSweepTargetHealth_ConcurrentTriggers_SingleFlight(t *testing.T) { w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"jsonrpc":"2.0","id":"federated","result":{}}`)) })) - defer srv.Close() + // F6, feat/target-health review: registered in this order so + // t.Cleanup's LIFO order unblocks the handler (closing release) + // BEFORE srv.Close runs — httptest.Server.Close blocks until + // outstanding requests complete, and the assertions below can + // t.Fatalf/t.Errorf before ever reaching the explicit close(release) + // further down; without this a failing assertion left the handler + // permanently blocked and srv.Close hung until the whole test + // binary's 10-minute timeout, rather than failing fast. unblock is + // idempotent (sync.Once) since the happy path below also calls it + // directly, before waiting on the sweep's resulting state. + var unblockOnce sync.Once + unblock := func() { unblockOnce.Do(func() { close(release) }) } + t.Cleanup(srv.Close) + t.Cleanup(unblock) gw := newTargetHealthSweepGateway(t, true, time.Hour, srv.URL) @@ -292,11 +391,64 @@ func TestMaybeSweepTargetHealth_ConcurrentTriggers_SingleFlight(t *testing.T) { // maybeSweepTargetHealth concurrently, at most one outbound request // must have been sent. waitForCondition(t, func() bool { return atomic.LoadInt32(&hits) > 0 }, time.Second) - close(release) + unblock() waitForCondition(t, func() bool { return gw.targetHealth.stateOf(targetKindMCP, "alpha") != targetHealthUnknown }, time.Second) assert.Equal(t, int32(1), atomic.LoadInt32(&hits), "concurrent triggers within one interval must produce exactly one sweep") } +// TestMaybeSweepTargetHealth_IntervalEnforcedAcrossRapidCalls proves F3: +// the interval load (top of maybeSweepTargetHealth) and the CAS that wins +// the single-flight flag are not atomic with each other. Without a +// re-check under the CAS, a caller whose own interval read predates an +// entirely separate sweep's start-and-finish could still win the CAS +// once that sweep clears the flag, and spawn a second sweep inside the +// same interval — worst at startup, when every caller's first read sees +// last == 0. A fast-completing first sweep, immediately followed by a +// burst of concurrent callers, must still yield exactly one sweep within +// probeInterval; a call after the interval has genuinely elapsed must +// start a second one. +func TestMaybeSweepTargetHealth_IntervalEnforcedAcrossRapidCalls(t *testing.T) { + t.Parallel() + var hits int32 + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + atomic.AddInt32(&hits, 1) + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"jsonrpc":"2.0","id":"federated","result":{}}`)) + })) + defer srv.Close() + + probeInterval := 150 * time.Millisecond + gw := newTargetHealthSweepGateway(t, true, probeInterval, srv.URL) + + // First sweep: the probe answers immediately, so this completes fast + // and clears targetHealthSweeping well inside probeInterval. + gw.maybeSweepTargetHealth() + waitForCondition(t, func() bool { return atomic.LoadInt32(&hits) > 0 }, time.Second) + waitForCondition(t, func() bool { return gw.targetHealth.stateOf(targetKindMCP, "alpha") != targetHealthUnknown }, time.Second) + + // A burst of concurrent callers immediately after — still well inside + // probeInterval — must not start a second sweep. + var wg sync.WaitGroup + for i := 0; i < 50; i++ { + wg.Add(1) + go func() { + defer wg.Done() + gw.maybeSweepTargetHealth() + }() + } + wg.Wait() + time.Sleep(30 * time.Millisecond) // let any wrongly-spawned sweep reach the server + if got := atomic.LoadInt32(&hits); got != 1 { + t.Errorf("hits = %d, want exactly 1 (a burst of concurrent callers inside probeInterval must not start a second sweep)", got) + } + + // Once probeInterval has genuinely elapsed, a new call starts a + // second sweep. + time.Sleep(probeInterval) + gw.maybeSweepTargetHealth() + waitForCondition(t, func() bool { return atomic.LoadInt32(&hits) == 2 }, time.Second) +} + // TestMaybeSweepTargetHealth_LegacySSE_ClosesBodyWithoutReading proves a // legacy "/sse" MCP server's probe uses a plain GET and closes the body // immediately: a test server that never closes its stream must not hang @@ -304,6 +456,7 @@ func TestMaybeSweepTargetHealth_ConcurrentTriggers_SingleFlight(t *testing.T) { func TestMaybeSweepTargetHealth_LegacySSE_ClosesBodyWithoutReading(t *testing.T) { t.Parallel() headersSent := make(chan struct{}) + release := make(chan struct{}) srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") w.WriteHeader(http.StatusOK) @@ -312,9 +465,18 @@ func TestMaybeSweepTargetHealth_LegacySSE_ClosesBodyWithoutReading(t *testing.T) if ok { flusher.Flush() } - <-r.Context().Done() // never closes on its own; relies on the probe not reading + <-release // never closes on its own; relies on the probe not reading })) - defer srv.Close() + // F6, feat/target-health review: previously relied on the PROBE'S OWN + // 5s context timeout (targetTimeout below) to unblock this handler, + // so srv.Close (deferred) silently added a real ~5s stall to every + // run of this test. An explicit release channel, unblocked via + // t.Cleanup BEFORE srv.Close (LIFO — see + // TestMaybeSweepTargetHealth_ConcurrentTriggers_SingleFlight's own + // comment for the identical ordering reasoning), makes this test + // fast AND immune to a failing assertion ever leaving it blocked. + t.Cleanup(srv.Close) + t.Cleanup(func() { close(release) }) adapters := map[string]providerAdapter{"openai": newFakeAdapter("openai")} cfg := &Config{ From 88260a386bbb18a7139d4f02368fdc0234ad860a Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 02:45:15 +0100 Subject: [PATCH 06/15] fix(target-health): ignore context-caused federation errors mcpFederatedToolsList's fan-out and mcpFederatedToolsCall both derive their outbound context from r.Context(). A client cancel (context.Canceled) or the shared fan-out deadline expiring (context.DeadlineExceeded) is not evidence about a server's own health, so neither is recorded any more, mirroring recordTargetProxyHealth's own client-cancel rule. A server that is genuinely hung is still caught by the active probe sweep or its own per-server proxy health. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- README.md | 7 +- mcp_federation.go | 23 +++++- mcp_federation_test.go | 161 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 188 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 4bd9de3..f05c4d0 100644 --- a/README.md +++ b/README.md @@ -1893,7 +1893,12 @@ plugin's config. `POST /mcp`'s `tools/list` fan-out and `tools/call` record a failure only when the outbound call itself fails (`err != nil` from the backend call) — a JSON-RPC-level `error` in the backend's own - response still counts as reachable, since the server answered. + response still counts as reachable, since the server answered. A + context-caused failure (the caller canceling, or the shared fan-out + deadline expiring) records nothing at all, the same client-cancel + rule the per-server proxy above applies; a genuinely hung server is + still caught by the active probe sweep or its own per-server proxy + health. - **Active probes are opt-in** (`targetHealth.enabled: true`) and lazy: no timer, no background goroutine running on its own. A probe sweep is triggered by `/metrics`, `GET /admin/api/targets`, `GET diff --git a/mcp_federation.go b/mcp_federation.go index 223bbd2..bdd6bd2 100644 --- a/mcp_federation.go +++ b/mcp_federation.go @@ -980,7 +980,20 @@ func (g *Gateway) mcpFederatedToolsList(w http.ResponseWriter, format mcpRespons // it is recorded separately, below, once the shape is known. probeStart := time.Now() resp, err := g.mcpBackendCall(fanoutCtx, targetURL, "tools/list", struct{}{}, mcpBackendResponseMaxBytes) - g.targetHealth.record(targetKindMCP, name, targetURL, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) + // F2: fanoutCtx is derived from r.Context() (above), so a + // client hang-up (context.Canceled) surfaces here as EVERY + // still-in-flight server's own error, and the shared + // toolsListBackendTimeout expiry (context.DeadlineExceeded) + // surfaces identically for a server that was genuinely slow + // AND one still parked on sem, never dialed at all — neither + // says anything about that server's own health, so neither is + // recorded, mirroring recordTargetProxyHealth's identical + // client-cancel rule (target_health.go). A server that is + // really hung is instead caught by the active probe sweep or + // its own per-request proxy health, not by this fan-out. + if err == nil || (!errors.Is(err, context.Canceled) && !errors.Is(err, context.DeadlineExceeded)) { + g.targetHealth.record(targetKindMCP, name, targetURL, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) + } mu.Lock() defer mu.Unlock() @@ -1103,7 +1116,13 @@ func (g *Gateway) mcpFederatedToolsCall(w http.ResponseWriter, format mcpRespons // not. probeStart := time.Now() resp, err := g.mcpBackendCall(ctx, targetURL, "tools/call", mcpToolCallParams{Name: toolName, Arguments: params.Arguments}, mcpBackendCallResponseMaxBytes) - g.targetHealth.record(targetKindMCP, serverName, targetURL, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) + // F2: same context-caused-error guard as mcpFederatedToolsList's own + // fan-out, above — ctx here derives from r.Context() too, so a client + // cancel or the shared toolsCallBackendTimeout expiry must record + // nothing rather than a false failure. + if err == nil || (!errors.Is(err, context.Canceled) && !errors.Is(err, context.DeadlineExceeded)) { + g.targetHealth.record(targetKindMCP, serverName, targetURL, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) + } g.limiter.countTargetRequest(targetKindMCP, serverName) if err != nil { g.logf("federated tools/call: server %q: %v", serverName, err) diff --git a/mcp_federation_test.go b/mcp_federation_test.go index 94933e2..a386eb6 100644 --- a/mcp_federation_test.go +++ b/mcp_federation_test.go @@ -1995,3 +1995,164 @@ func TestHandleMCPFederated_ToolsCall_TargetHealth_UnreachableServer_RecordsUnhe t.Errorf("alpha state = %q, want unhealthy", got) } } + +// --- feat/target-health F2: context-caused fan-out errors record nothing --- +// +// A plain connection-refused server still recording a failure is already +// covered by TestHandleMCPFederated_ToolsList_TargetHealth_RecordsPerServer +// (tools/list) and TestHandleMCPFederated_ToolsCall_TargetHealth_UnreachableServer_RecordsUnhealthy +// (tools/call) above — both must keep passing unchanged by the F2 fix +// below, which only special-cases context.Canceled/context.DeadlineExceeded. + +// TestHandleMCPFederated_ToolsList_ClientCanceled_RecordsNothing proves F2: +// a client cancel mid-fan-out — context.Canceled propagating from +// r.Context() into fanoutCtx — records nothing for the servers still in +// flight, mirroring recordTargetProxyHealth's own client-cancel rule +// (target_health.go): a caller hanging up says nothing about the target's +// own health. +func TestHandleMCPFederated_ToolsList_ClientCanceled_RecordsNothing(t *testing.T) { + reached := make(chan struct{}, 2) + release := make(chan struct{}) + blocking := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + reached <- struct{}{} + <-release + }) + alpha := httptest.NewServer(blocking) + beta := httptest.NewServer(blocking) + // Registered in this order so t.Cleanup's LIFO order unblocks both + // handlers (closing release) BEFORE either server's Close is called — + // httptest.Server.Close blocks until outstanding requests complete, so + // closing it first would deadlock until the test's own timeout (F6). + t.Cleanup(alpha.Close) + t.Cleanup(beta.Close) + t.Cleanup(func() { close(release) }) + + cfg := newFederationTestConfig(alpha.URL, beta.URL, false) + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + ctx, cancel := context.WithCancel(context.Background()) + req := newFederatedRequest(t, "sk-alice", jsonrpcRequest{JSONRPC: jsonrpcVersion, Method: "tools/list", ID: json.RawMessage("1")}).WithContext(ctx) + + done := make(chan struct{}) + rec := httptest.NewRecorder() + go func() { + h.ServeHTTP(rec, req) + close(done) + }() + + <-reached + <-reached + cancel() + <-done + + if got := gw.targetHealth.stateOf(targetKindMCP, "alpha"); got != targetHealthUnknown { + t.Errorf("alpha state = %q, want unknown (a client cancel must record nothing)", got) + } + if got := gw.targetHealth.stateOf(targetKindMCP, "beta"); got != targetHealthUnknown { + t.Errorf("beta state = %q, want unknown (a client cancel must record nothing)", got) + } +} + +// TestHandleMCPFederated_ToolsList_SharedDeadlineExpiry_RecordsNothing +// proves F2's second case: when the fan-out's own shared context expires +// (toolsListBackendTimeout, or here the incoming request's own shorter +// deadline — see TestHandleMCPFederated_ToolsList_SlowBackend_BoundedByRequestContext's +// own doc comment for why that stands in for the real 20s budget), a +// server still parked behind the fan-out semaphore — never actually +// dialed — must not be recorded as a failure either. mcpBackendCall +// returns the identical context.DeadlineExceeded whether a server was +// slow or never contacted at all, so this case is handled by the same +// guard as the client-cancel case above, not by tracking who was dialed. +func TestHandleMCPFederated_ToolsList_SharedDeadlineExpiry_RecordsNothing(t *testing.T) { + block := make(chan struct{}) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + <-block + })) + t.Cleanup(srv.Close) + t.Cleanup(func() { close(block) }) + + // One more server than the fan-out semaphore has slots for + // (mcpFederatedFanoutConcurrency) guarantees at least one is still + // parked on the semaphore, never dialed, when the shared deadline + // fires. + names := make([]string, 0, mcpFederatedFanoutConcurrency+1) + mcpServers := make(map[string]*TargetConfig, mcpFederatedFanoutConcurrency+1) + for i := 0; i < mcpFederatedFanoutConcurrency+1; i++ { + name := fmt.Sprintf("srv%d", i) + names = append(names, name) + mcpServers[name] = &TargetConfig{URL: srv.URL} + } + + cfg := CreateConfig() + cfg.Providers = map[string]*ProviderConfig{"openai": {Type: "openai", APIKey: "k"}} + cfg.MCPServers = mcpServers + cfg.Groups = map[string]*GroupConfig{"default": {}} + cfg.Users = &UsersConfig{Inline: []*UserConfig{{Name: "alice", Group: "default", APIKey: "sk-alice"}}} + + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + req := newFederatedRequest(t, "sk-alice", jsonrpcRequest{JSONRPC: jsonrpcVersion, Method: "tools/list", ID: json.RawMessage("1")}) + shortCtx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond) + defer cancel() + req = req.WithContext(shortCtx) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, req) + + for _, name := range names { + if got := gw.targetHealth.stateOf(targetKindMCP, name); got != targetHealthUnknown { + t.Errorf("mcp/%s state = %q, want unknown (a shared fan-out deadline expiry must record nothing)", name, got) + } + } +} + +// TestHandleMCPFederated_ToolsCall_ClientCanceled_RecordsNothing mirrors +// TestHandleMCPFederated_ToolsList_ClientCanceled_RecordsNothing for +// tools/call's own, separate context.WithTimeout(r.Context(), ...) call +// site. +func TestHandleMCPFederated_ToolsCall_ClientCanceled_RecordsNothing(t *testing.T) { + reached := make(chan struct{}) + release := make(chan struct{}) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + close(reached) + <-release + })) + t.Cleanup(srv.Close) + t.Cleanup(func() { close(release) }) + + cfg := newFederationTestConfig(srv.URL, "http://beta.invalid", true) + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + ctx, cancel := context.WithCancel(context.Background()) + callParams, _ := json.Marshal(mcpToolCallParams{Name: "alpha_lookup"}) + req := newFederatedRequest(t, "sk-alice", jsonrpcRequest{ + JSONRPC: jsonrpcVersion, Method: "tools/call", ID: json.RawMessage("1"), Params: callParams, + }).WithContext(ctx) + + done := make(chan struct{}) + rec := httptest.NewRecorder() + go func() { + h.ServeHTTP(rec, req) + close(done) + }() + + <-reached + cancel() + <-done + + if got := gw.targetHealth.stateOf(targetKindMCP, "alpha"); got != targetHealthUnknown { + t.Errorf("alpha state = %q, want unknown (a client cancel must record nothing)", got) + } +} From f5d9014b130a91dfb8714e36e13eb54a98a7ed95 Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 02:46:04 +0100 Subject: [PATCH 07/15] test(target-health): deterministic yaegi-check and non-blocking sweep tests MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit exerciseTargetHealth's traffic-sourced assertion (mcpProbeServerName must read healthy/traffic, F5 review) raced its own trigger: GET /admin/api/targets was the first-ever sweep-capable route this harness hit, so the background sweep it started could beat the response encode and overwrite source from traffic to probe under Yaegi's interpreter overhead. exerciseTargetHealthProbeWarmup now runs first, before exerciseHandler, against a dedicated, never- proxied MCP target — its health can only ever be written by the probe, so polling it to healthy/probe both proves the interpreted active-probe path end to end and spends this gateway's one probeInterval-bounded sweep before any traffic runs, making every later target-health assertion in this harness deterministic. probeInterval moves from 10s to 60s so no later exercise can trigger a second sweep mid-run. TARGETHEALTH-1's expected state also updates to unknown, reflecting F4 (a2d152b1): mcpProbeServerName's only observation is a failed tools/call, so it has never once succeeded. mcp_a2a_test.go's ClientCanceled_RecordsNothing test replaces its 30ms-cancel-vs-200ms-sleep timing margin with a channel handshake (cancel only once the handler is genuinely reached, then release it), removing any wall-clock dependence. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- mcp_a2a_test.go | 34 ++++++-- tools/yaegi-check/main.go | 178 ++++++++++++++++++++++++++++++++------ 2 files changed, 178 insertions(+), 34 deletions(-) diff --git a/mcp_a2a_test.go b/mcp_a2a_test.go index 7394d66..ab2f1c2 100644 --- a/mcp_a2a_test.go +++ b/mcp_a2a_test.go @@ -1100,13 +1100,26 @@ func TestHandleTargetProxy_TargetHealth_HangTripsWatchdog_RecordsUnhealthy(t *te // TestHandleTargetProxy_TargetHealth_ClientCanceled_RecordsNothing // proves a canceled CLIENT request records nothing at all — the target's // own health stays "unknown", not "unhealthy", since the client hanging -// up says nothing about the target. +// up says nothing about the target. F6, feat/target-health review: uses +// a channel handshake (cancel only once the handler has genuinely been +// reached, then release it) instead of a 30ms-cancel-vs-200ms-sleep +// wall-clock margin, which left no slack under load and could either +// cancel before the request reached the handler or fail to prove the +// cancel raced a still-in-flight request. func TestHandleTargetProxy_TargetHealth_ClientCanceled_RecordsNothing(t *testing.T) { + reached := make(chan struct{}) + release := make(chan struct{}) srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - time.Sleep(200 * time.Millisecond) + close(reached) + <-release w.WriteHeader(http.StatusOK) })) - defer srv.Close() + // Registered in this order so t.Cleanup's LIFO order unblocks the + // handler (closing release) BEFORE srv.Close runs — see + // TestMaybeSweepTargetHealth_ConcurrentTriggers_SingleFlight's own + // comment (target_health_test.go) for the identical reasoning. + t.Cleanup(srv.Close) + t.Cleanup(func() { close(release) }) cfg := newTargetHealthProxyConfig(srv.URL) h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") @@ -1116,13 +1129,18 @@ func TestHandleTargetProxy_TargetHealth_ClientCanceled_RecordsNothing(t *testing gw := h.(*Gateway) ctx, cancel := context.WithCancel(context.Background()) - go func() { - time.Sleep(30 * time.Millisecond) - cancel() - }() req := httptest.NewRequest(http.MethodGet, "/mcp/alpha/tools/list", nil).WithContext(ctx) req.Header.Set("Authorization", "Bearer sk-alice") - h.ServeHTTP(httptest.NewRecorder(), req) + + done := make(chan struct{}) + go func() { + h.ServeHTTP(httptest.NewRecorder(), req) + close(done) + }() + + <-reached + cancel() + <-done snap := gw.targetHealth.snapshot(targetKindMCP, "alpha") if snap.state != targetHealthUnknown { diff --git a/tools/yaegi-check/main.go b/tools/yaegi-check/main.go index 136e370..3607517 100644 --- a/tools/yaegi-check/main.go +++ b/tools/yaegi-check/main.go @@ -415,6 +415,20 @@ func run() error { targetHealthDownUpstream := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {})) targetHealthDownURL := targetHealthDownUpstream.URL targetHealthDownUpstream.Close() + // targetHealthProbeOnlyUpstream answers any JSON-RPC call — in + // practice only ever "initialize", from the active probe sweep + // (target_health.go's probeMCPTarget) — with a small, valid result + // well under mcpBackendResponseMaxBytes (4MiB), so the probe's + // handshake genuinely SUCCEEDS. targetHealthProbeOnlyServerName's own + // doc comment explains why this server backs a dedicated, + // never-proxied target rather than reusing mcpProbeUpstream (whose + // 11MiB body exceeds every response-size cap this plugin enforces, + // probe included, so it can only ever record a failure). + targetHealthProbeOnlyUpstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Type", "application/json") + _, _ = w.Write([]byte(`{"jsonrpc":"2.0","id":"federated","result":{"protocolVersion":"2025-11-25","capabilities":{}}}`)) + })) + defer targetHealthProbeOnlyUpstream.Close() // anthropicProbeUpstream answers an Anthropic Messages API call with a // real Anthropic-shaped body, so the /v1/messages passthrough branch // (callAnthropicMessagesPassthrough) runs interpreted. A body @@ -598,16 +612,19 @@ func run() error { // runs correctly under Yaegi too, not just the config-override // one testDataWantModel already exercises. `"modelMeta":{"` + testDataWantModel + `":{"contextTokens":` + yaegiMetaContextTokens + `,"inputCostPerMTokMicroUsd":1250000,"outputCostPerMTokMicroUsd":10000000}},` + - `"mcpServers":{"` + mcpProbeServerName + `":{"url":"` + mcpProbeUpstream.URL + `"},"` + targetHealthDownServerName + `":{"url":"` + targetHealthDownURL + `"}},` + - // targetHealth (feat/target-health): enabled with a short - // probeInterval so a future active-probe assertion could run - // quickly if this harness ever adds one — exerciseTargetHealth - // (below) currently exercises the passive-recording and - // admin/metrics-exposure paths only, driven by real traffic - // (exerciseFederatedTooLarge's own federated call, and - // exerciseTargetHealth's own direct proxy calls against - // targetHealthDownServerName), never the active sweep itself. - `"targetHealth":{"enabled":true,"probeInterval":"10s"},` + + `"mcpServers":{"` + mcpProbeServerName + `":{"url":"` + mcpProbeUpstream.URL + `"},"` + targetHealthDownServerName + `":{"url":"` + targetHealthDownURL + `"},"` + targetHealthProbeOnlyServerName + `":{"url":"` + targetHealthProbeOnlyUpstream.URL + `"}},` + + // targetHealth (feat/target-health): enabled. probeInterval is + // deliberately well ABOVE the floor (10s): exerciseTargetHealthProbeWarmup + // (below) spends this gateway's ONE sweep for the whole + // probeInterval window right after construction, before any other + // exercise runs, specifically so no LATER exercise's own GET + // /admin/api/targets, /metrics, /v1/mcp/servers, or /v1/agents + // call can trigger a second sweep mid-run and race a passive- + // traffic assertion (F5, feat/target-health review — see + // exerciseTargetHealth's own doc comment for the exact race this + // avoids). "60s" comfortably outlasts this whole harness's + // real-world runtime. + `"targetHealth":{"enabled":true,"probeInterval":"60s"},` + // metrics (Prometheus text-exposition endpoint): enabled with // modelLabel on, so exerciseMetricsRoute below exercises the // opt-in per-(provider,model) breakdown under the interpreter @@ -663,6 +680,15 @@ func run() error { return fmt.Errorf("%s.New's returned value does not implement http.Handler", pkgName) } + // exerciseTargetHealthProbeWarmup (feat/target-health, F5 review) runs + // FIRST, before exerciseHandler and everything after it: its own doc + // comment explains why this ordering is what makes every later + // target-health assertion in this harness deterministic rather than + // racing the active probe sweep under Yaegi's interpreter overhead. + if err := exerciseTargetHealthProbeWarmup(handler); err != nil { + return err + } + if err := exerciseHandler(handler, builtinLookupContextTokens, failoverBHits); err != nil { return err } @@ -798,6 +824,18 @@ const ( targetHealthFailureThreshold = 3 ) +// targetHealthProbeOnlyServerName is a THIRD MCP server run() configures, +// against targetHealthProbeOnlyUpstream — a real, always-answering +// upstream this harness never proxies traffic through (no per-server +// proxy call, no federated tools/list or tools/call ever names it): its +// health entry can only ever be written by the ACTIVE PROBE sweep +// (target_health.go's probeMCPTarget), never by passive traffic. F5, +// feat/target-health review: exerciseTargetHealthProbeWarmup (below) +// uses this determinism to assert source == "probe" without racing +// anything, and to prove the interpreted initialize/close handshake path +// itself, not just "some sweep ran". +const targetHealthProbeOnlyServerName = "target-health-probe-only" + // metricsProbeAllowedCIDR is the CIDR block attemptAccountingOverride's // own metrics.allowedCIDRs names — see that literal's own comment for why // this must contain httptest.NewRequest's default RemoteAddr. @@ -1774,6 +1812,28 @@ type targetHealthProbeView struct { Source string `json:"source"` } +// pollTargetHealth drives GET /admin/api/targets against handler +// repeatedly until name's health satisfies want, or a 5s budget elapses, +// then returns its final reading either way — mirrors +// pollProviderAttemptCounters's identical poll-with-deadline shape +// (below), applied here to feat/target-health's own async sweep +// (maybeSweepTargetHealth spawns the actual probing goroutine and +// returns immediately, target_health.go's own doc comment) instead of +// limiter.spawn's async counter write. +func pollTargetHealth(handler http.Handler, name string, want func(targetHealthProbeView) bool) (targetHealthProbeView, error) { + deadline := time.Now().Add(5 * time.Second) + for { + health, err := readTargetHealth(handler, name) + if err != nil { + return targetHealthProbeView{}, err + } + if want(health) || time.Now().After(deadline) { + return health, nil + } + time.Sleep(10 * time.Millisecond) + } +} + // readTargetHealth returns name's own "health" object from GET // /admin/api/targets, searching both mcpServers and agents (mcpProbeServerName // and targetHealthDownServerName are both MCP servers, but this checks @@ -1812,28 +1872,94 @@ func readTargetHealth(handler http.Handler, name string) (targetHealthProbeView, return targetHealthProbeView{}, fmt.Errorf("target %q not in GET /admin/api/targets: %s", name, rec.Body.String()) } -// exerciseTargetHealth proves feat/target-health end to end under the -// REAL interpreter. Part (a): mcpProbeServerName already received one -// real federated tools/call attempt via exerciseFederatedTooLarge, -// above — its oversized response trips errMCPResponseTooLarge, a -// transport-level failure from doBackendJSONRPC's own perspective +// exerciseTargetHealthProbeWarmup proves feat/target-health's ACTIVE +// PROBE sweep end to end under the REAL interpreter, and — just as +// important — makes every LATER target-health assertion in this harness +// deterministic. Called from run() BEFORE exerciseHandler, i.e. before +// any other route this harness hits: GET /admin/api/targets is the +// first-ever sweep-capable route (maybeSweepTargetHealth's own doc +// comment, target_health.go, lists the four: serveMetrics, +// serveAdminTargets, handleMCPServers, handleAgents) this handler sees, +// so it deterministically owns the ONE sweep this gateway's +// probeInterval (configured to "60s", well above this harness's +// real-world runtime) allows for the rest of the run. +// +// This matters because targetHealthProbeOnlyServerName's own record() is +// not the only one a sweep touches — EVERY configured MCP server and +// agent gets probed in the same sweep (sweepTargetHealth's own doc +// comment), mcpProbeServerName included. Spending that one sweep here, +// before exerciseFederatedTooLarge ever drives mcpProbeServerName's real +// traffic observation, guarantees the traffic observation is the LAST +// write to that entry for the remainder of the run — no later +// admin/metrics/listing route can trigger a second sweep to race it +// (F5, feat/target-health review: this is what closes the race that +// used to make TARGETHEALTH-2, below, racy under Yaegi's interpreter +// overhead). +// +// targetHealthProbeOnlyServerName is dedicated to this assertion +// specifically because it is NEVER proxied or federated through by any +// other exercise in this harness — its health entry can only ever be +// written by the probe, so source == "probe" here is not just likely, +// it is the only value possible. Polling (pollTargetHealth) rather than +// asserting on a single read: the sweep itself still runs on its own +// spawned goroutine even though this call triggered it. +func exerciseTargetHealthProbeWarmup(handler http.Handler) error { + health, err := pollTargetHealth(handler, targetHealthProbeOnlyServerName, func(h targetHealthProbeView) bool { + return h.State != "unknown" + }) + if err != nil { + return err + } + if health.Source != "probe" { + return fmt.Errorf("TARGETHEALTH-PROBE-1: GET /admin/api/targets: %q health.source = %q, want %q (only the active probe ever touches this target)", targetHealthProbeOnlyServerName, health.Source, "probe") + } + // Recover's own swallow (sweepTargetHealth's defer, target_health.go) + // means an interpreted panic mid-probe would otherwise degrade to a + // silently-stuck "unknown" rather than a loud failure — asserting the + // FULL success shape here (not merely "state != unknown") is what + // makes a Yaegi incompatibility in the initialize/close handshake + // path visible instead of passing silently. + if health.State != "healthy" { + return fmt.Errorf("TARGETHEALTH-PROBE-2: GET /admin/api/targets: %q health.state = %q, want healthy (targetHealthProbeOnlyUpstream always answers initialize successfully)", targetHealthProbeOnlyServerName, health.State) + } + + fmt.Println("yaegi-check: target health active probe sweep ran and recorded correctly interpreted") + return nil +} + +// exerciseTargetHealth proves feat/target-health's PASSIVE recording end +// to end under the REAL interpreter, now that +// exerciseTargetHealthProbeWarmup (run() calls it first, above) has +// already spent this gateway's one probeInterval-bounded sweep — no +// further sweep can fire during this function, so neither part below +// races the active probe path. +// +// Part (a): mcpProbeServerName receives one real federated tools/call +// attempt via exerciseFederatedTooLarge (exerciseHandler, called before +// this function) — its oversized response trips errMCPResponseTooLarge, +// a transport-level failure from doBackendJSONRPC's own perspective // (mcp_federation.go), which mcpFederatedToolsCall records as a -// target-health failure. One failure stays well under -// targetHealthFailureThreshold, so the target still reads "healthy" — -// target_health.go's own doc comment explains why 1-2 recent failures -// short of the threshold stay healthy. Part (b): drives -// targetHealthFailureThreshold consecutive failures through the direct -// per-server proxy path (/mcp/{name}/..., handleTargetProxy) against -// targetHealthDownServerName's dead upstream, then asserts the SAME -// tracker flips that target to "unhealthy" on both GET -// /admin/api/targets and llmgateway_target_healthy on /metrics. +// target-health failure. This is the ONLY observation this target ever +// receives (the warmup above never touches it — see +// exerciseTargetHealthProbeWarmup's own doc comment for why spending the +// sweep before this call matters), so it has never once succeeded: +// F4 (feat/target-health review) reads that as "unknown", not "healthy" +// — the failure-threshold gate still protects against this single +// transient-looking failure, so it does not read "unhealthy" either. +// +// Part (b): drives targetHealthFailureThreshold consecutive failures +// through the direct per-server proxy path (/mcp/{name}/..., +// handleTargetProxy) against targetHealthDownServerName's dead upstream, +// then asserts the SAME tracker flips that target to "unhealthy" on +// both GET /admin/api/targets and llmgateway_target_healthy on +// /metrics. func exerciseTargetHealth(handler http.Handler) error { probeHealth, err := readTargetHealth(handler, mcpProbeServerName) if err != nil { return err } - if probeHealth.State != "healthy" { - return fmt.Errorf("TARGETHEALTH-1: GET /admin/api/targets: %q health.state = %q, want healthy (after one federated tools/call attempt, below threshold): %+v", mcpProbeServerName, probeHealth.State, probeHealth) + if probeHealth.State != "unknown" { + return fmt.Errorf("TARGETHEALTH-1: GET /admin/api/targets: %q health.state = %q, want unknown (one failed federated tools/call attempt, never having succeeded, below threshold — F4): %+v", mcpProbeServerName, probeHealth.State, probeHealth) } if probeHealth.Source != "traffic" { return fmt.Errorf("TARGETHEALTH-2: GET /admin/api/targets: %q health.source = %q, want %q", mcpProbeServerName, probeHealth.Source, "traffic") From 10d1825ed70305275ff97f2ca6d6dfaefd6e89aa Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 02:47:07 +0100 Subject: [PATCH 08/15] fix(target-health): omit target metrics family when unconfigured writeTargetMetrics now returns before emitting even llmgateway_target_healthy's own HELP/TYPE header when neither an MCP server nor an agent is configured, mirroring writeStoreHealthMetrics' identical behaviour when Redis is unconfigured. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- README.md | 4 +++- metrics.go | 8 ++++++++ metrics_test.go | 52 +++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 63 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index f05c4d0..6a094d0 100644 --- a/README.md +++ b/README.md @@ -1684,7 +1684,9 @@ plugin's config. - `llmgateway_target_healthy{kind,target}` — `1`/`0` gauge for an MCP server or A2A agent's tracked health; `kind` is `"mcp"` or `"agent"`. No sample at all for a target this tracker has never observed — see - [MCP and A2A](#mcp-and-a2a)'s "Target health" section. + [MCP and A2A](#mcp-and-a2a)'s "Target health" section. The whole + family, HELP and TYPE lines included, is absent entirely when no MCP + servers or agents are configured. - `llmgateway_limit_store_up` — `1`/`0` gauge for this replica's own connection to the configured limit store (Redis); absent entirely when no store is configured. Every store-backed family above simply diff --git a/metrics.go b/metrics.go index b39ad8b..a242d87 100644 --- a/metrics.go +++ b/metrics.go @@ -694,7 +694,15 @@ func (g *Gateway) writeProviderMetrics(m *metricWriter) { // unreadable". Iterates every CONFIGURED MCP server and agent (not just // ones the tracker happens to have an entry for), so a target removed // from config since its last observation contributes no stale series. +// F7, feat/target-health review: returns before emitting even the family's +// own HELP/TYPE header when no MCP server or agent is configured at all — +// mirrors writeStoreHealthMetrics' identical "nothing to report, no family +// either" early return above, rather than a HELP/TYPE line promising a +// metric family that can never carry a sample in this deployment. func (g *Gateway) writeTargetMetrics(m *metricWriter) { + if len(g.cfg.MCPServers) == 0 && len(g.cfg.Agents) == 0 { + return + } m.family("llmgateway_target_healthy", "gauge", "1 when an MCP server or A2A agent's health (last passive observation or active probe) is healthy, 0 when its consecutive-failure count has reached targetHealth.failureThreshold. No sample while never yet observed."+aggregationNoteTargetHealthy) diff --git a/metrics_test.go b/metrics_test.go index 0bf64a3..234206a 100644 --- a/metrics_test.go +++ b/metrics_test.go @@ -1521,6 +1521,58 @@ func TestMetrics_TargetHealthy_NoSampleWhileUnknown(t *testing.T) { } } +// TestMetrics_TargetHealthy_NoSampleWhileNeverSucceeded proves F4's +// second no-sample case: a target that HAS been observed, but has never +// once succeeded and is still below failureThreshold, reads "unknown" +// (TestTargetHealthTracker_FirstObservationFailure_ReadsUnknown) and +// therefore still emits no llmgateway_target_healthy sample — the same +// "a gap is honest, a fabricated value is not" rule the never-observed +// case above applies, now extended to "observed but never succeeded". +func TestMetrics_TargetHealthy_NoSampleWhileNeverSucceeded(t *testing.T) { + t.Parallel() + cfg := newMetricsTestConfig() + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: "http://mcp-alpha.internal"}} + h, gw := newMetricsGatewayHandle(t, cfg) + + gw.targetHealth.record(targetKindMCP, "alpha", "", false, errors.New("boom"), time.Millisecond, targetHealthSourceProbe) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, metricsRequest(http.MethodGet, metricsPathDefault, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200", rec.Code) + } + _, samples := parsePrometheusText(t, rec.Body.Bytes()) + for _, s := range samples { + if s.name == "llmgateway_target_healthy" { + t.Errorf("unexpected sample %v — a target that has never succeeded must emit nothing", s) + } + } +} + +// TestMetrics_TargetHealthy_FamilyAbsentWhenNoTargetsConfigured proves +// F7: writeTargetMetrics omits even llmgateway_target_healthy's own +// HELP/TYPE header when no MCP server or agent is configured at all — +// mirroring writeStoreHealthMetrics' identical "nothing to report, no +// family either" behavior when Redis is unconfigured. +func TestMetrics_TargetHealthy_FamilyAbsentWhenNoTargetsConfigured(t *testing.T) { + t.Parallel() + cfg := newMetricsTestConfig() + h, _ := newMetricsGatewayHandle(t, cfg) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, metricsRequest(http.MethodGet, metricsPathDefault, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200", rec.Code) + } + types, _ := parsePrometheusText(t, rec.Body.Bytes()) + if _, ok := types["llmgateway_target_healthy"]; ok { + t.Error("want llmgateway_target_healthy's TYPE line absent when no MCP servers or agents are configured") + } + if strings.Contains(rec.Body.String(), "llmgateway_target_healthy") { + t.Errorf("body unexpectedly mentions llmgateway_target_healthy: %s", rec.Body.String()) + } +} + // TestMetrics_TargetHealthy_ReflectsRecordedState proves the gauge // renders 1 for a healthy MCP server and 0 for an unhealthy agent, with // the documented kind label values ("mcp"/"agent" — NOT the internal From aad01b8d6fcd61cce9fcdc514447ffa776e7c7f3 Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 02:47:51 +0100 Subject: [PATCH 09/15] fix(target-health): keep sweep timestamp first for atomic alignment MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit targetHealthLastSweepUnixNano moves to Gateway's first field. It is read and written only through sync/atomic's 64-bit functions, and the sync/atomic package guarantees 64-bit alignment on ARM, x86-32, and 32-bit MIPS only for a struct's first word — Traefik ships armv7 and 386 builds alongside amd64/arm64. Every other field keeps golangci-lint fieldalignment's pointer-grouped ordering; verified with the standalone fieldalignment analyzer that this is the only field out of place and adds no struct-size padding, only a documented +8 GC-scan-prefix cost. docs: catches up README's admin `health` object and Target health "State" bullet to F4 (previous commit, a0c8607) — three ways to read `state: "unknown"`, and that consecutiveFailures/lastCheck/ lastError/latencyMs/source stay present when a target has been observed but never succeeded. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- README.md | 34 ++++++++++++++++----- llmgateway.go | 83 ++++++++++++++++++++++++++++++++------------------- 2 files changed, 78 insertions(+), 39 deletions(-) diff --git a/README.md b/README.md index 6a094d0..49b826b 100644 --- a/README.md +++ b/README.md @@ -1549,9 +1549,11 @@ or in CI. `health` is `{"state","lastCheck","lastError","consecutiveFailures","latencyMs","source"}` — see [MCP and A2A](#mcp-and-a2a)'s "Target health" section for the full contract. `state` is `"unknown"`, `"healthy"`, or `"unhealthy"`, - and `consecutiveFailures` is always present; every other field is - omitted while `state` is `"unknown"` (this target has never been - observed). This route always reads existing state; when + and `consecutiveFailures` is always present. Every other field is + omitted only while this target has never once been observed; `state` + alone does not decide the omission, since `"unknown"` also covers a + target that has been observed but has not yet succeeded, and that case + keeps every field. This route always reads existing state; when `targetHealth.enabled`, it additionally triggers a background probe sweep when one is due, so the response itself never waits on that sweep. Polled every 5 seconds, in the same batch as `overview` and @@ -1921,11 +1923,27 @@ plugin's config. or the default `/.well-known/agent-card.json`); a `404` still counts as reachable — for example an umbrella agent whose root carries no card of its own. - - **State**: `"unknown"` (never observed), `"healthy"` (recorded at - least once, `consecutiveFailures` below `targetHealth.failureThreshold`), - or `"unhealthy"` (`consecutiveFailures` at or above the threshold). A - target with one or two recent failures after a success still reads - `"healthy"` until the threshold is actually crossed. + - **State**: `"healthy"` (succeeded at least once, + `consecutiveFailures` below `targetHealth.failureThreshold`), or + `"unhealthy"` (`consecutiveFailures` at or above the threshold, + whether or not the target has ever succeeded). A target with one or + two recent failures after a success still reads `"healthy"` until the + threshold is actually crossed. + - **`"unknown"` reads three ways**, all sharing one JSON `state` + value: + 1. never observed at all — no probe or passive traffic has reached + this target yet. `GET /admin/api/targets` omits every health field + but `state`/`consecutiveFailures` for this case. + 2. observed, but never once succeeded, and still below + `targetHealth.failureThreshold` — the threshold's protection + against a single transient first failure still applies, so this + does not jump straight to `"unhealthy"`, but a target this tracker + has never seen answer is not `"healthy"` either. Every other + health field is still present here, since there is a real + observation to show. + 3. either way, `llmgateway_target_healthy` emits no sample while + `state` is `"unknown"` — a gap in the series is honest, a + fabricated `1` is not. ## Security notes diff --git a/llmgateway.go b/llmgateway.go index 116678b..eceff6f 100644 --- a/llmgateway.go +++ b/llmgateway.go @@ -586,7 +586,26 @@ const maxExplicitBodyAdmissionCap = 10_000 // convention (admin.go) for the same reasoning spelled out once; this // struct is the other place it applies. type Gateway struct { - next http.Handler + // targetHealthLastSweepUnixNano MUST stay the first field (F7, + // feat/target-health review). It backs maybeSweepTargetHealth's + // single-flight gate (target_health.go) and is read/written only via + // sync/atomic's 64-bit functions (atomic.LoadInt64/StoreInt64) — the + // sync/atomic package documents that "on ARM, x86-32, and 32-bit + // MIPS, it is the caller's responsibility to arrange for 64-bit + // alignment of 64-bit words accessed atomically," and guarantees + // that alignment only for "the first word in an allocated struct, + // array, or slice." Traefik ships armv7 and 386 builds alongside + // amd64/arm64, so this is not a hypothetical: any field placed + // ahead of this one could silently misalign it on those platforms. + // Every field below is ordered by golangci-lint's fieldalignment + // linter (pointer-containing fields grouped first, for GC scan + // efficiency, then the rest) — this one field is the sole, deliberate + // exception, verified with `fieldalignment ./...` to add no + // additional padding: an 8-byte int64 transitions cleanly into the + // 8-byte-aligned pointer block that follows on every architecture + // this plugin targets. + targetHealthLastSweepUnixNano int64 + next http.Handler // redisClient is the same instance newGateway hands to both the // limiter's redisStore and the response cache (its own doc comment, // below, explains why it's built once and shared) — kept here too, @@ -617,19 +636,22 @@ type Gateway struct { adapters map[string]providerAdapter cfg *Config auth *authStore + // provenance is the in-process usage-accounting-provenance accumulator + // (feat: expose token-accounting provenance, metrics.go's + // provenanceStore) — recordUsageProvenance's only write target, and + // writeProvenanceMetrics/buildAdminProvenanceViews' (admin.go) own + // read source. Always constructed, here, by newGateway, even when + // Config.Metrics is nil or disabled, mirroring g.latency's own + // identical "always-present, usually-empty, nil-receiver-safe" + // convention immediately below — see that field's own doc comment for + // the full reasoning, which applies here unchanged. + provenance *provenanceStore // cache is nil whenever response caching is not configured or not // usable (cfg.Cache.Enabled is false, or true with no config.Redis — // see buildResponseCache, cache.go). Every call site checks for nil // before using it, rather than responseCache having its own // always-disabled zero value. cache *responseCache - // bodyAdmission is the buffered-channel semaphore acquireBodyAdmission - // (routes_unified.go) claims from and releases: security review - // finding 1b, 2026-08-22. Sized once, here, by newGateway (see - // defaultBodyAdmissionCap/Config.MaxInFlightBodyRequests) — never - // resized afterward, matching a Go channel's own fixed-capacity - // contract. - bodyAdmission chan struct{} // targetClient is the shared, connection-pooled *http.Client the // MCP/A2A target proxy (mcp_a2a.go) issues every upstream request // through — built once via newAdapterHTTPClient, the same constructor @@ -648,17 +670,14 @@ type Gateway struct { // identical "safe even off a bare &Gateway{} literal" convention // above. latency *latencyStore - // provenance is the in-process usage-accounting-provenance accumulator - // (feat: expose token-accounting provenance, metrics.go's - // provenanceStore) — recordUsageProvenance's only write target, and - // writeProvenanceMetrics/buildAdminProvenanceViews' (admin.go) own - // read source. Always constructed, here, by newGateway, even when - // Config.Metrics is nil or disabled, mirroring g.latency's own - // identical "always-present, usually-empty, nil-receiver-safe" - // convention immediately above — see that field's own doc comment for - // the full reasoning, which applies here unchanged. - provenance *provenanceStore - name string + // bodyAdmission is the buffered-channel semaphore acquireBodyAdmission + // (routes_unified.go) claims from and releases: security review + // finding 1b, 2026-08-22. Sized once, here, by newGateway (see + // defaultBodyAdmissionCap/Config.MaxInFlightBodyRequests) — never + // resized afterward, matching a Go channel's own fixed-capacity + // contract. + bodyAdmission chan struct{} + name string // failoverLogGate rate-limits runMeteredCall's generic "failing over" // log line (routes_unified.go) to once per storeErrorLogEvery // (adversarial-review fix, F10) — reuses auth.go's own logGate type, @@ -672,13 +691,13 @@ type Gateway struct { // never re-parses a CIDR string per scrape. nil when Metrics is // unconfigured or carries no AllowedCIDRs entries. metricsNets []*net.IPNet - // failover is Config.Failover, validated and resolved once by - // newGateway (validateFailoverConfig, failover.go). - failover failoverConfig // targetHealthCfg is Config.TargetHealth, validated and resolved once // by validateTargetHealthConfig (target_health.go) — maybeSweepTargetHealth // reads probeInterval/enabled from this, never the raw Config. targetHealthCfg targetHealthConfig + // failover is Config.Failover, validated and resolved once by + // newGateway (validateFailoverConfig, failover.go). + failover failoverConfig // targetTimeout is targetClient's own resolved request timeout — // Config.RequestTimeout only; an MCP/A2A target has no per-target // override the way a provider does. proxyUpstream's own callers @@ -686,15 +705,17 @@ type Gateway struct { // idle-progress body watchdog (timeout.go) matches the // ResponseHeaderTimeout already set on targetClient's Transport. targetTimeout time.Duration - // targetHealthLastSweepUnixNano/targetHealthSweeping back - // maybeSweepTargetHealth's own single-flight, at-most-one-sweep-per- - // interval gate (target_health.go): a UnixNano timestamp and a CAS - // flag, both atomic rather than mutex-guarded, since every caller - // (serveMetrics, serveAdminTargets, handleMCPServers, handleAgents) - // reaches maybeSweepTargetHealth on a live request path and must - // never block behind a lock another such call already holds. - targetHealthLastSweepUnixNano int64 - targetHealthSweeping int32 + // targetHealthSweeping is maybeSweepTargetHealth's own single-flight + // CAS flag (target_health.go) — its sibling, the UnixNano timestamp + // this same gate reads, is targetHealthLastSweepUnixNano, kept as + // this struct's FIRST field instead (see that field's own doc + // comment, top of this struct, for why). Both are atomic rather than + // mutex-guarded, since every caller (serveMetrics, serveAdminTargets, + // handleMCPServers, handleAgents) reaches maybeSweepTargetHealth on a + // live request path and must never block behind a lock another such + // call already holds. A plain int32 needs no special alignment + // treatment the way its int64 sibling does. + targetHealthSweeping int32 } // telemetryStartupOnce keeps the anonymous "plugin loaded" ping to one per From af84ed5eb7cbb0a1176ad2a1274cc09590fe70a1 Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 02:49:55 +0100 Subject: [PATCH 10/15] feat(admin): show target health in the dashboard Add a Health column to the MCP servers and A2A agents tables in TargetsView. An unhealthy target renders a destructive badge with the age of its last check and carries the failure count, source, and scrubbed last error in the title. An unknown target renders an outline badge and, when it has failed but never succeeded, the same failure details in its title. A healthy target renders muted text with its last observed latency and no badge, matching the providers' convention. Add AdminTargetHealthView to the API types with the wire contract the Go side emits, a bare formatElapsedAgo helper next to formatAgo, and column-cell tests for all three states. Regenerate the baked admin assets. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- admin_assets_gen.go | 12 +- webui/src/lib/format.spec.ts | 45 +++++++- webui/src/lib/format.ts | 39 ++++++- webui/src/lib/target-columns.spec.ts | 158 +++++++++++++++++++++++++++ webui/src/lib/target-columns.ts | 97 +++++++++++++++- webui/src/types/api.ts | 39 +++++++ 6 files changed, 373 insertions(+), 17 deletions(-) create mode 100644 webui/src/lib/target-columns.spec.ts diff --git a/admin_assets_gen.go b/admin_assets_gen.go index 5bc69f2..cd15b6e 100644 --- a/admin_assets_gen.go +++ b/admin_assets_gen.go @@ -1,6 +1,6 @@ // Code generated by webui/generate.mjs; DO NOT EDIT. // -// Source: webui/dist/ (vite build output), digest 3ff0c88830d16950. +// Source: webui/dist/ (vite build output), digest 25a21c1cf0995404. // Regenerate via `make admin-ui` after any webui/ source change. // // Every asset body below is base64-encoded and decoded once at package-var @@ -34,16 +34,16 @@ func decodeAdminAsset(encoded string) []byte { // adminIndexHTML is GET /admin's response body (admin.go's serveAdminPage) — // the built Vue app's HTML shell. var adminIndexHTML = decodeAdminAsset( - "PCFkb2N0eXBlIGh0bWw+CjxodG1sIGxhbmc9ImVuIj4KICA8aGVhZD4KICAgIDxtZXRhIGNoYXJzZXQ9IlVURi04IiAvPgogICAgPCEtLSBJbmxpbmUgZGF0YTogVVJJLCBub3QgYSBmaWxlIHVuZGVyIHB1YmxpYy86IGFkbWluLmdvJ3MgYXNzZXQgbWFwIG9ubHkKICAgICAgICAgZXZlciBob2xkcyBjb250ZW50LWhhc2hlZCBmaWxlcyB1bmRlciAvYWRtaW4vYXNzZXRzLyosIGFuZCB0aGUgYWRtaW4KICAgICAgICAgQ1NQJ3MgaW1nLXNyYyBhbGxvd3MgJ3NlbGYnIHBsdXMgZGF0YTogZm9yIGV4YWN0bHkgdGhpcyByZWFzb24g4oCUIG5vCiAgICAgICAgIGV4dHJhIHVuaGFzaGVkLWFzc2V0IHJvdXRlIGlzIG5lZWRlZCBmb3Igb25lIHNtYWxsIGljb24uIC0tPgogICAgPGxpbmsKICAgICAgcmVsPSJpY29uIgogICAgICB0eXBlPSJpbWFnZS9zdmcreG1sIgogICAgICBocmVmPSJkYXRhOmltYWdlL3N2Zyt4bWwsJTNDc3ZnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zycgdmlld0JveD0nMCAwIDI0IDI0JyUzRSUzQ3JlY3Qgd2lkdGg9JzI0JyBoZWlnaHQ9JzI0JyByeD0nNScgZmlsbD0nJTIzMDA3MmIyJy8lM0UlM0NwYXRoIGQ9J002IDE2LjUgMTAgOGwzIDYgMi0zLjUgMyA2JyBzdHJva2U9JyUyM2ZmZicgc3Ryb2tlLXdpZHRoPScyJyBmaWxsPSdub25lJyBzdHJva2UtbGluZWNhcD0ncm91bmQnIHN0cm9rZS1saW5lam9pbj0ncm91bmQnLyUzRSUzQy9zdmclM0UiCiAgICAvPgogICAgPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwgaW5pdGlhbC1zY2FsZT0xLjAiIC8+CiAgICA8dGl0bGU+TExNIEdhdGV3YXkgLSBBZG1pbjwvdGl0bGU+CiAgICA8c2NyaXB0IHR5cGU9Im1vZHVsZSIgY3Jvc3NvcmlnaW4gc3JjPSIvYWRtaW4vYXNzZXRzL2luZGV4LUQ4QjhBQ0d0LmpzIj48L3NjcmlwdD4KICAgIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgY3Jvc3NvcmlnaW4gaHJlZj0iL2FkbWluL2Fzc2V0cy9pbmRleC1DU2tJSXRyby5jc3MiPgogIDwvaGVhZD4KICA8Ym9keT4KICAgIDxkaXYgaWQ9ImFwcCI+PC9kaXY+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==", + "PCFkb2N0eXBlIGh0bWw+CjxodG1sIGxhbmc9ImVuIj4KICA8aGVhZD4KICAgIDxtZXRhIGNoYXJzZXQ9IlVURi04IiAvPgogICAgPCEtLSBJbmxpbmUgZGF0YTogVVJJLCBub3QgYSBmaWxlIHVuZGVyIHB1YmxpYy86IGFkbWluLmdvJ3MgYXNzZXQgbWFwIG9ubHkKICAgICAgICAgZXZlciBob2xkcyBjb250ZW50LWhhc2hlZCBmaWxlcyB1bmRlciAvYWRtaW4vYXNzZXRzLyosIGFuZCB0aGUgYWRtaW4KICAgICAgICAgQ1NQJ3MgaW1nLXNyYyBhbGxvd3MgJ3NlbGYnIHBsdXMgZGF0YTogZm9yIGV4YWN0bHkgdGhpcyByZWFzb24g4oCUIG5vCiAgICAgICAgIGV4dHJhIHVuaGFzaGVkLWFzc2V0IHJvdXRlIGlzIG5lZWRlZCBmb3Igb25lIHNtYWxsIGljb24uIC0tPgogICAgPGxpbmsKICAgICAgcmVsPSJpY29uIgogICAgICB0eXBlPSJpbWFnZS9zdmcreG1sIgogICAgICBocmVmPSJkYXRhOmltYWdlL3N2Zyt4bWwsJTNDc3ZnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zycgdmlld0JveD0nMCAwIDI0IDI0JyUzRSUzQ3JlY3Qgd2lkdGg9JzI0JyBoZWlnaHQ9JzI0JyByeD0nNScgZmlsbD0nJTIzMDA3MmIyJy8lM0UlM0NwYXRoIGQ9J002IDE2LjUgMTAgOGwzIDYgMi0zLjUgMyA2JyBzdHJva2U9JyUyM2ZmZicgc3Ryb2tlLXdpZHRoPScyJyBmaWxsPSdub25lJyBzdHJva2UtbGluZWNhcD0ncm91bmQnIHN0cm9rZS1saW5lam9pbj0ncm91bmQnLyUzRSUzQy9zdmclM0UiCiAgICAvPgogICAgPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwgaW5pdGlhbC1zY2FsZT0xLjAiIC8+CiAgICA8dGl0bGU+TExNIEdhdGV3YXkgLSBBZG1pbjwvdGl0bGU+CiAgICA8c2NyaXB0IHR5cGU9Im1vZHVsZSIgY3Jvc3NvcmlnaW4gc3JjPSIvYWRtaW4vYXNzZXRzL2luZGV4LUN3UF9NYk9iLmpzIj48L3NjcmlwdD4KICAgIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgY3Jvc3NvcmlnaW4gaHJlZj0iL2FkbWluL2Fzc2V0cy9pbmRleC1DU2tJSXRyby5jc3MiPgogIDwvaGVhZD4KICA8Ym9keT4KICAgIDxkaXYgaWQ9ImFwcCI+PC9kaXY+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==", ) // adminAssets maps each hashed filename under /admin/assets/ (admin.go's // serveAdminAsset) to its content. var adminAssets = map[string]adminAsset{ - "ChartsView-BVocJsry.js": { + "ChartsView--5PgKbV9.js": { contentType: "text/javascript; charset=utf-8", body: decodeAdminAsset( - "import{$ as e,A as t,At as n,B as r,Bt as i,C as a,Ct as o,D as s,Dt as c,E as l,Et as u,F as d,Ft as f,G as p,H as m,I as h,It as g,J as _,K as v,L as y,Lt as b,M as x,Mt as S,N as C,Nt as w,O as T,Ot as E,P as D,Pt as O,Q as k,R as ee,Rt as te,S as ne,St as re,T as ie,Tt as ae,U as oe,V as se,Vt as ce,W as le,X as ue,Y as de,Z as fe,_ as pe,_t as me,a as he,at as ge,b as A,c as _e,ct as ve,d as ye,dt as j,et as M,f as be,ft as xe,g as Se,gt as N,h as Ce,ht as we,i as Te,it as P,j as Ee,jt as F,k as De,kt as Oe,l as ke,lt as Ae,m as je,mt as Me,n as Ne,nt as I,o as Pe,ot as L,p as Fe,pt as Ie,q as Le,r as Re,rt as ze,s as Be,st as R,t as Ve,tt as He,u as Ue,ut as We,v as Ge,vt as z,w as Ke,wt as B,x as qe,xt as V,y as Je,yt as Ye,z as Xe,zt as Ze}from"./index-D8B8ACGt.js";function Qe(e,t=-1/0,n=1/0){return Math.min(n,Math.max(t,e))}function $e(e,t,n){let r=n.originalEvent.target,i=new CustomEvent(e,{bubbles:!1,cancelable:!0,detail:n});t&&r.addEventListener(e,t,{once:!0}),r.dispatchEvent(i)}var et=n({layersRoot:new Set,layersWithOutsidePointerEventsDisabled:new Set,originalBodyPointerEvents:void 0,branches:new Set});function tt(e){if(typeof e!=`object`||!e)return!1;let t=Object.getPrototypeOf(e);return t!==null&&t!==Object.prototype&&Object.getPrototypeOf(t)!==null||Symbol.iterator in e?!1:Symbol.toStringTag in e?Object.prototype.toString.call(e)===`[object Module]`:!0}function nt(e,t,n=`.`,r){if(!tt(t))return nt(e,{},n,r);let i={...t};for(let t of Object.keys(e)){if(t===`__proto__`||t===`constructor`)continue;let a=e[t];a!=null&&(r&&r(i,t,a,n)||(i[t]=Array.isArray(a)&&Array.isArray(i[t])?[...a,...i[t]]:tt(a)&&tt(i[t])?nt(a,i[t],(n?`${n}.`:``)+t.toString(),r):a))}return i}function rt(e){return(...t)=>t.reduce((t,n)=>nt(t,n,``,e),{})}var it=rt(),at=d(()=>{let e=F(new Map),n=F(),r=M(()=>{for(let t of e.value.values())if(t)return!0;return!1}),i=s({scrollBody:F(!0)}),a=null,o=()=>{document.body.style.paddingRight=``,document.body.style.marginRight=``,et.layersWithOutsidePointerEventsDisabled.size===0&&(document.body.style.pointerEvents=``),document.documentElement.style.removeProperty(`--scrollbar-width`),document.body.style.overflow=n.value??``,y&&a?.(),n.value=void 0};return V(r,(e,s)=>{if(!h)return;if(!e){s&&o();return}n.value===void 0&&(n.value=document.body.style.overflow);let c=window.innerWidth-document.documentElement.clientWidth,l={padding:c,margin:0},u=i.scrollBody?.value?typeof i.scrollBody.value==`object`?it({padding:i.scrollBody.value.padding===!0?c:i.scrollBody.value.padding,margin:i.scrollBody.value.margin===!0?c:i.scrollBody.value.margin},l):l:{padding:0,margin:0};c>0&&(document.body.style.paddingRight=typeof u.padding==`number`?`${u.padding}px`:String(u.padding),document.body.style.marginRight=typeof u.margin==`number`?`${u.margin}px`:String(u.margin),document.documentElement.style.setProperty(`--scrollbar-width`,`${c}px`),document.body.style.overflow=`hidden`),y&&(a=t(document,`touchmove`,e=>ct(e),{passive:!1})),xe(()=>{r.value&&(document.body.style.pointerEvents=`none`,document.body.style.overflow=`hidden`)})},{immediate:!0,flush:`sync`}),e});function ot(e){let t=Math.random().toString(36).substring(2,7),n=at();n.value.set(t,e??!1);let i=M({get:()=>n.value.get(t)??!1,set:e=>n.value.set(t,e)});return r(()=>{n.value.delete(t)}),i}function st(e){let t=window.getComputedStyle(e);if(t.overflowX===`scroll`||t.overflowY===`scroll`||t.overflowX===`auto`&&e.clientWidth<e.scrollWidth||t.overflowY===`auto`&&e.clientHeight<e.scrollHeight)return!0;{let t=e.parentNode;return!(t instanceof Element)||t.tagName===`BODY`?!1:st(t)}}function ct(e){let t=e||window.event,n=t.target;return n instanceof Element&&st(n)?!1:t.touches.length>1||(t.preventDefault&&t.cancelable&&t.preventDefault(),!1)}var lt=0;function ut(){re(e=>{if(!h)return;let t=document.querySelectorAll(`[data-reka-focus-guard]`);document.body.insertAdjacentElement(`afterbegin`,t[0]??dt()),document.body.insertAdjacentElement(`beforeend`,t[1]??dt()),lt++,e(()=>{lt===1&&document.querySelectorAll(`[data-reka-focus-guard]`).forEach(e=>e.remove()),lt--})})}function dt(){let e=document.createElement(`span`);return e.setAttribute(`data-reka-focus-guard`,``),e.tabIndex=0,e.style.outline=`none`,e.style.opacity=`0`,e.style.position=`fixed`,e.style.pointerEvents=`none`,e}function ft(e){return M(()=>!g(e)||!!De(e)?.closest(`form`))}var pt=function(e){return typeof document>`u`?null:(Array.isArray(e)?e[0]:e).ownerDocument.body},mt=new WeakMap,ht=new WeakMap,gt={},_t=0,vt=function(e){return e&&(e.host||vt(e.parentNode))},yt=function(e,t){return t.map(function(t){if(e.contains(t))return t;var n=vt(t);return n&&e.contains(n)?n:(console.error(`aria-hidden`,t,`in not contained inside`,e,`. Doing nothing`),null)}).filter(function(e){return!!e})},bt=function(e,t,n,r){var i=yt(t,Array.isArray(e)?e:[e]);gt[n]||(gt[n]=new WeakMap);var a=gt[n],o=[],s=new Set,c=new Set(i),l=function(e){!e||s.has(e)||(s.add(e),l(e.parentNode))};i.forEach(l);var u=function(e){!e||c.has(e)||Array.prototype.forEach.call(e.children,function(e){if(s.has(e))u(e);else try{var t=e.getAttribute(r),i=t!==null&&t!==`false`,c=(mt.get(e)||0)+1,l=(a.get(e)||0)+1;mt.set(e,c),a.set(e,l),o.push(e),c===1&&i&&ht.set(e,!0),l===1&&e.setAttribute(n,`true`),i||e.setAttribute(r,`true`)}catch(t){console.error(`aria-hidden: cannot operate on `,e,t)}})};return u(t),s.clear(),_t++,function(){o.forEach(function(e){var t=mt.get(e)-1,i=a.get(e)-1;mt.set(e,t),a.set(e,i),t||(ht.has(e)||e.removeAttribute(r),ht.delete(e)),i||e.removeAttribute(n)}),_t--,_t||(mt=new WeakMap,mt=new WeakMap,ht=new WeakMap,gt={})}},xt=function(e,t,n){n===void 0&&(n=`data-aria-hidden`);var r=Array.from(Array.isArray(e)?e:[e]),i=t||pt(e);return i?(r.push.apply(r,Array.from(i.querySelectorAll(`[aria-live], script`))),bt(r,i,n,`aria-hidden`)):function(){return null}};function St(e){let t;V(()=>De(e),e=>{let n=!1;try{n=!!e?.closest(`[popover]:not(:popover-open)`)}catch{}e&&!n?t=xt(e):t&&t()}),we(()=>{t&&t()})}function Ct(e){let t=F(),n=M(()=>t.value?.width??0),r=M(()=>t.value?.height??0),i;return Me(()=>{let n=De(e);n?(t.value={width:n.offsetWidth,height:n.offsetHeight},i=new ResizeObserver(e=>{if(!Array.isArray(e)||!e.length)return;let r=e[0],i,a;if(`borderBoxSize`in r){let e=r.borderBoxSize,t=Array.isArray(e)?e[0]:e;i=t.inlineSize,a=t.blockSize}else i=n.offsetWidth,a=n.offsetHeight;t.value={width:i,height:a}}),i.observe(n,{box:`border-box`})):t.value=void 0}),we(()=>{i?.disconnect(),i=void 0}),{width:n,height:r}}function wt(e){let t=Xe(``,1e3);return{search:t,handleTypeaheadSearch:(n,r)=>{if(t.value+=n,e)e(n);else{let e=m(),n=r.map(e=>({...e,textValue:e.value?.textValue??e.ref.textContent?.trim()??``})),i=n.find(t=>t.ref===e),a=Et(n.map(e=>e.textValue),t.value,i?.textValue),o=n.find(e=>e.textValue===a);return o&&o.ref.focus(),o?.ref}},resetTypeahead:()=>{t.value=``}}}function Tt(e,t){return e.map((n,r)=>e[(t+r)%e.length])}function Et(e,t,n){let r=t.length>1&&Array.from(t).every(e=>e===t[0])?t[0]:t,i=n?e.indexOf(n):-1,a=Tt(e,Math.max(i,0));r.length===1&&(a=a.filter(e=>e!==n));let o=a.find(e=>e.toLowerCase().startsWith(r.toLowerCase()));return o===n?void 0:o}var Dt=`dismissableLayer.pointerDownOutside`,Ot=`dismissableLayer.focusOutside`;function kt(e,t){if(!(t instanceof Element))return!1;let n=t.closest(`[data-dismissable-layer]`),r=e.dataset.dismissableLayer===``?e:e.querySelector(`[data-dismissable-layer]`),i=Array.from(e.ownerDocument.querySelectorAll(`[data-dismissable-layer]`));return!!(n&&(r===n||i.indexOf(r)<i.indexOf(n)))}function At(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=F(!1),a=F(()=>{});return re(o=>{if(!h||!g(n))return;let s=async n=>{let o=n.target;if(!(!t?.value||!o)){if(kt(t.value,o)){i.value=!1;return}if(n.target&&!i.value){let t={originalEvent:n};function i(){$e(Dt,e,t)}n.pointerType===`touch`?(r.removeEventListener(`click`,a.value),a.value=i,r.addEventListener(`click`,a.value,{once:!0})):i()}else r.removeEventListener(`click`,a.value);i.value=!1}},c=window.setTimeout(()=>{r.addEventListener(`pointerdown`,s)},0);o(()=>{window.clearTimeout(c),r.removeEventListener(`pointerdown`,s),r.removeEventListener(`click`,a.value)})}),{onPointerDownCapture:()=>{g(n)&&(i.value=!0)}}}function jt(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=F(!1);return re(a=>{if(!h||!g(n))return;let o=async n=>{if(!t?.value)return;await xe(),await xe();let r=n.target;!t.value||!r||kt(t.value,r)||n.target&&!i.value&&$e(Ot,e,{originalEvent:n})};r.addEventListener(`focusin`,o),a(()=>r.removeEventListener(`focusin`,o))}),{onFocusCapture:()=>{g(n)&&(i.value=!0)},onBlurCapture:()=>{g(n)&&(i.value=!1)}}}var Mt=R({__name:`DismissableLayer`,props:{disableOutsidePointerEvents:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},present:{type:Boolean,required:!1,default:!0}},emits:[`escapeKeyDown`,`pointerDownOutside`,`focusOutside`,`interactOutside`,`dismiss`],setup(e,{emit:t}){let n=e,r=t,{forwardRef:a,currentElement:o}=ie(),s=M(()=>o.value?.ownerDocument??globalThis.document),c=M(()=>et.layersRoot),l=M(()=>o.value?Array.from(c.value).indexOf(o.value):-1),u=M(()=>et.layersWithOutsidePointerEventsDisabled.size>0),d=M(()=>{let e=Array.from(c.value),[t]=[...et.layersWithOutsidePointerEventsDisabled].slice(-1),n=e.indexOf(t);return l.value>=n}),f=At(async e=>{let t=[...et.branches].some(t=>t?.contains(e.target));!n.present||!d.value||t||(r(`pointerDownOutside`,e),r(`interactOutside`,e),await xe(),e.defaultPrevented||r(`dismiss`))},o),p=jt(e=>{let t=[...et.branches].some(t=>t?.contains(e.target));!n.present||t||(r(`focusOutside`,e),r(`interactOutside`,e),e.defaultPrevented||r(`dismiss`))},o);return T(`Escape`,e=>{n.present&&l.value===c.value.size-1&&(r(`escapeKeyDown`,e),e.defaultPrevented||r(`dismiss`))}),V([o,()=>n.disableOutsidePointerEvents,()=>n.present],([e,t,n],r,i)=>{!e||!n||t&&(et.layersWithOutsidePointerEventsDisabled.size===0&&(et.originalBodyPointerEvents=s.value.body.style.pointerEvents,s.value.body.style.pointerEvents=`none`),et.layersWithOutsidePointerEventsDisabled.add(e),i(()=>{et.layersWithOutsidePointerEventsDisabled.delete(e),et.layersWithOutsidePointerEventsDisabled.size===0&&!se(et.originalBodyPointerEvents)&&(s.value.body.style.pointerEvents=et.originalBodyPointerEvents)}))},{immediate:!0}),V([o,()=>n.present],([e,t],n,r)=>{!e||!t||(c.value.add(e),r(()=>{c.value.delete(e)}))},{immediate:!0}),re(e=>{e(()=>{o.value&&(c.value.delete(o.value),et.layersWithOutsidePointerEventsDisabled.delete(o.value))})}),(e,t)=>(N(),I(b(A),{ref:b(a),"as-child":e.asChild,as:e.as,"data-dismissable-layer":``,style:i({pointerEvents:u.value?d.value?`auto`:`none`:void 0}),onFocusCapture:b(p).onFocusCapture,onBlurCapture:b(p).onBlurCapture,onPointerdownCapture:b(f).onPointerDownCapture},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`style`,`onFocusCapture`,`onBlurCapture`,`onPointerdownCapture`]))}}),Nt=D(()=>F([]));function Pt(){let e=Nt();return{add(t){let n=e.value[0];t!==n&&n?.pause(),e.value=Ft(e.value,t),e.value.unshift(t)},remove(t){e.value=Ft(e.value,t),e.value[0]?.resume()}}}function Ft(e,t){let n=[...e],r=n.indexOf(t);return r!==-1&&n.splice(r,1),n}var It=`focusScope.autoFocusOnMount`,Lt=`focusScope.autoFocusOnUnmount`,Rt={bubbles:!1,cancelable:!0};function zt(e,{select:t=!1}={}){let n=m();for(let r of e)if(Gt(r,{select:t}),m()!==n)return!0}function Bt(e){let t=Vt(e);return[Ht(t,e),Ht(t.reverse(),e)]}function Vt(e){let t=[],n=document.createTreeWalker(e,NodeFilter.SHOW_ELEMENT,{acceptNode:e=>{let t=e.tagName===`INPUT`&&e.type===`hidden`;return e.disabled||e.hidden||t?NodeFilter.FILTER_SKIP:e.tabIndex>=0?NodeFilter.FILTER_ACCEPT:NodeFilter.FILTER_SKIP}});for(;n.nextNode();)t.push(n.currentNode);return t}function Ht(e,t){for(let n of e)if(!Ut(n,{upTo:t}))return n}function Ut(e,{upTo:t}){if(getComputedStyle(e).visibility===`hidden`)return!0;for(;e;){if(t!==void 0&&e===t)return!1;if(getComputedStyle(e).display===`none`)return!0;e=e.parentElement}return!1}function Wt(e){return e instanceof HTMLInputElement&&`select`in e}function Gt(e,{select:t=!1}={}){if(e&&e.focus){let n=m();e.focus({preventScroll:!0}),e!==n&&Wt(e)&&t&&e.select()}}var Kt=R({__name:`FocusScope`,props:{loop:{type:Boolean,required:!1,default:!1},trapped:{type:Boolean,required:!1,default:!1},present:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`mountAutoFocus`,`unmountAutoFocus`],setup(e,{emit:t}){let r=e,i=t,{currentRef:a,currentElement:o}=ie(),s=F(null),c=Pt(),l=n({paused:!1,pause(){this.paused=!0},resume(){this.paused=!1}});re(e=>{if(!h)return;let t=o.value;if(!r.trapped)return;function n(e){if(l.paused||!t)return;let n=e.target;t.contains(n)?s.value=n:Gt(s.value,{select:!0})}function i(e){if(l.paused||!t)return;let n=e.relatedTarget;n!==null&&(t.contains(n)||Gt(s.value,{select:!0}))}function a(e){let n=s.value;n!==null&&e.some(e=>e.removedNodes.length>0)&&(t.contains(n)||Gt(t))}document.addEventListener(`focusin`,n),document.addEventListener(`focusout`,i);let c=new MutationObserver(a);t&&c.observe(t,{childList:!0,subtree:!0}),e(()=>{document.removeEventListener(`focusin`,n),document.removeEventListener(`focusout`,i),c.disconnect()})});function u(e,t){let n=new CustomEvent(It,Rt),r=e=>i(`mountAutoFocus`,e);e.addEventListener(It,r),e.dispatchEvent(n),e.removeEventListener(It,r),n.defaultPrevented||(zt(Vt(e),{select:!0}),m()===t&&Gt(e))}re(async e=>{let t=o.value;if(await xe(),!t)return;r.present!==!1&&c.add(l);let n=m();!t.contains(n)&&r.present!==!1&&u(t,n),e(()=>{let e=new CustomEvent(Lt,Rt),r=e=>{i(`unmountAutoFocus`,e)};t.addEventListener(Lt,r),t.dispatchEvent(e),t.setAttribute(`data-focus-scope-unmounting`,``),setTimeout(()=>{e.defaultPrevented||Gt(n??document.body,{select:!0}),t.removeEventListener(Lt,r),c.remove(l),t.removeAttribute(`data-focus-scope-unmounting`)},0)})}),V(()=>r.present,async(e,t)=>{if(!h)return;if(e===!1&&t===!0){c.remove(l);return}if(e!==!0||t!==!1)return;c.add(l),await xe();let n=o.value;if(!n)return;let r=m();n.contains(r)||u(n,r)});function d(e){if(!r.loop&&!r.trapped||l.paused)return;let t=e.key===`Tab`&&!e.altKey&&!e.ctrlKey&&!e.metaKey,n=m();if(t&&n){let t=e.currentTarget,[i,a]=Bt(t);i&&a?!e.shiftKey&&n===a?(e.preventDefault(),r.loop&&Gt(i,{select:!0})):e.shiftKey&&n===i&&(e.preventDefault(),r.loop&&Gt(a,{select:!0})):n===t&&e.preventDefault()}}return(e,t)=>(N(),I(b(A),{ref_key:`currentRef`,ref:a,tabindex:`-1`,"as-child":e.asChild,as:e.as,onKeydown:d},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as-child`,`as`]))}}),qt=[`Enter`,` `],Jt=[`ArrowDown`,`PageUp`,`Home`],Yt=[`ArrowUp`,`PageDown`,`End`];[...Jt,...Yt],[...qt],[...qt];function Xt(e){let t=m();for(let n of e)if(n===t||(n.focus(),m()!==t))return}var Zt=R({__name:`Teleport`,props:{to:{type:null,required:!1},disabled:{type:Boolean,required:!1},defer:{type:Boolean,required:!1},forceMount:{type:Boolean,required:!1}},setup(t){let n=t,r=s({}),i=M(()=>n.to??r.teleportTo?.value??`body`),a=Ee();return(t,n)=>b(a)||t.forceMount?(N(),I(e,{key:0,to:i.value,disabled:t.disabled,defer:t.defer},[z(t.$slots,`default`)],8,[`to`,`disabled`,`defer`])):ze(`v-if`,!0)}}),Qt=R({__name:`VisuallyHidden`,props:{feature:{type:String,required:!1,default:`focusable`},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(N(),I(b(A),{as:e.as,"as-child":e.asChild,"aria-hidden":e.feature===`focusable`||e.feature===`fully-hidden`?`true`:void 0,"data-hidden":e.feature===`fully-hidden`?``:void 0,tabindex:e.feature===`fully-hidden`?`-1`:void 0,style:{position:`absolute`,border:0,width:`1px`,height:`1px`,padding:0,margin:`-1px`,overflow:`hidden`,clip:`rect(0, 0, 0, 0)`,clipPath:`inset(50%)`,whiteSpace:`nowrap`,wordWrap:`normal`,top:`-1px`,left:`-1px`}},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`aria-hidden`,`data-hidden`,`tabindex`]))}}),[$t,en]=oe(`PopperRoot`),tn=R({inheritAttrs:!1,__name:`PopperRoot`,setup(e){let t=F();return en({anchor:t,onAnchorChange:e=>t.value=e}),(e,t)=>z(e.$slots,`default`)}}),nn=R({__name:`PopperAnchor`,props:{reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{forwardRef:n,currentElement:r}=ie(),i=$t();return o(()=>{i.onAnchorChange(t.reference??r.value)}),(e,t)=>(N(),I(b(A),{ref:b(n),as:e.as,"as-child":e.asChild},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as`,`as-child`]))}});function rn(e){return e!==null}function an(e){return{name:`transformOrigin`,options:e,fn(t){let{placement:n,rects:r,middlewareData:i}=t,a=i.arrow?.centerOffset!==0,o=a?0:e.arrowWidth,s=a?0:e.arrowHeight,[c,l]=on(n),u={start:e.dir===`rtl`?`100%`:`0%`,center:`50%`,end:e.dir===`rtl`?`0%`:`100%`}[l],d={start:`0%`,center:`50%`,end:`100%`}[l],f=(i.arrow?.x??0)+o/2,p=(i.arrow?.y??0)+s/2,m=``,h=``;return c===`bottom`?(m=a?u:`${f}px`,h=`${-s}px`):c===`top`?(m=a?u:`${f}px`,h=`${r.floating.height+s}px`):c===`right`?(m=`${-s}px`,h=a?d:`${p}px`):c===`left`&&(m=`${r.floating.width+s}px`,h=a?d:`${p}px`),{data:{x:m,y:h}}}}}function on(e){let[t,n=`center`]=e.split(`-`);return[t,n]}var sn=[`top`,`right`,`bottom`,`left`],cn=Math.min,ln=Math.max,un=Math.round,dn=Math.floor,fn=e=>({x:e,y:e}),pn={left:`right`,right:`left`,bottom:`top`,top:`bottom`};function mn(e,t,n){return ln(e,cn(t,n))}function hn(e,t){return typeof e==`function`?e(t):e}function gn(e){return e.split(`-`)[0]}function _n(e){return e.split(`-`)[1]}function vn(e){return e===`x`?`y`:`x`}function yn(e){return e===`y`?`height`:`width`}function bn(e){let t=e[0];return t===`t`||t===`b`?`y`:`x`}function xn(e){return vn(bn(e))}function Sn(e,t,n){n===void 0&&(n=!1);let r=_n(e),i=xn(e),a=yn(i),o=i===`x`?r===(n?`end`:`start`)?`right`:`left`:r===`start`?`bottom`:`top`;return t.reference[a]>t.floating[a]&&(o=jn(o)),[o,jn(o)]}function Cn(e){let t=jn(e);return[wn(e),t,wn(t)]}function wn(e){return e.includes(`start`)?e.replace(`start`,`end`):e.replace(`end`,`start`)}var Tn=[`left`,`right`],En=[`right`,`left`],Dn=[`top`,`bottom`],On=[`bottom`,`top`];function kn(e,t,n){switch(e){case`top`:case`bottom`:return n?t?En:Tn:t?Tn:En;case`left`:case`right`:return t?Dn:On;default:return[]}}function An(e,t,n,r){let i=_n(e),a=kn(gn(e),n===`start`,r);return i&&(a=a.map(e=>e+`-`+i),t&&(a=a.concat(a.map(wn)))),a}function jn(e){let t=gn(e);return pn[t]+e.slice(t.length)}function Mn(e){return{top:e.top??0,right:e.right??0,bottom:e.bottom??0,left:e.left??0}}function Nn(e){return typeof e==`number`?{top:e,right:e,bottom:e,left:e}:Mn(e)}function Pn(e){let{x:t,y:n,width:r,height:i}=e;return{width:r,height:i,top:n,left:t,right:t+r,bottom:n+i,x:t,y:n}}function Fn(e,t,n){let{reference:r,floating:i}=e,a=bn(t),o=xn(t),s=yn(o),c=gn(t),l=a===`y`,u=r.x+r.width/2-i.width/2,d=r.y+r.height/2-i.height/2,f=r[s]/2-i[s]/2,p;switch(c){case`top`:p={x:u,y:r.y-i.height};break;case`bottom`:p={x:u,y:r.y+r.height};break;case`right`:p={x:r.x+r.width,y:d};break;case`left`:p={x:r.x-i.width,y:d};break;default:p={x:r.x,y:r.y}}let m=_n(t);return m&&(p[o]+=f*(m===`end`?1:-1)*(n&&l?-1:1)),p}async function In(e,t){t===void 0&&(t={});let{x:n,y:r,platform:i,rects:a,elements:o,strategy:s}=e,{boundary:c=`clippingAncestors`,rootBoundary:l=`viewport`,elementContext:u=`floating`,altBoundary:d=!1,padding:f=0}=hn(t,e),p=Nn(f),m=o[d?u===`floating`?`reference`:`floating`:u],h=Pn(await i.getClippingRect({element:await(i.isElement==null?void 0:i.isElement(m))??!0?m:m.contextElement||await(i.getDocumentElement==null?void 0:i.getDocumentElement(o.floating)),boundary:c,rootBoundary:l,strategy:s})),g=u===`floating`?{x:n,y:r,width:a.floating.width,height:a.floating.height}:a.reference,_=await(i.getOffsetParent==null?void 0:i.getOffsetParent(o.floating)),v=await(i.isElement==null?void 0:i.isElement(_))&&await(i.getScale==null?void 0:i.getScale(_))||{x:1,y:1},y=Pn(i.convertOffsetParentRelativeRectToViewportRelativeRect?await i.convertOffsetParentRelativeRectToViewportRelativeRect({elements:o,rect:g,offsetParent:_,strategy:s}):g);return{top:(h.top-y.top+p.top)/v.y,bottom:(y.bottom-h.bottom+p.bottom)/v.y,left:(h.left-y.left+p.left)/v.x,right:(y.right-h.right+p.right)/v.x}}var Ln=50,Rn=async(e,t,n)=>{let{placement:r=`bottom`,strategy:i=`absolute`,middleware:a=[],platform:o}=n,s=o.detectOverflow?o:{...o,detectOverflow:In},c=await(o.isRTL==null?void 0:o.isRTL(t)),l=await o.getElementRects({reference:e,floating:t,strategy:i}),{x:u,y:d}=Fn(l,r,c),f=r,p=0,m={};for(let n=0;n<a.length;n++){let h=a[n];if(!h)continue;let{name:g,fn:_}=h,{x:v,y,data:b,reset:x}=await _({x:u,y:d,initialPlacement:r,placement:f,strategy:i,middlewareData:m,rects:l,platform:s,elements:{reference:e,floating:t}});u=v??u,d=y??d,m[g]={...m[g],...b},x&&p<Ln&&(p++,typeof x==`object`&&(x.placement&&(f=x.placement),x.rects&&(l=x.rects===!0?await o.getElementRects({reference:e,floating:t,strategy:i}):x.rects),{x:u,y:d}=Fn(l,f,c)),n=-1)}return{x:u,y:d,placement:f,strategy:i,middlewareData:m}},zn=e=>({name:`arrow`,options:e,async fn(t){let{x:n,y:r,placement:i,rects:a,platform:o,elements:s,middlewareData:c}=t,{element:l,padding:u=0}=hn(e,t)||{};if(l==null)return{};let d=Nn(u),f={x:n,y:r},p=xn(i),m=yn(p),h=await o.getDimensions(l),g=p===`y`,_=g?`top`:`left`,v=g?`bottom`:`right`,y=g?`clientHeight`:`clientWidth`,b=a.reference[m]+a.reference[p]-f[p]-a.floating[m],x=f[p]-a.reference[p],S=await(o.getOffsetParent==null?void 0:o.getOffsetParent(l)),C=S?S[y]:0;(!C||!await(o.isElement==null?void 0:o.isElement(S)))&&(C=s.floating[y]||a.floating[m]);let w=b/2-x/2,T=C/2-h[m]/2-1,E=cn(d[_],T),D=cn(d[v],T),O=C-h[m]-D,k=C/2-h[m]/2+w,ee=mn(E,k,O),te=!c.arrow&&_n(i)!=null&&k!==ee&&a.reference[m]/2-(k<E?E:D)-h[m]/2<0,ne=te?k<E?k-E:k-O:0;return{[p]:f[p]+ne,data:{[p]:ee,centerOffset:k-ee-ne,...te&&{alignmentOffset:ne}},reset:te}}}),Bn=function(e){return e===void 0&&(e={}),{name:`flip`,options:e,async fn(t){var n;let{placement:r,middlewareData:i,rects:a,initialPlacement:o,platform:s,elements:c}=t,{mainAxis:l=!0,crossAxis:u=!0,fallbackPlacements:d,fallbackStrategy:f=`bestFit`,fallbackAxisSideDirection:p=`none`,flipAlignment:m=!0,...h}=hn(e,t);if((n=i.arrow)!=null&&n.alignmentOffset)return{};let g=gn(r),_=bn(o),v=gn(o)===o,y=await(s.isRTL==null?void 0:s.isRTL(c.floating)),b=d||(v||!m?[jn(o)]:Cn(o)),x=p!==`none`;!d&&x&&b.push(...An(o,m,p,y));let S=[o,...b],C=await s.detectOverflow(t,h),w=[],T=i.flip?.overflows||[];if(l&&w.push(C[g]),u){let e=Sn(r,a,y);w.push(C[e[0]],C[e[1]])}if(T=[...T,{placement:r,overflows:w}],!w.every(e=>e<=0)){let e=(i.flip?.index||0)+1,t=S[e];if(t&&(u!==`alignment`||_===bn(t)||T.every(e=>bn(e.placement)!==_||e.overflows[0]>0)))return{data:{index:e,overflows:T},reset:{placement:t}};let n=T.filter(e=>e.overflows[0]<=0).sort((e,t)=>e.overflows[1]-t.overflows[1])[0]?.placement;if(!n)switch(f){case`bestFit`:{let e=T.filter(e=>{if(x){let t=bn(e.placement);return t===_||t===`y`}return!0}).map(e=>[e.placement,e.overflows.filter(e=>e>0).reduce((e,t)=>e+t,0)]).sort((e,t)=>e[1]-t[1])[0]?.[0];e&&(n=e);break}case`initialPlacement`:n=o}if(r!==n)return{reset:{placement:n}}}return{}}}};function Vn(e,t){return{top:e.top-t.height,right:e.right-t.width,bottom:e.bottom-t.height,left:e.left-t.width}}function Hn(e){return sn.some(t=>e[t]>=0)}var Un=function(e){return e===void 0&&(e={}),{name:`hide`,options:e,async fn(t){let{rects:n,platform:r}=t,{strategy:i=`referenceHidden`,...a}=hn(e,t);switch(i){case`referenceHidden`:{let e=Vn(await r.detectOverflow(t,{...a,elementContext:`reference`}),n.reference);return{data:{referenceHiddenOffsets:e,referenceHidden:Hn(e)}}}case`escaped`:{let e=Vn(await r.detectOverflow(t,{...a,altBoundary:!0}),n.floating);return{data:{escapedOffsets:e,escaped:Hn(e)}}}default:return{}}}}},Wn=new Set([`left`,`top`]);async function Gn(e,t){let{placement:n,platform:r,elements:i}=e,a=await(r.isRTL==null?void 0:r.isRTL(i.floating)),o=gn(n),s=_n(n),c=bn(n)===`y`,l=Wn.has(o)?-1:1,u=a&&c?-1:1,d=hn(t,e),{mainAxis:f,crossAxis:p,alignmentAxis:m}=typeof d==`number`?{mainAxis:d,crossAxis:0,alignmentAxis:null}:{mainAxis:d.mainAxis||0,crossAxis:d.crossAxis||0,alignmentAxis:d.alignmentAxis};return s&&typeof m==`number`&&(p=s===`end`?m*-1:m),c?{x:p*u,y:f*l}:{x:f*l,y:p*u}}var Kn=function(e){return e===void 0&&(e=0),{name:`offset`,options:e,async fn(t){var n;let{x:r,y:i,placement:a,middlewareData:o}=t,s=await Gn(t,e);return a===o.offset?.placement&&(n=o.arrow)!=null&&n.alignmentOffset?{}:{x:r+s.x,y:i+s.y,data:{...s,placement:a}}}}},qn=function(e){return e===void 0&&(e={}),{name:`shift`,options:e,async fn(t){let{x:n,y:r,placement:i,platform:a}=t,{mainAxis:o=!0,crossAxis:s=!1,limiter:c={fn:e=>{let{x:t,y:n}=e;return{x:t,y:n}}},...l}=hn(e,t),u={x:n,y:r},d=await a.detectOverflow(t,l),f=bn(i),p=vn(f),m=u[p],h=u[f],g=(e,t)=>mn(t+d[e===`y`?`top`:`left`],t,t-d[e===`y`?`bottom`:`right`]);o&&(m=g(p,m)),s&&(h=g(f,h));let _=c.fn({...t,[p]:m,[f]:h});return{..._,data:{x:_.x-n,y:_.y-r,enabled:{[p]:o,[f]:s}}}}}},Jn=function(e){return e===void 0&&(e={}),{options:e,fn(t){let{x:n,y:r,placement:i,rects:a,middlewareData:o}=t,{offset:s=0,mainAxis:c=!0,crossAxis:l=!0}=hn(e,t),u={x:n,y:r},d=bn(i),f=vn(d),p=u[f],m=u[d],h=hn(s,t),g=typeof h==`number`?{mainAxis:h,crossAxis:0}:{mainAxis:h.mainAxis??0,crossAxis:h.crossAxis??0};if(c){let e=f===`y`?`height`:`width`,t=a.reference[f]-a.floating[e]+g.mainAxis,n=a.reference[f]+a.reference[e]-g.mainAxis;p<t?p=t:p>n&&(p=n)}if(l){let e=f===`y`?`width`:`height`,t=Wn.has(gn(i)),n=a.reference[d]-a.floating[e]+(t&&o.offset?.[d]||0)+(t?0:g.crossAxis),r=a.reference[d]+a.reference[e]+(t?0:o.offset?.[d]||0)-(t?g.crossAxis:0);m<n?m=n:m>r&&(m=r)}return{[f]:p,[d]:m}}}},Yn=function(e){return e===void 0&&(e={}),{name:`size`,options:e,async fn(t){let{placement:n,rects:r,platform:i,elements:a}=t,{apply:o=()=>{},...s}=hn(e,t),c=await i.detectOverflow(t,s),l=gn(n),u=_n(n),d=bn(n)===`y`,{width:f,height:p}=r.floating,m,h;l===`top`||l===`bottom`?(m=l,h=u===(await(i.isRTL==null?void 0:i.isRTL(a.floating))?`start`:`end`)?`left`:`right`):(h=l,m=u===`end`?`top`:`bottom`);let g=p-c.top-c.bottom,_=f-c.left-c.right,v=cn(p-c[m],g),y=cn(f-c[h],_),b=t.middlewareData.shift,x=!b,S=v,C=y;b!=null&&b.enabled.x&&(C=_),b!=null&&b.enabled.y&&(S=g),x&&!u&&(d?C=f-2*ln(c.left,c.right):S=p-2*ln(c.top,c.bottom)),await o({...t,availableWidth:C,availableHeight:S});let w=await i.getDimensions(a.floating);return f!==w.width||p!==w.height?{reset:{rects:!0}}:{}}}};function Xn(){return typeof window<`u`}function Zn(e){return $n(e)?(e.nodeName||``).toLowerCase():`#document`}function H(e){var t;return(e==null||(t=e.ownerDocument)==null?void 0:t.defaultView)||window}function Qn(e){return(($n(e)?e.ownerDocument:e.document)||window.document)?.documentElement}function $n(e){return Xn()?e instanceof Node||e instanceof H(e).Node:!1}function er(e){return Xn()?e instanceof Element||e instanceof H(e).Element:!1}function tr(e){return Xn()?e instanceof HTMLElement||e instanceof H(e).HTMLElement:!1}function nr(e){return!Xn()||typeof ShadowRoot>`u`?!1:e instanceof ShadowRoot||e instanceof H(e).ShadowRoot}function rr(e){let{overflow:t,overflowX:n,overflowY:r,display:i}=mr(e);return/auto|scroll|overlay|hidden|clip/.test(t+r+n)&&i!==`inline`&&i!==`contents`}function ir(e){return/^(table|td|th)$/.test(Zn(e))}function ar(e){try{if(e.matches(`:popover-open`))return!0}catch{}try{return e.matches(`:modal`)}catch{return!1}}var or=/transform|translate|scale|rotate|perspective|filter/,sr=/paint|layout|strict|content/,cr=e=>!!e&&e!==`none`,lr;function ur(e){let t=er(e)?mr(e):e;return cr(t.transform)||cr(t.translate)||cr(t.scale)||cr(t.rotate)||cr(t.perspective)||!fr()&&(cr(t.backdropFilter)||cr(t.filter))||or.test(t.willChange||``)||sr.test(t.contain||``)}function dr(e){let t=gr(e);for(;tr(t)&&!pr(t);){if(ur(t))return t;if(ar(t))return null;t=gr(t)}return null}function fr(){return lr??=typeof CSS<`u`&&CSS.supports&&CSS.supports(`-webkit-backdrop-filter`,`none`),lr}function pr(e){return/^(html|body|#document)$/.test(Zn(e))}function mr(e){return H(e).getComputedStyle(e)}function hr(e){return er(e)?{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}:{scrollLeft:e.scrollX,scrollTop:e.scrollY}}function gr(e){if(Zn(e)===`html`)return e;let t=e.assignedSlot||e.parentNode||nr(e)&&e.host||Qn(e);return nr(t)?t.host:t}function _r(e){let t=gr(e);return pr(t)?(e.ownerDocument||e).body:tr(t)&&rr(t)?t:_r(t)}function vr(e,t,n){t===void 0&&(t=[]),n===void 0&&(n=!0);let r=_r(e),i=r===e.ownerDocument?.body,a=H(r);if(i){let e=yr(a);return t.concat(a,a.visualViewport||[],rr(r)?r:[],e&&n?vr(e):[])}return t.concat(r,vr(r,[],n))}function yr(e){return e.parent&&Object.getPrototypeOf(e.parent)?e.frameElement:null}function br(e){let t=mr(e),n=parseFloat(t.width)||0,r=parseFloat(t.height)||0,i=tr(e),a=i?e.offsetWidth:n,o=i?e.offsetHeight:r,s=un(n)!==a||un(r)!==o;return s&&(n=a,r=o),{width:n,height:r,$:s}}function xr(e){return er(e)?e:e.contextElement}function Sr(e){let t=xr(e);if(!tr(t))return fn(1);let n=t.getBoundingClientRect(),{width:r,height:i,$:a}=br(t),o=(a?un(n.width):n.width)/r,s=(a?un(n.height):n.height)/i;return(!o||!Number.isFinite(o))&&(o=1),(!s||!Number.isFinite(s))&&(s=1),{x:o,y:s}}var Cr=fn(0);function wr(e){let t=H(e);return!fr()||!t.visualViewport?Cr:{x:t.visualViewport.offsetLeft,y:t.visualViewport.offsetTop}}function Tr(e,t,n){return t===void 0&&(t=!1),!!n&&t&&n===H(e)}function Er(e,t,n,r){t===void 0&&(t=!1),n===void 0&&(n=!1);let i=e.getBoundingClientRect(),a=xr(e),o=fn(1);t&&(r?er(r)&&(o=Sr(r)):o=Sr(e));let s=Tr(a,n,r)?wr(a):fn(0),c=(i.left+s.x)/o.x,l=(i.top+s.y)/o.y,u=i.width/o.x,d=i.height/o.y;if(a&&r){let e=H(a),t=er(r)?H(r):r,n=e,i=yr(n);for(;i&&t!==n;){let e=Sr(i),t=i.getBoundingClientRect(),r=mr(i),a=t.left+(i.clientLeft+parseFloat(r.paddingLeft))*e.x,o=t.top+(i.clientTop+parseFloat(r.paddingTop))*e.y;c*=e.x,l*=e.y,u*=e.x,d*=e.y,c+=a,l+=o,n=H(i),i=yr(n)}}return Pn({width:u,height:d,x:c,y:l})}function Dr(e,t){let n=hr(e).scrollLeft;return t?t.left+n:Er(Qn(e)).left+n}function Or(e,t){let n=e.getBoundingClientRect();return{x:n.left+t.scrollLeft-Dr(e,n),y:n.top+t.scrollTop}}function kr(e){let{elements:t,rect:n,offsetParent:r,strategy:i}=e,a=i===`fixed`,o=Qn(r),s=t?ar(t.floating):!1;if(r===o||s&&a)return n;let c={scrollLeft:0,scrollTop:0},l=fn(1),u=fn(0),d=tr(r);if((d||!a)&&((Zn(r)!==`body`||rr(o))&&(c=hr(r)),d)){let e=Er(r);l=Sr(r),u.x=e.x+r.clientLeft,u.y=e.y+r.clientTop}let f=o&&!d&&!a?Or(o,c):fn(0);return{width:n.width*l.x,height:n.height*l.y,x:n.x*l.x-c.scrollLeft*l.x+u.x+f.x,y:n.y*l.y-c.scrollTop*l.y+u.y+f.y}}function Ar(e){return e.getClientRects?Array.from(e.getClientRects()):[]}function jr(e){let t=hr(e),n=e.ownerDocument.body,r=ln(e.scrollWidth,e.clientWidth,n.scrollWidth,n.clientWidth),i=ln(e.scrollHeight,e.clientHeight,n.scrollHeight,n.clientHeight),a=-t.scrollLeft+Dr(e),o=-t.scrollTop;return mr(n).direction===`rtl`&&(a+=ln(e.clientWidth,n.clientWidth)-r),{width:r,height:i,x:a,y:o}}var Mr=25;function Nr(e,t,n){n===void 0&&(n=`viewport`);let r=n===`layoutViewport`,i=H(e),a=Qn(e),o=i.visualViewport,s=a.clientWidth,c=a.clientHeight,l=0,u=0;if(o){let e=!fr()||t===`fixed`;r?e||(l=-o.offsetLeft,u=-o.offsetTop):(s=o.width,c=o.height,e&&(l=o.offsetLeft,u=o.offsetTop))}if(Dr(a)<=0){let e=a.ownerDocument,t=e.body,n=getComputedStyle(t),r=e.compatMode===`CSS1Compat`&&parseFloat(n.marginLeft)+parseFloat(n.marginRight)||0,i=Math.abs(a.clientWidth-t.clientWidth-r),o=getComputedStyle(a).scrollbarGutter===`stable both-edges`?i/2:i;o<=Mr&&(s-=o)}return{width:s,height:c,x:l,y:u}}function Pr(e,t){let n=Er(e,!0,t===`fixed`),r=n.top+e.clientTop,i=n.left+e.clientLeft,a=Sr(e);return{width:e.clientWidth*a.x,height:e.clientHeight*a.y,x:i*a.x,y:r*a.y}}function Fr(e,t,n){let r;if(t===`viewport`||t===`layoutViewport`)r=Nr(e,n,t);else if(t===`document`)r=jr(Qn(e));else if(er(t))r=Pr(t,n);else{let n=wr(e);r={x:t.x-n.x,y:t.y-n.y,width:t.width,height:t.height}}return Pn(r)}function Ir(e,t){let n=t.get(e);if(n)return n;let r=vr(e,[],!1).filter(e=>er(e)&&Zn(e)!==`body`),i=null,a=mr(e).position===`fixed`,o=a?gr(e):e;for(;er(o)&&!pr(o);){let e=mr(o),t=ur(o),n=i?i.position:a?`fixed`:``;!t&&(n===`fixed`||n===`absolute`&&e.position===`static`)?r=r.filter(e=>e!==o):i=e,o=gr(o)}return t.set(e,r),r}function Lr(e){let{element:t,boundary:n,rootBoundary:r,strategy:i}=e,a=[...n===`clippingAncestors`?ar(t)?[]:Ir(t,this._c):[].concat(n),r],o=Fr(t,a[0],i),s=o.top,c=o.right,l=o.bottom,u=o.left;for(let e=1;e<a.length;e++){let n=Fr(t,a[e],i);s=ln(n.top,s),c=cn(n.right,c),l=cn(n.bottom,l),u=ln(n.left,u)}return{width:c-u,height:l-s,x:u,y:s}}function Rr(e){let{width:t,height:n}=br(e);return{width:t,height:n}}function zr(e,t,n){let r=tr(t),i=Qn(t),a=n===`fixed`,o=Er(e,!0,a,t),s={scrollLeft:0,scrollTop:0},c=fn(0);if((r||!a)&&((Zn(t)!==`body`||rr(i))&&(s=hr(t)),r)){let e=Er(t,!0,a,t);c.x=e.x+t.clientLeft,c.y=e.y+t.clientTop}!r&&i&&(c.x=Dr(i));let l=i&&!r&&!a?Or(i,s):fn(0);return{x:o.left+s.scrollLeft-c.x-l.x,y:o.top+s.scrollTop-c.y-l.y,width:o.width,height:o.height}}function Br(e){return mr(e).position===`static`}function Vr(e,t){if(!tr(e)||mr(e).position===`fixed`)return null;if(t)return t(e);let n=e.offsetParent;return Qn(e)===n&&(n=n.ownerDocument.body),n}function Hr(e,t){let n=H(e);if(ar(e))return n;if(!tr(e)){let t=gr(e);for(;t&&!pr(t);){if(er(t)&&!Br(t))return t;t=gr(t)}return n}let r=Vr(e,t);for(;r&&ir(r)&&Br(r);)r=Vr(r,t);return r&&pr(r)&&Br(r)&&!ur(r)?n:r||dr(e)||n}var Ur=async function(e){let t=this.getOffsetParent||Hr,n=this.getDimensions,r=await n(e.floating);return{reference:zr(e.reference,await t(e.floating),e.strategy),floating:{x:0,y:0,width:r.width,height:r.height}}};function Wr(e){return mr(e).direction===`rtl`}var Gr={convertOffsetParentRelativeRectToViewportRelativeRect:kr,getDocumentElement:Qn,getClippingRect:Lr,getOffsetParent:Hr,getElementRects:Ur,getClientRects:Ar,getDimensions:Rr,getScale:Sr,isElement:er,isRTL:Wr};function Kr(e,t){return e.x===t.x&&e.y===t.y&&e.width===t.width&&e.height===t.height}function qr(e,t,n){let r=null,i,a=Qn(e);function o(){var e;clearTimeout(i),(e=r)==null||e.disconnect(),r=null}function s(n,c){n===void 0&&(n=!1),c===void 0&&(c=1),o();let l=e.getBoundingClientRect(),{left:u,top:d,width:f,height:p}=l;if(n||t(),!f||!p)return;let m=dn(d),h=dn(a.clientWidth-(u+f)),g=dn(a.clientHeight-(d+p)),_=dn(u),v={rootMargin:-m+`px `+-h+`px `+-g+`px `+-_+`px`,threshold:ln(0,cn(1,c))||1},y=!0;function b(t){let n=t[0].intersectionRatio;if(!Kr(l,e.getBoundingClientRect()))return s();if(n!==c){if(!y)return s();n?s(!1,n):i=setTimeout(()=>{s(!1,1e-7)},1e3)}y=!1}try{r=new IntersectionObserver(b,{...v,root:a.ownerDocument})}catch{r=new IntersectionObserver(b,v)}r.observe(e)}let c=H(e),l=()=>s(n);return c.addEventListener(`resize`,l),s(!0),()=>{c.removeEventListener(`resize`,l),o()}}function Jr(e,t,n,r){r===void 0&&(r={});let{ancestorScroll:i=!0,ancestorResize:a=!0,elementResize:o=typeof ResizeObserver==`function`,layoutShift:s=typeof IntersectionObserver==`function`,animationFrame:c=!1}=r,l=xr(e),u=i||a?[...l?vr(l):[],...t?vr(t):[]]:[];u.forEach(e=>{i&&e.addEventListener(`scroll`,n),a&&e.addEventListener(`resize`,n)});let d=l&&s?qr(l,n,a):null,f=-1,p=null;o&&(p=new ResizeObserver(e=>{let[r]=e;r&&r.target===l&&p&&t&&(p.unobserve(t),cancelAnimationFrame(f),f=requestAnimationFrame(()=>{var e;(e=p)==null||e.observe(t)})),n()}),l&&!c&&p.observe(l),t&&p.observe(t));let m,h=c?Er(e):null;c&&g();function g(){let t=Er(e);h&&!Kr(h,t)&&n(),h=t,m=requestAnimationFrame(g)}return n(),()=>{var e;u.forEach(e=>{i&&e.removeEventListener(`scroll`,n),a&&e.removeEventListener(`resize`,n)}),d?.(),(e=p)==null||e.disconnect(),p=null,c&&cancelAnimationFrame(m)}}var Yr=Kn,Xr=qn,Zr=Bn,Qr=Yn,$r=Un,ei=zn,ti=Jn,ni=(e,t,n)=>{let r=new Map,i=n??{},a={...Gr,...i.platform,_c:r};return Rn(e,t,{...i,platform:a})};function ri(e){return typeof e==`object`&&!!e&&`$el`in e}function ii(e){if(ri(e)){let t=e.$el;return $n(t)&&Zn(t)===`#comment`?null:t}return e}function ai(e){return typeof e==`function`?e():b(e)}function oi(e){return{name:`arrow`,options:e,fn(t){let n=ii(ai(e.element));return n==null?{}:ei({element:n,padding:e.padding}).fn(t)}}}function si(e){return typeof window>`u`?1:(e.ownerDocument.defaultView||window).devicePixelRatio||1}function ci(e,t){let n=si(e);return Math.round(t*n)/n}function li(e,t,n){n===void 0&&(n={});let r=n.whileElementsMounted,i=M(()=>ai(n.open)??!0),a=M(()=>ai(n.middleware)),o=M(()=>ai(n.placement)??`bottom`),s=M(()=>ai(n.strategy)??`absolute`),c=M(()=>ai(n.transform)??!0),l=M(()=>ii(e.value)),d=M(()=>ii(t.value)),f=F(0),p=F(0),m=F(s.value),h=F(o.value),g=w({}),_=F(!1),v=M(()=>{let e={position:m.value,left:`0`,top:`0`};if(!d.value)return e;let t=ci(d.value,f.value),n=ci(d.value,p.value);return c.value?{...e,transform:`translate(`+t+`px, `+n+`px)`,...si(d.value)>=1.5&&{willChange:`transform`}}:{position:m.value,left:t+`px`,top:n+`px`}}),y;function b(){if(l.value==null||d.value==null)return;let e=i.value;ni(l.value,d.value,{middleware:a.value,placement:o.value,strategy:s.value}).then(t=>{f.value=t.x,p.value=t.y,m.value=t.strategy,h.value=t.placement,g.value=t.middlewareData,_.value=e!==!1})}function x(){typeof y==`function`&&(y(),y=void 0)}function C(){if(x(),r===void 0){b();return}if(l.value!=null&&d.value!=null){y=r(l.value,d.value,b);return}}function T(){i.value||(_.value=!1)}return V([a,o,s,i],b,{flush:`sync`}),V([l,d],C,{flush:`sync`}),V(i,T,{flush:`sync`}),u()&&Oe(x),{x:S(f),y:S(p),strategy:S(m),placement:S(h),middlewareData:S(g),isPositioned:S(_),floatingStyles:v,update:b}}var ui=[`dir`],di={side:`bottom`,sideOffset:0,sideFlip:!0,align:`center`,alignOffset:0,alignFlip:!0,arrowPadding:0,hideShiftedArrow:!0,avoidCollisions:!0,collisionBoundary:()=>[],collisionPadding:0,sticky:`partial`,hideWhenDetached:!1,positionStrategy:`fixed`,updatePositionStrategy:`optimized`,prioritizePosition:!1},[fi,pi]=oe(`PopperContent`),mi=R({inheritAttrs:!1,__name:`PopperContent`,props:We({memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},{...di}),emits:[`placed`],setup(e,{emit:t}){let n=e,r=t,a=$t(),{forwardRef:s,currentElement:c}=ie(),u=l(M(()=>n.dir)),d=F(),f=F(),{width:p,height:m}=Ct(f),h=M(()=>n.side+(n.align===`center`?``:`-${n.align}`)),g=M(()=>typeof n.collisionPadding==`number`?n.collisionPadding:{top:0,right:0,bottom:0,left:0,...n.collisionPadding}),_=M(()=>Array.isArray(n.collisionBoundary)?n.collisionBoundary:[n.collisionBoundary]),v=M(()=>({padding:g.value,boundary:_.value.filter(rn),altBoundary:_.value.length>0})),y=M(()=>({mainAxis:n.sideFlip,crossAxis:n.alignFlip})),x=M(()=>[Yr({mainAxis:n.sideOffset+m.value,alignmentAxis:n.alignOffset}),n.prioritizePosition&&n.avoidCollisions&&Zr({...v.value,...y.value}),n.avoidCollisions&&Xr({mainAxis:!0,crossAxis:!!n.prioritizePosition,limiter:n.sticky===`partial`?ti():void 0,...v.value}),!n.prioritizePosition&&n.avoidCollisions&&Zr({...v.value,...y.value}),Qr({...v.value,apply:({elements:e,rects:t,availableWidth:n,availableHeight:r})=>{let{width:i,height:a}=t.reference,o=e.floating.style;o.setProperty(`--reka-popper-available-width`,`${n}px`),o.setProperty(`--reka-popper-available-height`,`${r}px`),o.setProperty(`--reka-popper-anchor-width`,`${i}px`),o.setProperty(`--reka-popper-anchor-height`,`${a}px`)}}),f.value&&oi({element:f.value,padding:n.arrowPadding}),an({arrowWidth:p.value,arrowHeight:m.value,dir:u.value}),n.hideWhenDetached&&$r({strategy:`referenceHidden`,...v.value})]),{floatingStyles:S,placement:C,isPositioned:w,middlewareData:T,update:E}=li(M(()=>n.reference??a.anchor.value),d,{strategy:n.positionStrategy,placement:h,whileElementsMounted:(...e)=>Jr(...e,{layoutShift:!n.disableUpdateOnLayoutShift,animationFrame:n.updatePositionStrategy===`always`}),middleware:x}),D=M(()=>on(C.value)[0]),O=M(()=>on(C.value)[1]);o(()=>{w.value&&r(`placed`)});let k=M(()=>{let e=T.value.arrow?.centerOffset!==0;return n.hideShiftedArrow&&e}),ee=F(``);return re(()=>{c.value&&(ee.value=window.getComputedStyle(c.value).zIndex)}),pi({placedSide:D,onArrowChange:e=>f.value=e,arrowX:M(()=>T.value.arrow?.x??0),arrowY:M(()=>T.value.arrow?.y??0),shouldHideArrow:k}),(e,t)=>(N(),P(`div`,{ref_key:`floatingRef`,ref:d,"data-reka-popper-content-wrapper":``,dir:b(u),style:i({...b(S),transform:b(w)?b(S).transform:`translate(0, -200%)`,minWidth:`max-content`,zIndex:ee.value,"--reka-popper-transform-origin":[b(T).transformOrigin?.x,b(T).transformOrigin?.y].join(` `),...b(T).hide?.referenceHidden&&{visibility:`hidden`,pointerEvents:`none`}})},[n.memoDependencies?ae([n.asChild,n.as,D.value,O.value,b(w),...Object.values(e.$attrs),...n.memoDependencies],()=>(N(),I(b(A),j({key:0,ref:b(s)},e.$attrs,{"as-child":n.asChild,as:n.as,"data-side":D.value,"data-align":O.value,style:{animation:b(w)?void 0:`none`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`style`])),t,0):(N(),I(b(A),j({key:1,ref:b(s)},e.$attrs,{"as-child":n.asChild,as:n.as,"data-side":D.value,"data-align":O.value,dir:b(u),style:{animation:b(w)?void 0:`none`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`dir`,`style`]))],12,ui))}});function hi(e){let t=s({nonce:F()});return M(()=>e?.value||t.nonce?.value)}var gi=[` `,`Enter`,`ArrowUp`,`ArrowDown`],_i=[` `,`Enter`];function vi(e,t,n){return e===void 0?!1:Array.isArray(e)?e.some(e=>yi(e,t,n)):yi(e,t,n)}function yi(e,t,n){return e===void 0||t===void 0?!1:typeof e==`string`?e===t:typeof n==`function`?n(e,t):typeof n==`string`?e?.[n]===t?.[n]:le(e,t)}function bi(e){return e==null||e===``||Array.isArray(e)&&e.length===0}var xi=[`value`],[Si,Ci]=oe(`SelectRoot`),wi=R({inheritAttrs:!1,__name:`SelectRoot`,props:{open:{type:Boolean,required:!1,default:void 0},defaultOpen:{type:Boolean,required:!1},defaultValue:{type:null,required:!1},modelValue:{type:null,required:!1,default:void 0},nullableValue:{type:String,required:!1,default:``},by:{type:[String,Function],required:!1},dir:{type:String,required:!1},multiple:{type:Boolean,required:!1},autocomplete:{type:String,required:!1},disabled:{type:Boolean,required:!1},name:{type:String,required:!1},required:{type:Boolean,required:!1}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=e,r=t,{required:i,disabled:a,multiple:o,dir:s}=f(n),c=C(n,`modelValue`,r,{defaultValue:n.defaultValue??(o.value?[]:void 0),passive:n.modelValue===void 0,deep:!0}),u=C(n,`open`,r,{defaultValue:n.defaultOpen,passive:n.open===void 0}),d=F(),p=F(),m=F({x:0,y:0}),h=M(()=>o.value&&Array.isArray(c.value)?c.value?.length===0:se(c.value));Je({isProvider:!0});let g=l(s),_=ft(d),v=F(new Set),y=M(()=>Array.from(v.value).map(e=>e.value).join(`;`));function x(e){if(o.value){let t=Array.isArray(c.value)?[...c.value]:[],r=t.findIndex(t=>yi(t,e,n.by));r===-1?t.push(e):t.splice(r,1),c.value=[...t]}else c.value=e}function S(e){return Array.from(v.value).find(t=>vi(e,t.value,n.by))}return Ci({triggerElement:d,onTriggerChange:e=>{d.value=e},valueElement:p,onValueElementChange:e=>{p.value=e},contentId:``,modelValue:c,onValueChange:x,by:n.by,open:u,multiple:o,required:i,onOpenChange:e=>{u.value=e},dir:g,triggerPointerDownPosRef:m,disabled:a,isEmptyModelValue:h,optionsSet:v,onOptionAdd:e=>{let t=S(e.value);t&&v.value.delete(t),v.value.add(e)},onOptionRemove:e=>{let t=S(e.value);t&&v.value.delete(t)}}),(e,t)=>(N(),I(b(tn),null,{default:B(()=>[z(e.$slots,`default`,{modelValue:b(c),open:b(u)}),b(_)&&e.name?(N(),I(Ti,{key:y.value,"aria-hidden":`true`,tabindex:`-1`,multiple:b(o),required:b(i),name:e.name,autocomplete:e.autocomplete,disabled:b(a),value:b(c)},{default:B(()=>[b(se)(b(c))?(N(),P(`option`,{key:0,value:e.nullableValue},null,8,xi)):ze(`v-if`,!0),(N(!0),P(k,null,me(Array.from(v.value),e=>(N(),P(`option`,j({key:e.value??``},{ref_for:!0},e),null,16))),128))]),_:1},8,[`multiple`,`required`,`name`,`autocomplete`,`disabled`,`value`])):ze(`v-if`,!0)]),_:3}))}}),Ti=R({__name:`BubbleSelect`,props:{autocomplete:{type:String,required:!1},autofocus:{type:Boolean,required:!1},disabled:{type:Boolean,required:!1},form:{type:String,required:!1},multiple:{type:Boolean,required:!1},name:{type:String,required:!1},required:{type:Boolean,required:!1},size:{type:Number,required:!1},value:{type:null,required:!1}},setup(e){let t=e,n=F(),r=Si();V(()=>t.value,(e,t)=>{let r=window.HTMLSelectElement.prototype,i=Object.getOwnPropertyDescriptor(r,`value`).set;if(e!==t&&i&&n.value){let t=new Event(`change`,{bubbles:!0});i.call(n.value,e),n.value.dispatchEvent(t)}});function i(e){r.onValueChange(e.target.value)}return(e,r)=>(N(),I(b(Qt),{"as-child":``},{default:B(()=>[He(`select`,j({ref_key:`selectElement`,ref:n},t,{onInput:i}),[z(e.$slots,`default`)],16)]),_:3}))}}),Ei=R({__name:`SelectPopperPosition`,props:{memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1,default:`start`},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1,default:10},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Ke(e);return(e,n)=>(N(),I(b(mi),j(b(t),{style:{boxSizing:`border-box`,"--reka-select-content-transform-origin":`var(--reka-popper-transform-origin)`,"--reka-select-content-available-width":`var(--reka-popper-available-width)`,"--reka-select-content-available-height":`var(--reka-popper-available-height)`,"--reka-select-trigger-width":`var(--reka-popper-anchor-width)`,"--reka-select-trigger-height":`var(--reka-popper-anchor-height)`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Di={onViewportChange:()=>{},itemTextRefCallback:()=>{},itemRefCallback:()=>{}},[Oi,ki]=oe(`SelectContent`),Ai=R({__name:`SelectContentImpl`,props:{position:{type:String,required:!1,default:`item-aligned`},bodyLock:{type:Boolean,required:!1,default:!0},memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1,default:`start`},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},disableOutsidePointerEvents:{type:Boolean,required:!1,default:!0}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=Si();ut(),ot(n.bodyLock);let{CollectionSlot:a,getItems:o}=Je(),s=F();St(s);let{search:c,handleTypeaheadSearch:l}=wt(),u=F(),d=F(),f=F(),p=F(!1),m=F(!1),h=F(!1);function g(){d.value&&s.value&&Xt([d.value,s.value])}V(p,()=>{g()});let{onOpenChange:_,triggerPointerDownPosRef:v}=i;re(e=>{if(!s.value)return;let t={x:0,y:0},n=e=>{t={x:Math.abs(Math.round(e.pageX)-(v.value?.x??0)),y:Math.abs(Math.round(e.pageY)-(v.value?.y??0))}},r=e=>{e.pointerType!==`touch`&&(t.x<=10&&t.y<=10?e.preventDefault():s.value?.contains(e.target)||_(!1),document.removeEventListener(`pointermove`,n),v.value=null)};v.value!==null&&(document.addEventListener(`pointermove`,n),document.addEventListener(`pointerup`,r,{capture:!0,once:!0})),e(()=>{document.removeEventListener(`pointermove`,n),document.removeEventListener(`pointerup`,r,{capture:!0})})});function y(e){let t=e.ctrlKey||e.altKey||e.metaKey;if(e.key===`Tab`&&e.preventDefault(),!t&&e.key.length===1&&l(e.key,o()),[`ArrowUp`,`ArrowDown`,`Home`,`End`].includes(e.key)){let t=[...o().map(e=>e.ref)];if([`ArrowUp`,`End`].includes(e.key)&&(t=t.slice().reverse()),[`ArrowUp`,`ArrowDown`].includes(e.key)){let n=e.target,r=t.indexOf(n);t=t.slice(r+1)}setTimeout(()=>Xt(t)),e.preventDefault()}}let x=M(()=>n.position===`popper`?n:{}),S=Ke(x.value);return ki({content:s,viewport:u,onViewportChange:e=>{u.value=e},itemRefCallback:(e,t,n)=>{let r=!m.value&&!n,a=vi(i.modelValue.value,t,i.by);if(i.multiple.value){if(h.value)return;(a||r)&&(d.value=e,a&&(h.value=!0))}else(a||r)&&(d.value=e);r&&(m.value=!0)},selectedItem:d,selectedItemText:f,onItemLeave:()=>{s.value?.focus()},itemTextRefCallback:(e,t,n)=>{let r=!m.value&&!n;(vi(i.modelValue.value,t,i.by)||r)&&(f.value=e)},focusSelectedItem:g,position:n.position,isPositioned:p,searchRef:c}),(e,t)=>(N(),I(b(a),null,{default:B(()=>[L(b(Kt),{"as-child":``,onMountAutoFocus:t[6]||=fe(()=>{},[`prevent`]),onUnmountAutoFocus:t[7]||=e=>{r(`closeAutoFocus`,e),!e.defaultPrevented&&(b(i).triggerElement.value?.focus({preventScroll:!0}),e.preventDefault())}},{default:B(()=>[L(b(Mt),{"as-child":``,"disable-outside-pointer-events":e.disableOutsidePointerEvents,onFocusOutside:t[2]||=fe(()=>{},[`prevent`]),onDismiss:t[3]||=e=>b(i).onOpenChange(!1),onEscapeKeyDown:t[4]||=e=>r(`escapeKeyDown`,e),onPointerDownOutside:t[5]||=e=>r(`pointerDownOutside`,e)},{default:B(()=>[(N(),I(Ye(e.position===`popper`?Ei:Ni),j({...e.$attrs,...b(S)},{id:b(i).contentId,ref:e=>{if(!e)return;let t=b(De)(e);t?.hasAttribute(`data-reka-popper-content-wrapper`)?s.value=t.firstElementChild:s.value=t},role:`listbox`,"data-state":b(i).open.value?`open`:`closed`,dir:b(i).dir.value,style:{display:`flex`,flexDirection:`column`,outline:`none`},onContextmenu:t[0]||=fe(()=>{},[`prevent`]),onPlaced:t[1]||=e=>p.value=!0,onKeydown:y}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`id`,`data-state`,`dir`,`onKeydown`]))]),_:3},8,[`disable-outside-pointer-events`])]),_:3})]),_:3}))}}),[ji,Mi]=oe(`SelectItemAlignedPosition`),Ni=R({inheritAttrs:!1,__name:`SelectItemAlignedPosition`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`placed`],setup(e,{emit:t}){let n=e,r=t,{getItems:a}=Je(),o=Si(),s=Oi(),c=F(!1),l=F(!0),u=F(),{forwardRef:d,currentElement:f}=ie(),{viewport:p,selectedItem:m,selectedItemText:h,focusSelectedItem:g}=s;function _(){if(o.triggerElement.value&&o.valueElement.value&&u.value&&f.value&&p?.value&&m?.value&&h?.value){let e=o.triggerElement.value.getBoundingClientRect(),t=f.value.getBoundingClientRect(),n=o.valueElement.value.getBoundingClientRect(),i=h.value.getBoundingClientRect();if(o.dir.value!==`rtl`){let r=i.left-t.left,a=n.left-r,o=e.left-a,s=e.width+o,c=Math.max(s,t.width),l=window.innerWidth-10,d=Qe(a,10,Math.max(10,l-c));u.value.style.minWidth=`${s}px`,u.value.style.left=`${d}px`}else{let r=t.right-i.right,a=window.innerWidth-n.right-r,o=window.innerWidth-e.right-a,s=e.width+o,c=Math.max(s,t.width),l=window.innerWidth-10,d=Qe(a,10,Math.max(10,l-c));u.value.style.minWidth=`${s}px`,u.value.style.right=`${d}px`}let s=a().map(e=>e.ref),l=window.innerHeight-20,d=p.value.scrollHeight,g=window.getComputedStyle(f.value),_=Number.parseInt(g.borderTopWidth,10),v=Number.parseInt(g.paddingTop,10),y=Number.parseInt(g.borderBottomWidth,10),b=Number.parseInt(g.paddingBottom,10),x=_+v+d+b+y,S=Math.min(m.value.offsetHeight*5,x),C=window.getComputedStyle(p.value),w=Number.parseInt(C.paddingTop,10),T=Number.parseInt(C.paddingBottom,10),E=e.top+e.height/2-10,D=l-E,O=m.value.offsetHeight/2,k=m.value.offsetTop+O,ee=_+v+k,te=x-ee;if(ee<=E){let e=m.value===s.at(-1);u.value.style.bottom=`0px`;let t=f.value.clientHeight-p.value.offsetTop-p.value.offsetHeight,n=ee+Math.max(D,O+(e?T:0)+t+y);u.value.style.height=`${n}px`}else{let e=m.value===s[0];u.value.style.top=`0px`;let t=Math.max(E,_+p.value.offsetTop+(e?w:0)+O)+te;u.value.style.height=`${t}px`,p.value.scrollTop=ee-E+p.value.offsetTop}u.value.style.margin=`10px 0`,u.value.style.minHeight=`${S}px`,u.value.style.maxHeight=`${l}px`,r(`placed`),requestAnimationFrame(()=>c.value=!0)}}let v=F(``);Me(async()=>{await xe(),_(),f.value&&(v.value=window.getComputedStyle(f.value).zIndex)});function y(e){e&&l.value===!0&&(_(),g?.(),l.value=!1)}return x(o.triggerElement,()=>{_()}),Mi({contentWrapper:u,shouldExpandOnScrollRef:c,onScrollButtonChange:y}),(e,t)=>(N(),P(`div`,{ref_key:`contentWrapperElement`,ref:u,style:i({display:`flex`,flexDirection:`column`,position:`fixed`,zIndex:v.value})},[L(b(A),j({ref:b(d),style:{boxSizing:`border-box`,maxHeight:`100%`}},{...e.$attrs,...n}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16)],4))}}),Pi=R({inheritAttrs:!1,__name:`SelectProvider`,props:{context:{type:Object,required:!0}},setup(e){return Ci(e.context),ki(Di),(e,t)=>z(e.$slots,`default`)}}),Fi={key:1},Ii=R({inheritAttrs:!1,__name:`SelectContent`,props:{forceMount:{type:Boolean,required:!1},position:{type:String,required:!1},bodyLock:{type:Boolean,required:!1},memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},disableOutsidePointerEvents:{type:Boolean,required:!1}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(t,{emit:n}){let r=t,i=a(r,n),o=Si(),s=F();Me(()=>{s.value=new DocumentFragment});let c=F(),l=M(()=>r.forceMount||o.open.value),u=F(l.value),d;function f(){d&&=(clearTimeout(d),void 0)}return V(l,(e,t,n)=>{f(),d=setTimeout(()=>{u.value=l.value,d=void 0}),n(f)}),we(f),(t,n)=>l.value||u.value||c.value?.present?(N(),I(b(qe),{key:0,ref_key:`presenceRef`,ref:c,present:l.value},{default:B(()=>[L(Ai,Ze(ve({...b(i),...t.$attrs})),{default:B(()=>[z(t.$slots,`default`)]),_:3},16)]),_:3},8,[`present`])):s.value?(N(),P(`div`,Fi,[(N(),I(e,{to:s.value},[L(Pi,{context:b(o)},{default:B(()=>[z(t.$slots,`default`)]),_:3},8,[`context`])],8,[`to`]))])):ze(`v-if`,!0)}}),Li=R({__name:`SelectIcon`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(N(),I(b(A),{"aria-hidden":`true`,as:e.as,"as-child":e.asChild},{default:B(()=>[z(e.$slots,`default`,{},()=>[t[0]||=ge(`▼`)])]),_:3},8,[`as`,`as-child`]))}}),[Ri,zi]=oe(`SelectItem`),Bi=R({__name:`SelectItem`,props:{value:{type:null,required:!0},disabled:{type:Boolean,required:!1},textValue:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`select`],setup(e,{emit:t}){let n=e,r=t,{disabled:i}=f(n),a=Si(),o=Oi(),{forwardRef:s,currentElement:c}=ie(),{CollectionItem:l}=Je(),u=M(()=>vi(a.modelValue?.value,n.value,a.by)),d=F(!1),p=F(n.textValue??``),h=ne(void 0,`reka-select-item-text`);async function g(e){e.defaultPrevented||$e(`select.select`,_,{originalEvent:e,value:n.value})}async function _(e){await xe(),r(`select`,e),!e.defaultPrevented&&(i.value||(a.onValueChange(n.value),a.multiple.value||a.onOpenChange(!1)))}async function v(e){await xe(),!e.defaultPrevented&&(i.value?o.onItemLeave?.():e.currentTarget?.focus({preventScroll:!0}))}async function y(e){await xe(),!e.defaultPrevented&&e.currentTarget===m()&&o.onItemLeave?.()}async function x(e){await xe(),!e.defaultPrevented&&(o.searchRef?.value===``||e.key!==` `)&&(_i.includes(e.key)&&g(e),e.key===` `&&e.preventDefault())}if(n.value===``)throw Error(`A <SelectItem /> must have a value prop that is not an empty string. This is because the Select value can be set to an empty string to clear the selection and show the placeholder.`);return Me(()=>{c.value&&o.itemRefCallback(c.value,n.value,n.disabled)}),zi({value:n.value,disabled:i,textId:h,isSelected:u,onItemTextChange:e=>{p.value=((p.value||e?.textContent)??``).trim()}}),(e,t)=>(N(),I(b(l),{value:{textValue:p.value}},{default:B(()=>[L(b(A),{ref:b(s),role:`option`,"aria-labelledby":b(h),"data-highlighted":d.value?``:void 0,"aria-selected":u.value,"data-state":u.value?`checked`:`unchecked`,"aria-disabled":b(i)||void 0,"data-disabled":b(i)?``:void 0,tabindex:b(i)?void 0:-1,as:e.as,"as-child":e.asChild,onFocus:t[0]||=e=>d.value=!0,onBlur:t[1]||=e=>d.value=!1,onPointerup:g,onPointerdown:t[2]||=e=>{e.currentTarget.focus({preventScroll:!0})},onTouchend:t[3]||=fe(()=>{},[`prevent`,`stop`]),onPointermove:v,onPointerleave:y,onKeydown:x},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`aria-labelledby`,`data-highlighted`,`aria-selected`,`data-state`,`aria-disabled`,`data-disabled`,`tabindex`,`as`,`as-child`])]),_:3},8,[`value`]))}}),Vi=R({__name:`SelectItemIndicator`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Ri();return(e,r)=>b(n).isSelected.value?(N(),I(b(A),j({key:0,"aria-hidden":`true`},t),{default:B(()=>[z(e.$slots,`default`)]),_:3},16)):ze(`v-if`,!0)}}),Hi=R({inheritAttrs:!1,__name:`SelectItemText`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Si(),r=Oi(),i=Ri(),{forwardRef:a,currentElement:o}=ie(),s=M(()=>({value:i.value,disabled:i.disabled.value,textContent:o.value?.textContent??i.value?.toString()??``}));return Me(()=>{o.value&&(i.onItemTextChange(o.value),r.itemTextRefCallback(o.value,i.value,i.disabled.value),n.onOptionAdd(s.value))}),we(()=>{n.onOptionRemove(s.value)}),(e,n)=>(N(),I(b(A),j({id:b(i).textId,ref:b(a)},{...t,...e.$attrs}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`id`]))}}),Ui=R({__name:`SelectPortal`,props:{to:{type:null,required:!1},disabled:{type:Boolean,required:!1},defer:{type:Boolean,required:!1},forceMount:{type:Boolean,required:!1}},setup(e){let t=e;return(e,n)=>(N(),I(b(Zt),Ze(ve(t)),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Wi=R({__name:`SelectScrollButtonImpl`,emits:[`autoScroll`],setup(e,{emit:t}){let n=t,{getItems:r}=Je(),i=Oi(),a=F(null);function o(){a.value!==null&&(window.clearInterval(a.value),a.value=null)}re(()=>{r().map(e=>e.ref).find(e=>e===m())?.scrollIntoView({block:`nearest`})});function s(){a.value===null&&(a.value=window.setInterval(()=>{n(`autoScroll`)},50))}function c(){i.onItemLeave?.(),a.value===null&&(a.value=window.setInterval(()=>{n(`autoScroll`)},50))}return Ie(()=>o()),(e,t)=>(N(),I(b(A),j({"aria-hidden":`true`,style:{flexShrink:0}},e.$parent?.$props,{onPointerdown:s,onPointermove:c,onPointerleave:t[0]||=()=>{o()}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Gi=R({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Oi(),n=t.position===`item-aligned`?ji():void 0,{forwardRef:r,currentElement:i}=ie(),a=F(!1);return re(e=>{if(t.viewport?.value&&t.isPositioned?.value){let n=t.viewport.value;function r(){let e=n.scrollHeight-n.clientHeight;a.value=Math.ceil(n.scrollTop)<e}r(),n.addEventListener(`scroll`,r),e(()=>n.removeEventListener(`scroll`,r))}}),V(i,()=>{i.value&&n?.onScrollButtonChange(i.value)}),(e,n)=>a.value?(N(),I(Wi,{key:0,ref:b(r),onAutoScroll:n[0]||=()=>{let{viewport:e,selectedItem:n}=b(t);e?.value&&n?.value&&(e.value.scrollTop=e.value.scrollTop+n.value.offsetHeight)}},{default:B(()=>[z(e.$slots,`default`)]),_:3},512)):ze(`v-if`,!0)}}),Ki=R({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Oi(),n=t.position===`item-aligned`?ji():void 0,{forwardRef:r,currentElement:i}=ie(),a=F(!1);return re(e=>{if(t.viewport?.value&&t.isPositioned?.value){let n=t.viewport.value;function r(){a.value=n.scrollTop>0}r(),n.addEventListener(`scroll`,r),e(()=>n.removeEventListener(`scroll`,r))}}),V(i,()=>{i.value&&n?.onScrollButtonChange(i.value)}),(e,n)=>a.value?(N(),I(Wi,{key:0,ref:b(r),onAutoScroll:n[0]||=()=>{let{viewport:e,selectedItem:n}=b(t);e?.value&&n?.value&&(e.value.scrollTop=e.value.scrollTop-n.value.offsetHeight)}},{default:B(()=>[z(e.$slots,`default`)]),_:3},512)):ze(`v-if`,!0)}}),qi=R({__name:`SelectTrigger`,props:{disabled:{type:Boolean,required:!1},reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e,n=Si(),{forwardRef:r,currentElement:i}=ie(),a=M(()=>n.disabled?.value||t.disabled);n.contentId||=ne(void 0,`reka-select-content`),Me(()=>{n.onTriggerChange(i.value)});let{getItems:o}=Je(),{search:s,handleTypeaheadSearch:c,resetTypeahead:l}=wt();function u(){a.value||(n.onOpenChange(!0),l())}function d(e){u(),n.triggerPointerDownPosRef.value={x:Math.round(e.pageX),y:Math.round(e.pageY)}}function f(e){return e.button===0&&e.ctrlKey===!1}let p=!1;function m(e){if(e.pointerType===`touch`)return e.preventDefault();let t=e.target;t.hasPointerCapture(e.pointerId)&&t.releasePointerCapture(e.pointerId),f(e)&&(d(e),p=!0)}function h(e){f(e)&&e.preventDefault()}function g(e){p||e.currentTarget?.focus(),p=!1}return(e,t)=>(N(),I(b(nn),{"as-child":``,reference:e.reference},{default:B(()=>[L(b(A),{ref:b(r),role:`combobox`,type:e.as===`button`?`button`:void 0,"aria-controls":b(n).contentId,"aria-expanded":b(n).open.value||!1,"aria-required":b(n).required?.value,"aria-autocomplete":`none`,disabled:a.value,dir:b(n)?.dir.value,"data-state":b(n)?.open.value?`open`:`closed`,"data-disabled":a.value?``:void 0,"data-placeholder":b(bi)(b(n).modelValue?.value)?``:void 0,"as-child":e.asChild,as:e.as,onClick:g,onPointerdown:m,onMousedown:h,onPointerup:t[0]||=fe(e=>{e.pointerType===`touch`&&d(e)},[`prevent`]),onKeydown:t[1]||=e=>{let t=b(s)!==``;!(e.ctrlKey||e.altKey||e.metaKey)&&e.key.length===1&&t&&e.key===` `||(b(c)(e.key,b(o)()),b(gi).includes(e.key)&&(u(),e.preventDefault()))}},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`type`,`aria-controls`,`aria-expanded`,`aria-required`,`disabled`,`dir`,`data-state`,`data-disabled`,`data-placeholder`,`as-child`,`as`])]),_:3},8,[`reference`]))}}),Ji=R({__name:`SelectValue`,props:{placeholder:{type:String,required:!1,default:``},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,{forwardRef:n,currentElement:r}=ie(),i=Si();Me(()=>{i.valueElement=r});let a=M(()=>{let e=[],t=Array.from(i.optionsSet.value),n=e=>t.find(t=>vi(e,t.value,i.by));return e=Array.isArray(i.modelValue.value)?i.modelValue.value.map(e=>n(e)?.textContent??``):[n(i.modelValue.value)?.textContent??``],e.filter(Boolean)}),o=M(()=>a.value.length?a.value.join(`, `):t.placeholder);return(e,r)=>(N(),I(b(A),{ref:b(n),as:e.as,"as-child":e.asChild,style:{pointerEvents:`none`},"data-placeholder":a.value.length?void 0:t.placeholder},{default:B(()=>[z(e.$slots,`default`,{selectedLabel:a.value,modelValue:b(i).modelValue.value},()=>[ge(ce(o.value),1)])]),_:3},8,[`as`,`as-child`,`data-placeholder`]))}}),Yi=R({__name:`SelectViewport`,props:{nonce:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{nonce:n}=f(t),r=hi(n),i=Oi(),a=i.position===`item-aligned`?ji():void 0,{forwardRef:o,currentElement:s}=ie();Me(()=>{i?.onViewportChange(s.value)});let c=F(0);function l(e){let t=e.currentTarget,{shouldExpandOnScrollRef:n,contentWrapper:r}=a??{};if(n?.value&&r?.value){let e=Math.abs(c.value-t.scrollTop);if(e>0){let n=window.innerHeight-20,i=Number.parseFloat(r.value.style.minHeight),a=Number.parseFloat(r.value.style.height),o=Math.max(i,a);if(o<n){let i=o+e,a=Math.min(n,i),s=i-a;r.value.style.height=`${a}px`,r.value.style.bottom===`0px`&&(t.scrollTop=s>0?s:0,r.value.style.justifyContent=`flex-end`)}}}c.value=t.scrollTop}return(e,n)=>(N(),P(k,null,[L(b(A),j({ref:b(o),"data-reka-select-viewport":``,role:`presentation`},{...e.$attrs,...t},{style:{position:`relative`,flex:1,overflow:`hidden auto`},onScroll:l}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16),L(b(A),{as:`style`,nonce:b(r)},{default:B(()=>n[0]||=[ge(` /* Hide scrollbars cross-browser and enable momentum scroll for touch devices */ [data-reka-select-viewport] { scrollbar-width:none; -ms-overflow-style: none; -webkit-overflow-scrolling: touch; } [data-reka-select-viewport]::-webkit-scrollbar { display: none; } `)]),_:1,__:[0]},8,[`nonce`])],64))}}),Xi=R({__name:`Select`,props:{open:{type:Boolean},defaultOpen:{type:Boolean},defaultValue:{},modelValue:{},nullableValue:{},by:{type:[String,Function]},dir:{},multiple:{type:Boolean},autocomplete:{},disabled:{type:Boolean},name:{},required:{type:Boolean}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=a(e,t);return(e,t)=>(N(),I(b(wi),j({"data-slot":`select`},b(n)),{default:B(t=>[z(e.$slots,`default`,Ze(ve(t)))]),_:3},16))}}),Zi=R({inheritAttrs:!1,__name:`SelectContent`,props:{forceMount:{type:Boolean},position:{default:`item-aligned`},bodyLock:{type:Boolean},memoDependencies:{},side:{},sideOffset:{},sideFlip:{type:Boolean},align:{default:`center`},alignOffset:{},alignFlip:{type:Boolean},avoidCollisions:{type:Boolean},collisionBoundary:{},collisionPadding:{},arrowPadding:{},hideShiftedArrow:{type:Boolean},sticky:{},hideWhenDetached:{type:Boolean},positionStrategy:{},updatePositionStrategy:{},disableUpdateOnLayoutShift:{type:Boolean},prioritizePosition:{type:Boolean},reference:{},dir:{},asChild:{type:Boolean},as:{},disableOutsidePointerEvents:{type:Boolean},class:{type:[Boolean,null,String,Object,Array]}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=ee(n,`class`),o=a(i,r);return(t,r)=>(N(),I(b(Ui),null,{default:B(()=>[L(b(Ii),j({"data-slot":`select-content`,"data-align-trigger":e.position===`item-aligned`},{...t.$attrs,...b(o)},{class:b(p)(`bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 min-w-36 rounded-lg shadow-md ring-1 duration-100 data-[side=inline-start]:slide-in-from-right-2 data-[side=inline-end]:slide-in-from-left-2 cn-menu-translucent relative z-50 max-h-(--reka-select-content-available-height) origin-(--reka-select-content-transform-origin) overflow-x-hidden overflow-y-auto data-[align-trigger=true]:animate-none`,e.position===`popper`&&`data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1`,n.class)}),{default:B(()=>[L(b(ta)),L(b(Yi),{"data-position":e.position,class:te(b(p)(`data-[position=popper]:h-(--reka-select-trigger-height) data-[position=popper]:w-full data-[position=popper]:min-w-(--reka-select-trigger-width)`))},{default:B(()=>[z(t.$slots,`default`)]),_:3},8,[`data-position`,`class`]),L(b(ea))]),_:3},16,[`data-align-trigger`,`class`])]),_:3}))}}),Qi={class:`pointer-events-none absolute right-2 flex size-4 items-center justify-center`},$i=R({__name:`SelectItem`,props:{value:{},disabled:{type:Boolean},textValue:{},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Bi),j({"data-slot":`select-item`},b(r),{class:b(p)(`focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*=size-])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2 relative flex w-full cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0`,t.class)}),{default:B(()=>[He(`span`,Qi,[L(b(Vi),null,{default:B(()=>[z(e.$slots,`indicator-icon`,{},()=>[L(b(ue),{icon:b(v),class:`pointer-events-none size-3.5`},null,8,[`icon`])])]),_:3})]),L(b(Hi),null,{default:B(()=>[z(e.$slots,`default`)]),_:3})]),_:3},16,[`class`]))}}),ea=R({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Gi),j({"data-slot":`select-scroll-down-button`},b(r),{class:b(p)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:B(()=>[z(e.$slots,`default`,{},()=>[L(b(ue),{icon:b(Le),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),ta=R({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Ki),j({"data-slot":`select-scroll-up-button`},b(r),{class:b(p)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:B(()=>[z(e.$slots,`default`,{},()=>[L(b(ue),{icon:b(_),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),na=R({__name:`SelectTrigger`,props:{disabled:{type:Boolean},reference:{},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e,n=ee(t,`class`,`size`),r=Ke(n);return(n,i)=>(N(),I(b(qi),j({"data-slot":`select-trigger`,"data-size":e.size},b(r),{class:b(p)(`border-input data-placeholder:text-muted-foreground dark:bg-input/30 dark:hover:bg-input/50 focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 gap-1.5 rounded-lg border bg-transparent py-2 pr-2 pl-2.5 text-sm transition-colors select-none focus-visible:ring-3 aria-invalid:ring-3 data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:gap-1.5 [&_svg:not([class*=size-])]:size-4 flex w-fit items-center justify-between whitespace-nowrap outline-none disabled:cursor-not-allowed disabled:opacity-50 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center [&_svg]:pointer-events-none [&_svg]:shrink-0`,t.class)}),{default:B(()=>[z(n.$slots,`default`),L(b(Li),{"as-child":``},{default:B(()=>[L(b(ue),{icon:b(Le),class:`text-muted-foreground size-4 pointer-events-none`},null,8,[`icon`])]),_:1})]),_:3},16,[`data-size`,`class`]))}}),ra=R({__name:`SelectValue`,props:{placeholder:{},asChild:{type:Boolean},as:{}},setup(e){let t=e;return(e,n)=>(N(),I(b(Ji),j({"data-slot":`select-value`},t),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}});function ia(e){return e+.5|0}var aa=(e,t,n)=>Math.max(Math.min(e,n),t);function oa(e){return aa(ia(e*2.55),0,255)}function sa(e){return aa(ia(e*255),0,255)}function ca(e){return aa(ia(e/2.55)/100,0,1)}function la(e){return aa(ia(e*100),0,100)}var ua={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,A:10,B:11,C:12,D:13,E:14,F:15,a:10,b:11,c:12,d:13,e:14,f:15},da=[...`0123456789ABCDEF`],fa=e=>da[e&15],pa=e=>da[(e&240)>>4]+da[e&15],ma=e=>(e&240)>>4==(e&15),ha=e=>ma(e.r)&&ma(e.g)&&ma(e.b)&&ma(e.a);function ga(e){var t=e.length,n;return e[0]===`#`&&(t===4||t===5?n={r:255&ua[e[1]]*17,g:255&ua[e[2]]*17,b:255&ua[e[3]]*17,a:t===5?ua[e[4]]*17:255}:(t===7||t===9)&&(n={r:ua[e[1]]<<4|ua[e[2]],g:ua[e[3]]<<4|ua[e[4]],b:ua[e[5]]<<4|ua[e[6]],a:t===9?ua[e[7]]<<4|ua[e[8]]:255})),n}var _a=(e,t)=>e<255?t(e):``;function va(e){var t=ha(e)?fa:pa;return e?`#`+t(e.r)+t(e.g)+t(e.b)+_a(e.a,t):void 0}var ya=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function ba(e,t,n){let r=t*Math.min(n,1-n),i=(t,i=(t+e/30)%12)=>n-r*Math.max(Math.min(i-3,9-i,1),-1);return[i(0),i(8),i(4)]}function xa(e,t,n){let r=(r,i=(r+e/60)%6)=>n-n*t*Math.max(Math.min(i,4-i,1),0);return[r(5),r(3),r(1)]}function Sa(e,t,n){let r=ba(e,1,.5),i;for(t+n>1&&(i=1/(t+n),t*=i,n*=i),i=0;i<3;i++)r[i]*=1-t-n,r[i]+=t;return r}function Ca(e,t,n,r,i){return e===i?(t-n)/r+(t<n?6:0):t===i?(n-e)/r+2:(e-t)/r+4}function wa(e){let t=e.r/255,n=e.g/255,r=e.b/255,i=Math.max(t,n,r),a=Math.min(t,n,r),o=(i+a)/2,s,c,l;return i!==a&&(l=i-a,c=o>.5?l/(2-i-a):l/(i+a),s=Ca(t,n,r,l,i),s=s*60+.5),[s|0,c||0,o]}function Ta(e,t,n,r){return(Array.isArray(t)?e(t[0],t[1],t[2]):e(t,n,r)).map(sa)}function Ea(e,t,n){return Ta(ba,e,t,n)}function Da(e,t,n){return Ta(Sa,e,t,n)}function Oa(e,t,n){return Ta(xa,e,t,n)}function ka(e){return(e%360+360)%360}function Aa(e){let t=ya.exec(e),n=255,r;if(!t)return;t[5]!==r&&(n=t[6]?oa(+t[5]):sa(+t[5]));let i=ka(+t[2]),a=t[3]/100,o=t[4]/100;return r=t[1]===`hwb`?Da(i,a,o):t[1]===`hsv`?Oa(i,a,o):Ea(i,a,o),{r:r[0],g:r[1],b:r[2],a:n}}function ja(e,t){var n=wa(e);n[0]=ka(n[0]+t),n=Ea(n),e.r=n[0],e.g=n[1],e.b=n[2]}function Ma(e){if(!e)return;let t=wa(e),n=t[0],r=la(t[1]),i=la(t[2]);return e.a<255?`hsla(${n}, ${r}%, ${i}%, ${ca(e.a)})`:`hsl(${n}, ${r}%, ${i}%)`}var Na={x:`dark`,Z:`light`,Y:`re`,X:`blu`,W:`gr`,V:`medium`,U:`slate`,A:`ee`,T:`ol`,S:`or`,B:`ra`,C:`lateg`,D:`ights`,R:`in`,Q:`turquois`,E:`hi`,P:`ro`,O:`al`,N:`le`,M:`de`,L:`yello`,F:`en`,K:`ch`,G:`arks`,H:`ea`,I:`ightg`,J:`wh`},Pa={OiceXe:`f0f8ff`,antiquewEte:`faebd7`,aqua:`ffff`,aquamarRe:`7fffd4`,azuY:`f0ffff`,beige:`f5f5dc`,bisque:`ffe4c4`,black:`0`,blanKedOmond:`ffebcd`,Xe:`ff`,XeviTet:`8a2be2`,bPwn:`a52a2a`,burlywood:`deb887`,caMtXe:`5f9ea0`,KartYuse:`7fff00`,KocTate:`d2691e`,cSO:`ff7f50`,cSnflowerXe:`6495ed`,cSnsilk:`fff8dc`,crimson:`dc143c`,cyan:`ffff`,xXe:`8b`,xcyan:`8b8b`,xgTMnPd:`b8860b`,xWay:`a9a9a9`,xgYF:`6400`,xgYy:`a9a9a9`,xkhaki:`bdb76b`,xmagFta:`8b008b`,xTivegYF:`556b2f`,xSange:`ff8c00`,xScEd:`9932cc`,xYd:`8b0000`,xsOmon:`e9967a`,xsHgYF:`8fbc8f`,xUXe:`483d8b`,xUWay:`2f4f4f`,xUgYy:`2f4f4f`,xQe:`ced1`,xviTet:`9400d3`,dAppRk:`ff1493`,dApskyXe:`bfff`,dimWay:`696969`,dimgYy:`696969`,dodgerXe:`1e90ff`,fiYbrick:`b22222`,flSOwEte:`fffaf0`,foYstWAn:`228b22`,fuKsia:`ff00ff`,gaRsbSo:`dcdcdc`,ghostwEte:`f8f8ff`,gTd:`ffd700`,gTMnPd:`daa520`,Way:`808080`,gYF:`8000`,gYFLw:`adff2f`,gYy:`808080`,honeyMw:`f0fff0`,hotpRk:`ff69b4`,RdianYd:`cd5c5c`,Rdigo:`4b0082`,ivSy:`fffff0`,khaki:`f0e68c`,lavFMr:`e6e6fa`,lavFMrXsh:`fff0f5`,lawngYF:`7cfc00`,NmoncEffon:`fffacd`,ZXe:`add8e6`,ZcSO:`f08080`,Zcyan:`e0ffff`,ZgTMnPdLw:`fafad2`,ZWay:`d3d3d3`,ZgYF:`90ee90`,ZgYy:`d3d3d3`,ZpRk:`ffb6c1`,ZsOmon:`ffa07a`,ZsHgYF:`20b2aa`,ZskyXe:`87cefa`,ZUWay:`778899`,ZUgYy:`778899`,ZstAlXe:`b0c4de`,ZLw:`ffffe0`,lime:`ff00`,limegYF:`32cd32`,lRF:`faf0e6`,magFta:`ff00ff`,maPon:`800000`,VaquamarRe:`66cdaa`,VXe:`cd`,VScEd:`ba55d3`,VpurpN:`9370db`,VsHgYF:`3cb371`,VUXe:`7b68ee`,VsprRggYF:`fa9a`,VQe:`48d1cc`,VviTetYd:`c71585`,midnightXe:`191970`,mRtcYam:`f5fffa`,mistyPse:`ffe4e1`,moccasR:`ffe4b5`,navajowEte:`ffdead`,navy:`80`,Tdlace:`fdf5e6`,Tive:`808000`,TivedBb:`6b8e23`,Sange:`ffa500`,SangeYd:`ff4500`,ScEd:`da70d6`,pOegTMnPd:`eee8aa`,pOegYF:`98fb98`,pOeQe:`afeeee`,pOeviTetYd:`db7093`,papayawEp:`ffefd5`,pHKpuff:`ffdab9`,peru:`cd853f`,pRk:`ffc0cb`,plum:`dda0dd`,powMrXe:`b0e0e6`,purpN:`800080`,YbeccapurpN:`663399`,Yd:`ff0000`,Psybrown:`bc8f8f`,PyOXe:`4169e1`,saddNbPwn:`8b4513`,sOmon:`fa8072`,sandybPwn:`f4a460`,sHgYF:`2e8b57`,sHshell:`fff5ee`,siFna:`a0522d`,silver:`c0c0c0`,skyXe:`87ceeb`,UXe:`6a5acd`,UWay:`708090`,UgYy:`708090`,snow:`fffafa`,sprRggYF:`ff7f`,stAlXe:`4682b4`,tan:`d2b48c`,teO:`8080`,tEstN:`d8bfd8`,tomato:`ff6347`,Qe:`40e0d0`,viTet:`ee82ee`,JHt:`f5deb3`,wEte:`ffffff`,wEtesmoke:`f5f5f5`,Lw:`ffff00`,LwgYF:`9acd32`};function Fa(){let e={},t=Object.keys(Pa),n=Object.keys(Na),r,i,a,o,s;for(r=0;r<t.length;r++){for(o=s=t[r],i=0;i<n.length;i++)a=n[i],s=s.replace(a,Na[a]);a=parseInt(Pa[o],16),e[s]=[a>>16&255,a>>8&255,a&255]}return e}var Ia;function La(e){Ia||(Ia=Fa(),Ia.transparent=[0,0,0,0]);let t=Ia[e.toLowerCase()];return t&&{r:t[0],g:t[1],b:t[2],a:t.length===4?t[3]:255}}var Ra=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;function za(e){let t=Ra.exec(e),n=255,r,i,a;if(t){if(t[7]!==r){let e=+t[7];n=t[8]?oa(e):aa(e*255,0,255)}return r=+t[1],i=+t[3],a=+t[5],r=255&(t[2]?oa(r):aa(r,0,255)),i=255&(t[4]?oa(i):aa(i,0,255)),a=255&(t[6]?oa(a):aa(a,0,255)),{r,g:i,b:a,a:n}}}function Ba(e){return e&&(e.a<255?`rgba(${e.r}, ${e.g}, ${e.b}, ${ca(e.a)})`:`rgb(${e.r}, ${e.g}, ${e.b})`)}var Va=e=>e<=.0031308?e*12.92:e**(1/2.4)*1.055-.055,Ha=e=>e<=.04045?e/12.92:((e+.055)/1.055)**2.4;function Ua(e,t,n){let r=Ha(ca(e.r)),i=Ha(ca(e.g)),a=Ha(ca(e.b));return{r:sa(Va(r+n*(Ha(ca(t.r))-r))),g:sa(Va(i+n*(Ha(ca(t.g))-i))),b:sa(Va(a+n*(Ha(ca(t.b))-a))),a:e.a+n*(t.a-e.a)}}function Wa(e,t,n){if(e){let r=wa(e);r[t]=Math.max(0,Math.min(r[t]+r[t]*n,t===0?360:1)),r=Ea(r),e.r=r[0],e.g=r[1],e.b=r[2]}}function Ga(e,t){return e&&Object.assign(t||{},e)}function Ka(e){var t={r:0,g:0,b:0,a:255};return Array.isArray(e)?e.length>=3&&(t={r:e[0],g:e[1],b:e[2],a:255},e.length>3&&(t.a=sa(e[3]))):(t=Ga(e,{r:0,g:0,b:0,a:1}),t.a=sa(t.a)),t}function qa(e){return e.charAt(0)===`r`?za(e):Aa(e)}var Ja=class e{constructor(t){if(t instanceof e)return t;let n=typeof t,r;n===`object`?r=Ka(t):n===`string`&&(r=ga(t)||La(t)||qa(t)),this._rgb=r,this._valid=!!r}get valid(){return this._valid}get rgb(){var e=Ga(this._rgb);return e&&(e.a=ca(e.a)),e}set rgb(e){this._rgb=Ka(e)}rgbString(){return this._valid?Ba(this._rgb):void 0}hexString(){return this._valid?va(this._rgb):void 0}hslString(){return this._valid?Ma(this._rgb):void 0}mix(e,t){if(e){let n=this.rgb,r=e.rgb,i,a=t===i?.5:t,o=2*a-1,s=n.a-r.a,c=((o*s===-1?o:(o+s)/(1+o*s))+1)/2;i=1-c,n.r=255&c*n.r+i*r.r+.5,n.g=255&c*n.g+i*r.g+.5,n.b=255&c*n.b+i*r.b+.5,n.a=a*n.a+(1-a)*r.a,this.rgb=n}return this}interpolate(e,t){return e&&(this._rgb=Ua(this._rgb,e._rgb,t)),this}clone(){return new e(this.rgb)}alpha(e){return this._rgb.a=sa(e),this}clearer(e){let t=this._rgb;return t.a*=1-e,this}greyscale(){let e=this._rgb;return e.r=e.g=e.b=ia(e.r*.3+e.g*.59+e.b*.11),this}opaquer(e){let t=this._rgb;return t.a*=1+e,this}negate(){let e=this._rgb;return e.r=255-e.r,e.g=255-e.g,e.b=255-e.b,this}lighten(e){return Wa(this._rgb,2,e),this}darken(e){return Wa(this._rgb,2,-e),this}saturate(e){return Wa(this._rgb,1,e),this}desaturate(e){return Wa(this._rgb,1,-e),this}rotate(e){return ja(this._rgb,e),this}};function Ya(){}var Xa=(()=>{let e=0;return()=>e++})();function U(e){return e==null}function W(e){if(Array.isArray&&Array.isArray(e))return!0;let t=Object.prototype.toString.call(e);return t.slice(0,7)===`[object`&&t.slice(-6)===`Array]`}function G(e){return e!==null&&Object.prototype.toString.call(e)===`[object Object]`}function K(e){return(typeof e==`number`||e instanceof Number)&&isFinite(+e)}function Za(e,t){return K(e)?e:t}function q(e,t){return e===void 0?t:e}var Qa=(e,t)=>typeof e==`string`&&e.endsWith(`%`)?parseFloat(e)/100*t:+e;function J(e,t,n){if(e&&typeof e.call==`function`)return e.apply(n,t)}function Y(e,t,n,r){let i,a,o;if(W(e)){if(a=e.length,r)for(i=a-1;i>=0;i--)t.call(n,e[i],i);else for(i=0;i<a;i++)t.call(n,e[i],i)}else if(G(e))for(o=Object.keys(e),a=o.length,i=0;i<a;i++)t.call(n,e[o[i]],o[i])}function $a(e,t){let n,r,i,a;if(!e||!t||e.length!==t.length)return!1;for(n=0,r=e.length;n<r;++n)if(i=e[n],a=t[n],i.datasetIndex!==a.datasetIndex||i.index!==a.index)return!1;return!0}function eo(e){if(W(e))return e.map(eo);if(G(e)){let t=Object.create(null),n=Object.keys(e),r=n.length,i=0;for(;i<r;++i)t[n[i]]=eo(e[n[i]]);return t}return e}function to(e){return[`__proto__`,`prototype`,`constructor`].indexOf(e)===-1}function no(e,t,n,r){if(!to(e))return;let i=t[e],a=n[e];G(i)&&G(a)?ro(i,a,r):t[e]=eo(a)}function ro(e,t,n){let r=W(t)?t:[t],i=r.length;if(!G(e))return e;n||={};let a=n.merger||no,o;for(let t=0;t<i;++t){if(o=r[t],!G(o))continue;let i=Object.keys(o);for(let t=0,r=i.length;t<r;++t)a(i[t],e,o,n)}return e}function io(e,t){return ro(e,t,{merger:ao})}function ao(e,t,n){if(!to(e))return;let r=t[e],i=n[e];G(r)&&G(i)?io(r,i):Object.prototype.hasOwnProperty.call(t,e)||(t[e]=eo(i))}var oo={"":e=>e,x:e=>e.x,y:e=>e.y};function so(e){let t=e.split(`.`),n=[],r=``;for(let e of t)r+=e,r.endsWith(`\\`)?r=r.slice(0,-1)+`.`:(n.push(r),r=``);return n}function co(e){let t=so(e);return e=>{for(let n of t){if(n===``)break;e&&=e[n]}return e}}function lo(e,t){return(oo[t]||(oo[t]=co(t)))(e)}function uo(e){return e.charAt(0).toUpperCase()+e.slice(1)}var fo=e=>e!==void 0,po=e=>typeof e==`function`,mo=(e,t)=>{if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0};function ho(e){return e.type===`mouseup`||e.type===`click`||e.type===`contextmenu`}var X=Math.PI,go=2*X;go+X;var _o=1/0,vo=X/180,yo=X/2,bo=X/4,xo=X*2/3,So=Math.log10,Co=Math.sign;function wo(e,t,n){return Math.abs(e-t)<n}function To(e){let t=Math.round(e);e=wo(e,t,e/1e3)?t:e;let n=10**Math.floor(So(e)),r=e/n;return(r<=1?1:r<=2?2:r<=5?5:10)*n}function Eo(e){let t=[],n=Math.sqrt(e),r;for(r=1;r<n;r++)e%r===0&&(t.push(r),t.push(e/r));return n===(n|0)&&t.push(n),t.sort((e,t)=>e-t).pop(),t}function Do(e){return typeof e==`symbol`||typeof e==`object`&&!!e&&!(Symbol.toPrimitive in e||`toString`in e||`valueOf`in e)}function Oo(e){return!Do(e)&&!isNaN(parseFloat(e))&&isFinite(e)}function ko(e,t){let n=Math.round(e);return n-t<=e&&n+t>=e}function Ao(e,t,n){let r,i,a;for(r=0,i=e.length;r<i;r++)a=e[r][n],isNaN(a)||(t.min=Math.min(t.min,a),t.max=Math.max(t.max,a))}function jo(e){return X/180*e}function Mo(e){return 180/X*e}function No(e){if(!K(e))return;let t=1,n=0;for(;Math.round(e*t)/t!==e;)t*=10,n++;return n}function Po(e,t){let n=t.x-e.x,r=t.y-e.y,i=Math.sqrt(n*n+r*r),a=Math.atan2(r,n);return a<-.5*X&&(a+=go),{angle:a,distance:i}}function Fo(e,t){return Math.sqrt((t.x-e.x)**2+(t.y-e.y)**2)}function Io(e){return(e%go+go)%go}function Lo(e,t,n,r){let i=Io(e),a=Io(t),o=Io(n),s=Io(a-i),c=Io(o-i),l=Io(i-a),u=Io(i-o);return i===a||i===o||r&&a===o||s>c&&l<u}function Ro(e,t,n){return Math.max(t,Math.min(n,e))}function zo(e){return Ro(e,-32768,32767)}function Bo(e,t,n,r=1e-6){return e>=Math.min(t,n)-r&&e<=Math.max(t,n)+r}function Vo(e,t,n){n||=(n=>e[n]<t);let r=e.length-1,i=0,a;for(;r-i>1;)a=i+r>>1,n(a)?i=a:r=a;return{lo:i,hi:r}}var Ho=(e,t,n,r)=>Vo(e,n,r?r=>{let i=e[r][t];return i<n||i===n&&e[r+1][t]===n}:r=>e[r][t]<n),Uo=(e,t,n)=>Vo(e,n,r=>e[r][t]>=n);function Wo(e,t,n){let r=0,i=e.length;for(;r<i&&e[r]<t;)r++;for(;i>r&&e[i-1]>n;)i--;return r>0||i<e.length?e.slice(r,i):e}var Go=[`push`,`pop`,`shift`,`splice`,`unshift`];function Ko(e,t){if(e._chartjs){e._chartjs.listeners.push(t);return}Object.defineProperty(e,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[t]}}),Go.forEach(t=>{let n=`_onData`+uo(t),r=e[t];Object.defineProperty(e,t,{configurable:!0,enumerable:!1,value(...t){let i=r.apply(this,t);return e._chartjs.listeners.forEach(e=>{typeof e[n]==`function`&&e[n](...t)}),i}})})}function qo(e,t){let n=e._chartjs;if(!n)return;let r=n.listeners,i=r.indexOf(t);i!==-1&&r.splice(i,1),!(r.length>0)&&(Go.forEach(t=>{delete e[t]}),delete e._chartjs)}function Jo(e){let t=new Set(e);return t.size===e.length?e:Array.from(t)}var Yo=function(){return typeof window>`u`?function(e){return e()}:window.requestAnimationFrame}();function Xo(e,t){let n=[],r=!1;return function(...i){n=i,r||(r=!0,Yo.call(window,()=>{r=!1,e.apply(t,n)}))}}function Zo(e,t){let n;return function(...r){return t?(clearTimeout(n),n=setTimeout(e,t,r)):e.apply(this,r),t}}var Qo=e=>e===`start`?`left`:e===`end`?`right`:`center`,$o=(e,t,n)=>e===`start`?t:e===`end`?n:(t+n)/2,es=(e,t,n,r)=>e===(r?`left`:`right`)?n:e===`center`?(t+n)/2:t,ts=e=>e===0||e===1,ns=(e,t,n)=>-(2**(10*--e)*Math.sin((e-t)*go/n)),rs=(e,t,n)=>2**(-10*e)*Math.sin((e-t)*go/n)+1,is={linear:e=>e,easeInQuad:e=>e*e,easeOutQuad:e=>-e*(e-2),easeInOutQuad:e=>(e/=.5)<1?.5*e*e:-.5*(--e*(e-2)-1),easeInCubic:e=>e*e*e,easeOutCubic:e=>--e*e*e+1,easeInOutCubic:e=>(e/=.5)<1?.5*e*e*e:.5*((e-=2)*e*e+2),easeInQuart:e=>e*e*e*e,easeOutQuart:e=>-(--e*e*e*e-1),easeInOutQuart:e=>(e/=.5)<1?.5*e*e*e*e:-.5*((e-=2)*e*e*e-2),easeInQuint:e=>e*e*e*e*e,easeOutQuint:e=>--e*e*e*e*e+1,easeInOutQuint:e=>(e/=.5)<1?.5*e*e*e*e*e:.5*((e-=2)*e*e*e*e+2),easeInSine:e=>-Math.cos(e*yo)+1,easeOutSine:e=>Math.sin(e*yo),easeInOutSine:e=>-.5*(Math.cos(X*e)-1),easeInExpo:e=>e===0?0:2**(10*(e-1)),easeOutExpo:e=>e===1?1:-(2**(-10*e))+1,easeInOutExpo:e=>ts(e)?e:e<.5?.5*2**(10*(e*2-1)):.5*(-(2**(-10*(e*2-1)))+2),easeInCirc:e=>e>=1?e:-(Math.sqrt(1-e*e)-1),easeOutCirc:e=>Math.sqrt(1- --e*e),easeInOutCirc:e=>(e/=.5)<1?-.5*(Math.sqrt(1-e*e)-1):.5*(Math.sqrt(1-(e-=2)*e)+1),easeInElastic:e=>ts(e)?e:ns(e,.075,.3),easeOutElastic:e=>ts(e)?e:rs(e,.075,.3),easeInOutElastic(e){let t=.1125,n=.45;return ts(e)?e:e<.5?.5*ns(e*2,t,n):.5+.5*rs(e*2-1,t,n)},easeInBack(e){return e*e*(2.70158*e-1.70158)},easeOutBack(e){return--e*e*(2.70158*e+1.70158)+1},easeInOutBack(e){let t=1.70158;return(e/=.5)<1?.5*(e*e*(((t*=1.525)+1)*e-t)):.5*((e-=2)*e*(((t*=1.525)+1)*e+t)+2)},easeInBounce:e=>1-is.easeOutBounce(1-e),easeOutBounce(e){let t=7.5625,n=2.75;return e<1/n?t*e*e:e<2/n?t*(e-=1.5/n)*e+.75:e<2.5/n?t*(e-=2.25/n)*e+.9375:t*(e-=2.625/n)*e+.984375},easeInOutBounce:e=>e<.5?is.easeInBounce(e*2)*.5:is.easeOutBounce(e*2-1)*.5+.5};function as(e){if(e&&typeof e==`object`){let t=e.toString();return t===`[object CanvasPattern]`||t===`[object CanvasGradient]`}return!1}function os(e){return as(e)?e:new Ja(e)}function ss(e){return as(e)?e:new Ja(e).saturate(.5).darken(.1).hexString()}var cs=[`x`,`y`,`borderWidth`,`radius`,`tension`],ls=[`color`,`borderColor`,`backgroundColor`];function us(e){e.set(`animation`,{delay:void 0,duration:1e3,easing:`easeOutQuart`,fn:void 0,from:void 0,loop:void 0,to:void 0,type:void 0}),e.describe(`animation`,{_fallback:!1,_indexable:!1,_scriptable:e=>e!==`onProgress`&&e!==`onComplete`&&e!==`fn`}),e.set(`animations`,{colors:{type:`color`,properties:ls},numbers:{type:`number`,properties:cs}}),e.describe(`animations`,{_fallback:`animation`}),e.set(`transitions`,{active:{animation:{duration:400}},resize:{animation:{duration:0}},show:{animations:{colors:{from:`transparent`},visible:{type:`boolean`,duration:0}}},hide:{animations:{colors:{to:`transparent`},visible:{type:`boolean`,easing:`linear`,fn:e=>e|0}}}})}function ds(e){e.set(`layout`,{autoPadding:!0,padding:{top:0,right:0,bottom:0,left:0}})}var fs=new Map;function ps(e,t){t||={};let n=e+JSON.stringify(t),r=fs.get(n);return r||(r=new Intl.NumberFormat(e,t),fs.set(n,r)),r}function ms(e,t,n){return ps(t,n).format(e)}var hs={values(e){return W(e)?e:``+e},numeric(e,t,n){if(e===0)return`0`;let r=this.chart.options.locale,i,a=e;if(n.length>1){let t=Math.max(Math.abs(n[0].value),Math.abs(n[n.length-1].value));(t<1e-4||t>0x38d7ea4c68000)&&(i=`scientific`),a=gs(e,n)}let o=So(Math.abs(a)),s=isNaN(o)?1:Math.max(Math.min(-1*Math.floor(o),20),0),c={notation:i,minimumFractionDigits:s,maximumFractionDigits:s};return Object.assign(c,this.options.ticks.format),ms(e,r,c)},logarithmic(e,t,n){if(e===0)return`0`;let r=n[t].significand||e/10**Math.floor(So(e));return[1,2,3,5,10,15].includes(r)||t>.8*n.length?hs.numeric.call(this,e,t,n):``}};function gs(e,t){let n=t.length>3?t[2].value-t[1].value:t[1].value-t[0].value;return Math.abs(n)>=1&&e!==Math.floor(e)&&(n=e-Math.floor(e)),n}var _s={formatters:hs};function vs(e){e.set(`scale`,{display:!0,offset:!1,reverse:!1,beginAtZero:!1,bounds:`ticks`,clip:!0,grace:0,grid:{display:!0,lineWidth:1,drawOnChartArea:!0,drawTicks:!0,tickLength:8,tickWidth:(e,t)=>t.lineWidth,tickColor:(e,t)=>t.color,offset:!1},border:{display:!0,dash:[],dashOffset:0,width:1},title:{display:!1,text:``,padding:{top:4,bottom:4}},ticks:{minRotation:0,maxRotation:50,mirror:!1,textStrokeWidth:0,textStrokeColor:``,padding:3,display:!0,autoSkip:!0,autoSkipPadding:3,labelOffset:0,callback:_s.formatters.values,minor:{},major:{},align:`center`,crossAlign:`near`,showLabelBackdrop:!1,backdropColor:`rgba(255, 255, 255, 0.75)`,backdropPadding:2}}),e.route(`scale.ticks`,`color`,``,`color`),e.route(`scale.grid`,`color`,``,`borderColor`),e.route(`scale.border`,`color`,``,`borderColor`),e.route(`scale.title`,`color`,``,`color`),e.describe(`scale`,{_fallback:!1,_scriptable:e=>!e.startsWith(`before`)&&!e.startsWith(`after`)&&e!==`callback`&&e!==`parser`,_indexable:e=>e!==`borderDash`&&e!==`tickBorderDash`&&e!==`dash`}),e.describe(`scales`,{_fallback:`scale`}),e.describe(`scale.ticks`,{_scriptable:e=>e!==`backdropPadding`&&e!==`callback`,_indexable:e=>e!==`backdropPadding`})}var ys=Object.create(null),bs=Object.create(null);function xs(e,t){if(!t)return e;let n=t.split(`.`);for(let t=0,r=n.length;t<r;++t){let r=n[t];e=e[r]||(e[r]=Object.create(null))}return e}function Ss(e,t,n){return typeof t==`string`?ro(xs(e,t),n):ro(xs(e,``),t)}var Z=new class{constructor(e,t){this.animation=void 0,this.backgroundColor=`rgba(0,0,0,0.1)`,this.borderColor=`rgba(0,0,0,0.1)`,this.color=`#666`,this.datasets={},this.devicePixelRatio=e=>e.chart.platform.getDevicePixelRatio(),this.elements={},this.events=[`mousemove`,`mouseout`,`click`,`touchstart`,`touchmove`],this.font={family:`'Helvetica Neue', 'Helvetica', 'Arial', sans-serif`,size:12,style:`normal`,lineHeight:1.2,weight:null},this.hover={},this.hoverBackgroundColor=(e,t)=>ss(t.backgroundColor),this.hoverBorderColor=(e,t)=>ss(t.borderColor),this.hoverColor=(e,t)=>ss(t.color),this.indexAxis=`x`,this.interaction={mode:`nearest`,intersect:!0,includeInvisible:!1},this.maintainAspectRatio=!0,this.onHover=null,this.onClick=null,this.parsing=!0,this.plugins={},this.responsive=!0,this.scale=void 0,this.scales={},this.showLine=!0,this.drawActiveElementsOnTop=!0,this.describe(e),this.apply(t)}set(e,t){return Ss(this,e,t)}get(e){return xs(this,e)}describe(e,t){return Ss(bs,e,t)}override(e,t){return Ss(ys,e,t)}route(e,t,n,r){let i=xs(this,e),a=xs(this,n),o=`_`+t;Object.defineProperties(i,{[o]:{value:i[t],writable:!0},[t]:{enumerable:!0,get(){let e=this[o],t=a[r];return G(e)?Object.assign({},t,e):q(e,t)},set(e){this[o]=e}}})}apply(e){e.forEach(e=>e(this))}}({_scriptable:e=>!e.startsWith(`on`),_indexable:e=>e!==`events`,hover:{_fallback:`interaction`},interaction:{_scriptable:!1,_indexable:!1}},[us,ds,vs]);function Cs(e){return!e||U(e.size)||U(e.family)?null:(e.style?e.style+` `:``)+(e.weight?e.weight+` `:``)+e.size+`px `+e.family}function ws(e,t,n,r,i){let a=t[i];return a||(a=t[i]=e.measureText(i).width,n.push(i)),a>r&&(r=a),r}function Ts(e,t,n,r){r||={};let i=r.data=r.data||{},a=r.garbageCollect=r.garbageCollect||[];r.font!==t&&(i=r.data={},a=r.garbageCollect=[],r.font=t),e.save(),e.font=t;let o=0,s=n.length,c,l,u,d,f;for(c=0;c<s;c++)if(d=n[c],d!=null&&!W(d))o=ws(e,i,a,o,d);else if(W(d))for(l=0,u=d.length;l<u;l++)f=d[l],f!=null&&!W(f)&&(o=ws(e,i,a,o,f));e.restore();let p=a.length/2;if(p>n.length){for(c=0;c<p;c++)delete i[a[c]];a.splice(0,p)}return o}function Es(e,t,n){let r=e.currentDevicePixelRatio,i=n===0?0:Math.max(n/2,.5);return Math.round((t-i)*r)/r+i}function Ds(e,t){!t&&!e||(t||=e.getContext(`2d`),t.save(),t.resetTransform(),t.clearRect(0,0,e.width,e.height),t.restore())}function Os(e,t,n,r){ks(e,t,n,r,null)}function ks(e,t,n,r,i){let a,o,s,c,l,u,d,f,p=t.pointStyle,m=t.rotation,h=t.radius,g=(m||0)*vo;if(p&&typeof p==`object`&&(a=p.toString(),a===`[object HTMLImageElement]`||a===`[object HTMLCanvasElement]`)){e.save(),e.translate(n,r),e.rotate(g),e.drawImage(p,-p.width/2,-p.height/2,p.width,p.height),e.restore();return}if(!(isNaN(h)||h<=0)){switch(e.beginPath(),p){default:i?e.ellipse(n,r,i/2,h,0,0,go):e.arc(n,r,h,0,go),e.closePath();break;case`triangle`:u=i?i/2:h,e.moveTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=xo,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=xo,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),e.closePath();break;case`rectRounded`:l=h*.516,c=h-l,o=Math.cos(g+bo)*c,d=Math.cos(g+bo)*(i?i/2-l:c),s=Math.sin(g+bo)*c,f=Math.sin(g+bo)*(i?i/2-l:c),e.arc(n-d,r-s,l,g-X,g-yo),e.arc(n+f,r-o,l,g-yo,g),e.arc(n+d,r+s,l,g,g+yo),e.arc(n-f,r+o,l,g+yo,g+X),e.closePath();break;case`rect`:if(!m){c=Math.SQRT1_2*h,u=i?i/2:c,e.rect(n-u,r-c,2*u,2*c);break}g+=bo;case`rectRot`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+f,r-o),e.lineTo(n+d,r+s),e.lineTo(n-f,r+o),e.closePath();break;case`crossRot`:g+=bo;case`cross`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o);break;case`star`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o),g+=bo,d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o);break;case`line`:o=i?i/2:Math.cos(g)*h,s=Math.sin(g)*h,e.moveTo(n-o,r-s),e.lineTo(n+o,r+s);break;case`dash`:e.moveTo(n,r),e.lineTo(n+Math.cos(g)*(i?i/2:h),r+Math.sin(g)*h);break;case!1:e.closePath()}e.fill(),t.borderWidth>0&&e.stroke()}}function As(e,t,n){return n||=.5,!t||e&&e.x>t.left-n&&e.x<t.right+n&&e.y>t.top-n&&e.y<t.bottom+n}function js(e,t){e.save(),e.beginPath(),e.rect(t.left,t.top,t.right-t.left,t.bottom-t.top),e.clip()}function Ms(e){e.restore()}function Ns(e,t){t.translation&&e.translate(t.translation[0],t.translation[1]),U(t.rotation)||e.rotate(t.rotation),t.color&&(e.fillStyle=t.color),t.textAlign&&(e.textAlign=t.textAlign),t.textBaseline&&(e.textBaseline=t.textBaseline)}function Ps(e,t,n,r,i){if(i.strikethrough||i.underline){let a=e.measureText(r),o=t-a.actualBoundingBoxLeft,s=t+a.actualBoundingBoxRight,c=n-a.actualBoundingBoxAscent,l=n+a.actualBoundingBoxDescent,u=i.strikethrough?(c+l)/2:l;e.strokeStyle=e.fillStyle,e.beginPath(),e.lineWidth=i.decorationWidth||2,e.moveTo(o,u),e.lineTo(s,u),e.stroke()}}function Fs(e,t){let n=e.fillStyle;e.fillStyle=t.color,e.fillRect(t.left,t.top,t.width,t.height),e.fillStyle=n}function Is(e,t,n,r,i,a={}){let o=W(t)?t:[t],s=a.strokeWidth>0&&a.strokeColor!==``,c,l;for(e.save(),e.font=i.string,Ns(e,a),c=0;c<o.length;++c)l=o[c],a.backdrop&&Fs(e,a.backdrop),s&&(a.strokeColor&&(e.strokeStyle=a.strokeColor),U(a.strokeWidth)||(e.lineWidth=a.strokeWidth),e.strokeText(l,n,r,a.maxWidth)),e.fillText(l,n,r,a.maxWidth),Ps(e,n,r,l,a),r+=Number(i.lineHeight);e.restore()}function Ls(e,t){let{x:n,y:r,w:i,h:a,radius:o}=t;e.arc(n+o.topLeft,r+o.topLeft,o.topLeft,1.5*X,X,!0),e.lineTo(n,r+a-o.bottomLeft),e.arc(n+o.bottomLeft,r+a-o.bottomLeft,o.bottomLeft,X,yo,!0),e.lineTo(n+i-o.bottomRight,r+a),e.arc(n+i-o.bottomRight,r+a-o.bottomRight,o.bottomRight,yo,0,!0),e.lineTo(n+i,r+o.topRight),e.arc(n+i-o.topRight,r+o.topRight,o.topRight,0,-yo,!0),e.lineTo(n+o.topLeft,r)}var Rs=/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/,zs=/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;function Bs(e,t){let n=(``+e).match(Rs);if(!n||n[1]===`normal`)return t*1.2;switch(e=+n[2],n[3]){case`px`:return e;case`%`:e/=100}return t*e}var Vs=e=>+e||0;function Hs(e,t){let n={},r=G(t),i=r?Object.keys(t):t,a=G(e)?r?n=>q(e[n],e[t[n]]):t=>e[t]:()=>e;for(let e of i)n[e]=Vs(a(e));return n}function Us(e){return Hs(e,{top:`y`,right:`x`,bottom:`y`,left:`x`})}function Ws(e){return Hs(e,[`topLeft`,`topRight`,`bottomLeft`,`bottomRight`])}function Q(e){let t=Us(e);return t.width=t.left+t.right,t.height=t.top+t.bottom,t}function $(e,t){e||={},t||=Z.font;let n=q(e.size,t.size);typeof n==`string`&&(n=parseInt(n,10));let r=q(e.style,t.style);r&&!(``+r).match(zs)&&(console.warn(`Invalid font style specified: "`+r+`"`),r=void 0);let i={family:q(e.family,t.family),lineHeight:Bs(q(e.lineHeight,t.lineHeight),n),size:n,style:r,weight:q(e.weight,t.weight),string:``};return i.string=Cs(i),i}function Gs(e,t,n,r){let i=!0,a,o,s;for(a=0,o=e.length;a<o;++a)if(s=e[a],s!==void 0&&(t!==void 0&&typeof s==`function`&&(s=s(t),i=!1),n!==void 0&&W(s)&&(s=s[n%s.length],i=!1),s!==void 0))return r&&!i&&(r.cacheable=!1),s}function Ks(e,t,n){let{min:r,max:i}=e,a=Qa(t,(i-r)/2),o=(e,t)=>n&&e===0?0:e+t;return{min:o(r,-Math.abs(a)),max:o(i,a)}}function qs(e,t){return Object.assign(Object.create(e),t)}function Js(e,t=[``],n,r,i=()=>e[0]){let a=n||e;return r===void 0&&(r=uc(`_fallback`,e)),new Proxy({[Symbol.toStringTag]:`Object`,_cacheable:!0,_scopes:e,_rootScopes:a,_fallback:r,_getTarget:i,override:n=>Js([n,...e],t,a,r)},{deleteProperty(t,n){return delete t[n],delete t._keys,delete e[0][n],!0},get(n,r){return $s(n,r,()=>lc(r,t,e,n))},getOwnPropertyDescriptor(e,t){return Reflect.getOwnPropertyDescriptor(e._scopes[0],t)},getPrototypeOf(){return Reflect.getPrototypeOf(e[0])},has(e,t){return dc(e).includes(t)},ownKeys(e){return dc(e)},set(e,t,n){let r=e._storage||=i();return e[t]=r[t]=n,delete e._keys,!0}})}function Ys(e,t,n,r){let i={_cacheable:!1,_proxy:e,_context:t,_subProxy:n,_stack:new Set,_descriptors:Xs(e,r),setContext:t=>Ys(e,t,n,r),override:i=>Ys(e.override(i),t,n,r)};return new Proxy(i,{deleteProperty(t,n){return delete t[n],delete e[n],!0},get(e,t,n){return $s(e,t,()=>ec(e,t,n))},getOwnPropertyDescriptor(t,n){return t._descriptors.allKeys?Reflect.has(e,n)?{enumerable:!0,configurable:!0}:void 0:Reflect.getOwnPropertyDescriptor(e,n)},getPrototypeOf(){return Reflect.getPrototypeOf(e)},has(t,n){return Reflect.has(e,n)},ownKeys(){return Reflect.ownKeys(e)},set(t,n,r){return e[n]=r,delete t[n],!0}})}function Xs(e,t={scriptable:!0,indexable:!0}){let{_scriptable:n=t.scriptable,_indexable:r=t.indexable,_allKeys:i=t.allKeys}=e;return{allKeys:i,scriptable:n,indexable:r,isScriptable:po(n)?n:()=>n,isIndexable:po(r)?r:()=>r}}var Zs=(e,t)=>e?e+uo(t):t,Qs=(e,t)=>G(t)&&e!==`adapters`&&(Object.getPrototypeOf(t)===null||t.constructor===Object);function $s(e,t,n){if(Object.prototype.hasOwnProperty.call(e,t)||t===`constructor`)return e[t];let r=n();return e[t]=r,r}function ec(e,t,n){let{_proxy:r,_context:i,_subProxy:a,_descriptors:o}=e,s=r[t];return po(s)&&o.isScriptable(t)&&(s=tc(t,s,e,n)),W(s)&&s.length&&(s=nc(t,s,e,o.isIndexable)),Qs(t,s)&&(s=Ys(s,i,a&&a[t],o)),s}function tc(e,t,n,r){let{_proxy:i,_context:a,_subProxy:o,_stack:s}=n;if(s.has(e))throw Error(`Recursion detected: `+Array.from(s).join(`->`)+`->`+e);s.add(e);let c=t(a,o||r);return s.delete(e),Qs(e,c)&&(c=oc(i._scopes,i,e,c)),c}function nc(e,t,n,r){let{_proxy:i,_context:a,_subProxy:o,_descriptors:s}=n;if(a.index!==void 0&&r(e))return t[a.index%t.length];if(G(t[0])){let n=t,r=i._scopes.filter(e=>e!==n);t=[];for(let c of n){let n=oc(r,i,e,c);t.push(Ys(n,a,o&&o[e],s))}}return t}function rc(e,t,n){return po(e)?e(t,n):e}var ic=(e,t)=>e===!0?t:typeof e==`string`?lo(t,e):void 0;function ac(e,t,n,r,i){for(let a of t){let t=ic(n,a);if(t){e.add(t);let a=rc(t._fallback,n,i);if(a!==void 0&&a!==n&&a!==r)return a}else if(t===!1&&r!==void 0&&n!==r)return null}return!1}function oc(e,t,n,r){let i=t._rootScopes,a=rc(t._fallback,n,r),o=[...e,...i],s=new Set;s.add(r);let c=sc(s,o,n,a||n,r);return c===null||a!==void 0&&a!==n&&(c=sc(s,o,a,c,r),c===null)?!1:Js(Array.from(s),[``],i,a,()=>cc(t,n,r))}function sc(e,t,n,r,i){for(;n;)n=ac(e,t,n,r,i);return n}function cc(e,t,n){let r=e._getTarget();t in r||(r[t]={});let i=r[t];return W(i)&&G(n)?n:i||{}}function lc(e,t,n,r){let i;for(let a of t)if(i=uc(Zs(a,e),n),i!==void 0)return Qs(e,i)?oc(n,r,e,i):i}function uc(e,t){for(let n of t){if(!n)continue;let t=n[e];if(t!==void 0)return t}}function dc(e){let t=e._keys;return t||=e._keys=fc(e._scopes),t}function fc(e){let t=new Set;for(let n of e)for(let e of Object.keys(n).filter(e=>!e.startsWith(`_`)))t.add(e);return Array.from(t)}function pc(){return typeof window<`u`&&typeof document<`u`}function mc(e){let t=e.parentNode;return t&&t.toString()===`[object ShadowRoot]`&&(t=t.host),t}function hc(e,t,n){let r;return typeof e==`string`?(r=parseInt(e,10),e.indexOf(`%`)!==-1&&(r=r/100*t.parentNode[n])):r=e,r}var gc=e=>e.ownerDocument.defaultView.getComputedStyle(e,null);function _c(e,t){return gc(e).getPropertyValue(t)}var vc=[`top`,`right`,`bottom`,`left`];function yc(e,t,n){let r={};n=n?`-`+n:``;for(let i=0;i<4;i++){let a=vc[i];r[a]=parseFloat(e[t+`-`+a+n])||0}return r.width=r.left+r.right,r.height=r.top+r.bottom,r}var bc=(e,t,n)=>(e>0||t>0)&&(!n||!n.shadowRoot);function xc(e,t){let n=e.touches,r=n&&n.length?n[0]:e,{offsetX:i,offsetY:a}=r,o=!1,s,c;if(bc(i,a,e.target))s=i,c=a;else{let e=t.getBoundingClientRect();s=r.clientX-e.left,c=r.clientY-e.top,o=!0}return{x:s,y:c,box:o}}function Sc(e,t){if(`native`in e)return e;let{canvas:n,currentDevicePixelRatio:r}=t,i=gc(n),a=i.boxSizing===`border-box`,o=yc(i,`padding`),s=yc(i,`border`,`width`),{x:c,y:l,box:u}=xc(e,n),d=o.left+(u&&s.left),f=o.top+(u&&s.top),{width:p,height:m}=t;return a&&(p-=o.width+s.width,m-=o.height+s.height),{x:Math.round((c-d)/p*n.width/r),y:Math.round((l-f)/m*n.height/r)}}function Cc(e,t,n){let r,i;if(t===void 0||n===void 0){let a=e&&mc(e);if(!a)t=e.clientWidth,n=e.clientHeight;else{let e=a.getBoundingClientRect(),o=gc(a),s=yc(o,`border`,`width`),c=yc(o,`padding`);t=e.width-c.width-s.width,n=e.height-c.height-s.height,r=hc(o.maxWidth,a,`clientWidth`),i=hc(o.maxHeight,a,`clientHeight`)}}return{width:t,height:n,maxWidth:r||_o,maxHeight:i||_o}}var wc=e=>Math.round(e*10)/10;function Tc(e,t,n,r){let i=gc(e),a=yc(i,`margin`),o=hc(i.maxWidth,e,`clientWidth`)||_o,s=hc(i.maxHeight,e,`clientHeight`)||_o,c=Cc(e,t,n),{width:l,height:u}=c;if(i.boxSizing===`content-box`){let e=yc(i,`border`,`width`),t=yc(i,`padding`);l-=t.width+e.width,u-=t.height+e.height}return l=Math.max(0,l-a.width),u=Math.max(0,r?l/r:u-a.height),l=wc(Math.min(l,o,c.maxWidth)),u=wc(Math.min(u,s,c.maxHeight)),l&&!u&&(u=wc(l/2)),(t!==void 0||n!==void 0)&&r&&c.height&&u>c.height&&(u=c.height,l=wc(Math.floor(u*r))),{width:l,height:u}}function Ec(e,t,n){let r=t||1,i=wc(e.height*r),a=wc(e.width*r);e.height=wc(e.height),e.width=wc(e.width);let o=e.canvas;return o.style&&(n||!o.style.height&&!o.style.width)&&(o.style.height=`${e.height}px`,o.style.width=`${e.width}px`),e.currentDevicePixelRatio!==r||o.height!==i||o.width!==a?(e.currentDevicePixelRatio=r,o.height=i,o.width=a,e.ctx.setTransform(r,0,0,r,0,0),!0):!1}var Dc=function(){let e=!1;try{let t={get passive(){return e=!0,!1}};pc()&&(window.addEventListener(`test`,null,t),window.removeEventListener(`test`,null,t))}catch{}return e}();function Oc(e,t){let n=_c(e,t),r=n&&n.match(/^(\d+)(\.\d+)?px$/);return r?+r[1]:void 0}var kc=function(e,t){return{x(n){return e+e+t-n},setWidth(e){t=e},textAlign(e){return e===`center`?e:e===`right`?`left`:`right`},xPlus(e,t){return e-t},leftForLtr(e,t){return e-t}}},Ac=function(){return{x(e){return e},setWidth(e){},textAlign(e){return e},xPlus(e,t){return e+t},leftForLtr(e,t){return e}}};function jc(e,t,n){return e?kc(t,n):Ac()}function Mc(e,t){let n,r;(t===`ltr`||t===`rtl`)&&(n=e.canvas.style,r=[n.getPropertyValue(`direction`),n.getPropertyPriority(`direction`)],n.setProperty(`direction`,t,`important`),e.prevTextDirection=r)}function Nc(e,t){t!==void 0&&(delete e.prevTextDirection,e.canvas.style.setProperty(`direction`,t[0],t[1]))}function Pc(e,t,n){return e.options.clip?e[n]:t[n]}function Fc(e,t){let{xScale:n,yScale:r}=e;return n&&r?{left:Pc(n,t,`left`),right:Pc(n,t,`right`),top:Pc(r,t,`top`),bottom:Pc(r,t,`bottom`)}:t}function Ic(e,t){let n=t._clip;if(n.disabled)return!1;let r=Fc(t,e.chartArea);return{left:n.left===!1?0:r.left-(n.left===!0?0:n.left),right:n.right===!1?e.width:r.right+(n.right===!0?0:n.right),top:n.top===!1?0:r.top-(n.top===!0?0:n.top),bottom:n.bottom===!1?e.height:r.bottom+(n.bottom===!0?0:n.bottom)}}var Lc=new class{constructor(){this._request=null,this._charts=new Map,this._running=!1,this._lastDate=void 0}_notify(e,t,n,r){let i=t.listeners[r],a=t.duration;i.forEach(r=>r({chart:e,initial:t.initial,numSteps:a,currentStep:Math.min(n-t.start,a)}))}_refresh(){this._request||=(this._running=!0,Yo.call(window,()=>{this._update(),this._request=null,this._running&&this._refresh()}))}_update(e=Date.now()){let t=0;this._charts.forEach((n,r)=>{if(!n.running||!n.items.length)return;let i=n.items,a=i.length-1,o=!1,s;for(;a>=0;--a)s=i[a],s._active?(s._total>n.duration&&(n.duration=s._total),s.tick(e),o=!0):(i[a]=i[i.length-1],i.pop());o&&(r.draw(),this._notify(r,n,e,`progress`)),i.length||(n.running=!1,this._notify(r,n,e,`complete`),n.initial=!1),t+=i.length}),this._lastDate=e,t===0&&(this._running=!1)}_getAnims(e){let t=this._charts,n=t.get(e);return n||(n={running:!1,initial:!0,items:[],listeners:{complete:[],progress:[]}},t.set(e,n)),n}listen(e,t,n){this._getAnims(e).listeners[t].push(n)}add(e,t){!t||!t.length||this._getAnims(e).items.push(...t)}has(e){return this._getAnims(e).items.length>0}start(e){let t=this._charts.get(e);t&&(t.running=!0,t.start=Date.now(),t.duration=t.items.reduce((e,t)=>Math.max(e,t._duration),0),this._refresh())}running(e){if(!this._running)return!1;let t=this._charts.get(e);return!(!t||!t.running||!t.items.length)}stop(e){let t=this._charts.get(e);if(!t||!t.items.length)return;let n=t.items,r=n.length-1;for(;r>=0;--r)n[r].cancel();t.items=[],this._notify(e,t,Date.now(),`complete`)}remove(e){return this._charts.delete(e)}},Rc=`transparent`,zc={boolean(e,t,n){return n>.5?t:e},color(e,t,n){let r=os(e||Rc),i=r.valid&&os(t||Rc);return i&&i.valid?i.mix(r,n).hexString():t},number(e,t,n){return e+(t-e)*n}},Bc=class{constructor(e,t,n,r){let i=t[n];r=Gs([e.to,r,i,e.from]);let a=Gs([e.from,i,r]);this._active=!0,this._fn=e.fn||zc[e.type||typeof a],this._easing=is[e.easing]||is.linear,this._start=Math.floor(Date.now()+(e.delay||0)),this._duration=this._total=Math.floor(e.duration),this._loop=!!e.loop,this._target=t,this._prop=n,this._from=a,this._to=r,this._promises=void 0}active(){return this._active}update(e,t,n){if(this._active){this._notify(!1);let r=this._target[this._prop],i=n-this._start,a=this._duration-i;this._start=n,this._duration=Math.floor(Math.max(a,e.duration)),this._total+=i,this._loop=!!e.loop,this._to=Gs([e.to,t,r,e.from]),this._from=Gs([e.from,r,t])}}cancel(){this._active&&(this.tick(Date.now()),this._active=!1,this._notify(!1))}tick(e){let t=e-this._start,n=this._duration,r=this._prop,i=this._from,a=this._loop,o=this._to,s;if(this._active=i!==o&&(a||t<n),!this._active){this._target[r]=o,this._notify(!0);return}if(t<0){this._target[r]=i;return}s=t/n%2,s=a&&s>1?2-s:s,s=this._easing(Math.min(1,Math.max(0,s))),this._target[r]=this._fn(i,o,s)}wait(){let e=this._promises||=[];return new Promise((t,n)=>{e.push({res:t,rej:n})})}_notify(e){let t=e?`res`:`rej`,n=this._promises||[];for(let e=0;e<n.length;e++)n[e][t]()}},Vc=class{constructor(e,t){this._chart=e,this._properties=new Map,this.configure(t)}configure(e){if(!G(e))return;let t=Object.keys(Z.animation),n=this._properties;Object.getOwnPropertyNames(e).forEach(r=>{let i=e[r];if(!G(i))return;let a={};for(let e of t)a[e]=i[e];(W(i.properties)&&i.properties||[r]).forEach(e=>{(e===r||!n.has(e))&&n.set(e,a)})})}_animateOptions(e,t){let n=t.options,r=Uc(e,n);if(!r)return[];let i=this._createAnimations(r,n);return n.$shared&&Hc(e.options.$animations,n).then(()=>{e.options=n},()=>{}),i}_createAnimations(e,t){let n=this._properties,r=[],i=e.$animations||={},a=Object.keys(t),o=Date.now(),s;for(s=a.length-1;s>=0;--s){let c=a[s];if(c.charAt(0)===`$`)continue;if(c===`options`){r.push(...this._animateOptions(e,t));continue}let l=t[c],u=i[c],d=n.get(c);if(u){if(d&&u.active()){u.update(d,l,o);continue}u.cancel()}if(!d||!d.duration){e[c]=l;continue}i[c]=u=new Bc(d,e,c,l),r.push(u)}return r}update(e,t){if(this._properties.size===0){Object.assign(e,t);return}let n=this._createAnimations(e,t);if(n.length)return Lc.add(this._chart,n),!0}};function Hc(e,t){let n=[],r=Object.keys(t);for(let t=0;t<r.length;t++){let i=e[r[t]];i&&i.active()&&n.push(i.wait())}return Promise.all(n)}function Uc(e,t){if(!t)return;let n=e.options;if(!n){e.options=t;return}return n.$shared&&(e.options=n=Object.assign({},n,{$shared:!1,$animations:{}})),n}function Wc(e,t){let n=e&&e.options||{},r=n.reverse,i=n.min===void 0?t:0,a=n.max===void 0?t:0;return{start:r?a:i,end:r?i:a}}function Gc(e,t,n){if(n===!1)return!1;let r=Wc(e,n),i=Wc(t,n);return{top:i.end,right:r.end,bottom:i.start,left:r.start}}function Kc(e){let t,n,r,i;return G(e)?(t=e.top,n=e.right,r=e.bottom,i=e.left):t=n=r=i=e,{top:t,right:n,bottom:r,left:i,disabled:e===!1}}function qc(e,t){let n=[],r=e._getSortedDatasetMetas(t),i,a;for(i=0,a=r.length;i<a;++i)n.push(r[i].index);return n}function Jc(e,t,n,r={}){let i=e.keys,a=r.mode===`single`,o,s,c,l;if(t===null)return;let u=!1;for(o=0,s=i.length;o<s;++o){if(c=+i[o],c===n){if(u=!0,r.all)continue;break}l=e.values[c],K(l)&&(a||t===0||Co(t)===Co(l))&&(t+=l)}return!u&&!r.all?0:t}function Yc(e,t){let{iScale:n,vScale:r}=t,i=n.axis===`x`?`x`:`y`,a=r.axis===`x`?`x`:`y`,o=Object.keys(e),s=Array(o.length),c,l,u;for(c=0,l=o.length;c<l;++c)u=o[c],s[c]={[i]:u,[a]:e[u]};return s}function Xc(e,t){let n=e&&e.options.stacked;return n||n===void 0&&t.stack!==void 0}function Zc(e,t,n){return`${e.id}.${t.id}.${n.stack||n.type}`}function Qc(e){let{min:t,max:n,minDefined:r,maxDefined:i}=e.getUserBounds();return{min:r?t:-1/0,max:i?n:1/0}}function $c(e,t,n){let r=e[t]||(e[t]={});return r[n]||(r[n]={})}function el(e,t,n,r){for(let i of t.getMatchingVisibleMetas(r).reverse()){let t=e[i.index];if(n&&t>0||!n&&t<0)return i.index}return null}function tl(e,t){let{chart:n,_cachedMeta:r}=e,i=n._stacks||={},{iScale:a,vScale:o,index:s}=r,c=a.axis,l=o.axis,u=Zc(a,o,r),d=t.length,f;for(let e=0;e<d;++e){let n=t[e],{[c]:a,[l]:d}=n,p=n._stacks||={};f=p[l]=$c(i,u,a),f[s]=d,f._top=el(f,o,!0,r.type),f._bottom=el(f,o,!1,r.type);let m=f._visualValues||(f._visualValues={});m[s]=d}}function nl(e,t){let n=e.scales;return Object.keys(n).filter(e=>n[e].axis===t).shift()}function rl(e,t){return qs(e,{active:!1,dataset:void 0,datasetIndex:t,index:t,mode:`default`,type:`dataset`})}function il(e,t,n){return qs(e,{active:!1,dataIndex:t,parsed:void 0,raw:void 0,element:n,index:t,mode:`default`,type:`data`})}function al(e,t){let n=e.controller.index,r=e.vScale&&e.vScale.axis;if(r){t||=e._parsed;for(let e of t){let t=e._stacks;if(!t||t[r]===void 0||t[r][n]===void 0)return;delete t[r][n],t[r]._visualValues!==void 0&&t[r]._visualValues[n]!==void 0&&delete t[r]._visualValues[n]}}}var ol=e=>e===`reset`||e===`none`,sl=(e,t)=>t?e:Object.assign({},e),cl=(e,t,n)=>e&&!t.hidden&&t._stacked&&{keys:qc(n,!0),values:null},ll=class{static defaults={};static datasetElementType=null;static dataElementType=null;constructor(e,t){this.chart=e,this._ctx=e.ctx,this.index=t,this._cachedDataOpts={},this._cachedMeta=this.getMeta(),this._type=this._cachedMeta.type,this.options=void 0,this._parsing=!1,this._data=void 0,this._objectData=void 0,this._sharedOptions=void 0,this._drawStart=void 0,this._drawCount=void 0,this.enableOptionSharing=!1,this.supportsDecimation=!1,this.$context=void 0,this._syncList=[],this.datasetElementType=new.target.datasetElementType,this.dataElementType=new.target.dataElementType,this.initialize()}initialize(){let e=this._cachedMeta;this.configure(),this.linkScales(),e._stacked=Xc(e.vScale,e),this.addElements(),this.options.fill&&!this.chart.isPluginEnabled(`filler`)&&console.warn(`Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options`)}updateIndex(e){this.index!==e&&al(this._cachedMeta),this.index=e}linkScales(){let e=this.chart,t=this._cachedMeta,n=this.getDataset(),r=(e,t,n,r)=>e===`x`?t:e===`r`?r:n,i=t.xAxisID=q(n.xAxisID,nl(e,`x`)),a=t.yAxisID=q(n.yAxisID,nl(e,`y`)),o=t.rAxisID=q(n.rAxisID,nl(e,`r`)),s=t.indexAxis,c=t.iAxisID=r(s,i,a,o),l=t.vAxisID=r(s,a,i,o);t.xScale=this.getScaleForId(i),t.yScale=this.getScaleForId(a),t.rScale=this.getScaleForId(o),t.iScale=this.getScaleForId(c),t.vScale=this.getScaleForId(l)}getDataset(){return this.chart.data.datasets[this.index]}getMeta(){return this.chart.getDatasetMeta(this.index)}getScaleForId(e){return this.chart.scales[e]}_getOtherScale(e){let t=this._cachedMeta;return e===t.iScale?t.vScale:t.iScale}reset(){this._update(`reset`)}_destroy(){let e=this._cachedMeta;this._data&&qo(this._data,this),e._stacked&&al(e)}_dataCheck(){let e=this.getDataset(),t=e.data||=[],n=this._data;if(G(t)){let e=this._cachedMeta;this._data=Yc(t,e)}else if(n!==t){if(n){qo(n,this);let e=this._cachedMeta;al(e),e._parsed=[]}t&&Object.isExtensible(t)&&Ko(t,this),this._syncList=[],this._data=t}}addElements(){let e=this._cachedMeta;this._dataCheck(),this.datasetElementType&&(e.dataset=new this.datasetElementType)}buildOrUpdateElements(e){let t=this._cachedMeta,n=this.getDataset(),r=!1;this._dataCheck();let i=t._stacked;t._stacked=Xc(t.vScale,t),t.stack!==n.stack&&(r=!0,al(t),t.stack=n.stack),this._resyncElements(e),(r||i!==t._stacked)&&(tl(this,t._parsed),t._stacked=Xc(t.vScale,t))}configure(){let e=this.chart.config,t=e.datasetScopeKeys(this._type),n=e.getOptionScopes(this.getDataset(),t,!0);this.options=e.createResolver(n,this.getContext()),this._parsing=this.options.parsing,this._cachedDataOpts={}}parse(e,t){let{_cachedMeta:n,_data:r}=this,{iScale:i,_stacked:a}=n,o=i.axis,s=e===0&&t===r.length||n._sorted,c=e>0&&n._parsed[e-1],l,u,d;if(this._parsing===!1)n._parsed=r,n._sorted=!0,d=r;else{d=W(r[e])?this.parseArrayData(n,r,e,t):G(r[e])?this.parseObjectData(n,r,e,t):this.parsePrimitiveData(n,r,e,t);let i=()=>u[o]===null||c&&u[o]<c[o];for(l=0;l<t;++l)n._parsed[l+e]=u=d[l],s&&(i()&&(s=!1),c=u);n._sorted=s}a&&tl(this,d)}parsePrimitiveData(e,t,n,r){let{iScale:i,vScale:a}=e,o=i.axis,s=a.axis,c=i.getLabels(),l=i===a,u=Array(r),d,f,p;for(d=0,f=r;d<f;++d)p=d+n,u[d]={[o]:l||i.parse(c[p],p),[s]:a.parse(t[p],p)};return u}parseArrayData(e,t,n,r){let{xScale:i,yScale:a}=e,o=Array(r),s,c,l,u;for(s=0,c=r;s<c;++s)l=s+n,u=t[l],o[s]={x:i.parse(u[0],l),y:a.parse(u[1],l)};return o}parseObjectData(e,t,n,r){let{xScale:i,yScale:a}=e,{xAxisKey:o=`x`,yAxisKey:s=`y`}=this._parsing,c=Array(r),l,u,d,f;for(l=0,u=r;l<u;++l)d=l+n,f=t[d],c[l]={x:i.parse(lo(f,o),d),y:a.parse(lo(f,s),d)};return c}getParsed(e){return this._cachedMeta._parsed[e]}getDataElement(e){return this._cachedMeta.data[e]}applyStack(e,t,n){let r=this.chart,i=this._cachedMeta,a=t[e.axis];return Jc({keys:qc(r,!0),values:t._stacks[e.axis]._visualValues},a,i.index,{mode:n})}updateRangeFromParsed(e,t,n,r){let i=n[t.axis],a=i===null?NaN:i,o=r&&n._stacks[t.axis];r&&o&&(r.values=o,a=Jc(r,i,this._cachedMeta.index)),e.min=Math.min(e.min,a),e.max=Math.max(e.max,a)}getMinMax(e,t){let n=this._cachedMeta,r=n._parsed,i=n._sorted&&e===n.iScale,a=r.length,o=this._getOtherScale(e),s=cl(t,n,this.chart),c={min:1/0,max:-1/0},{min:l,max:u}=Qc(o),d,f;function p(){f=r[d];let t=f[o.axis];return!K(f[e.axis])||l>t||u<t}for(d=0;d<a&&!(!p()&&(this.updateRangeFromParsed(c,e,f,s),i));++d);if(i){for(d=a-1;d>=0;--d)if(!p()){this.updateRangeFromParsed(c,e,f,s);break}}return c}getAllParsedValues(e){let t=this._cachedMeta._parsed,n=[],r,i,a;for(r=0,i=t.length;r<i;++r)a=t[r][e.axis],K(a)&&n.push(a);return n}getMaxOverflow(){return!1}getLabelAndValue(e){let t=this._cachedMeta,n=t.iScale,r=t.vScale,i=this.getParsed(e);return{label:n?``+n.getLabelForValue(i[n.axis]):``,value:r?``+r.getLabelForValue(i[r.axis]):``}}_update(e){let t=this._cachedMeta;this.update(e||`default`),t._clip=Kc(q(this.options.clip,Gc(t.xScale,t.yScale,this.getMaxOverflow())))}update(e){}draw(){let e=this._ctx,t=this.chart,n=this._cachedMeta,r=n.data||[],i=t.chartArea,a=[],o=this._drawStart||0,s=this._drawCount||r.length-o,c=this.options.drawActiveElementsOnTop,l;for(n.dataset&&n.dataset.draw(e,i,o,s),l=o;l<o+s;++l){let t=r[l];t.hidden||(t.active&&c?a.push(t):t.draw(e,i))}for(l=0;l<a.length;++l)a[l].draw(e,i)}getStyle(e,t){let n=t?`active`:`default`;return e===void 0&&this._cachedMeta.dataset?this.resolveDatasetElementOptions(n):this.resolveDataElementOptions(e||0,n)}getContext(e,t,n){let r=this.getDataset(),i;if(e>=0&&e<this._cachedMeta.data.length){let t=this._cachedMeta.data[e];i=t.$context||=il(this.getContext(),e,t),i.parsed=this.getParsed(e),i.raw=r.data[e],i.index=i.dataIndex=e}else i=this.$context||=rl(this.chart.getContext(),this.index),i.dataset=r,i.index=i.datasetIndex=this.index;return i.active=!!t,i.mode=n,i}resolveDatasetElementOptions(e){return this._resolveElementOptions(this.datasetElementType.id,e)}resolveDataElementOptions(e,t){return this._resolveElementOptions(this.dataElementType.id,t,e)}_resolveElementOptions(e,t=`default`,n){let r=t===`active`,i=this._cachedDataOpts,a=e+`-`+t,o=i[a],s=this.enableOptionSharing&&fo(n);if(o)return sl(o,s);let c=this.chart.config,l=c.datasetElementScopeKeys(this._type,e),u=r?[`${e}Hover`,`hover`,e,``]:[e,``],d=c.getOptionScopes(this.getDataset(),l),f=Object.keys(Z.elements[e]),p=c.resolveNamedOptions(d,f,()=>this.getContext(n,r,t),u);return p.$shared&&(p.$shared=s,i[a]=Object.freeze(sl(p,s))),p}_resolveAnimations(e,t,n){let r=this.chart,i=this._cachedDataOpts,a=`animation-${t}`,o=i[a];if(o)return o;let s;if(r.options.animation!==!1){let r=this.chart.config,i=r.datasetAnimationScopeKeys(this._type,t),a=r.getOptionScopes(this.getDataset(),i);s=r.createResolver(a,this.getContext(e,n,t))}let c=new Vc(r,s&&s.animations);return s&&s._cacheable&&(i[a]=Object.freeze(c)),c}getSharedOptions(e){if(e.$shared)return this._sharedOptions||=Object.assign({},e)}includeOptions(e,t){return!t||ol(e)||this.chart._animationsDisabled}_getSharedOptions(e,t){let n=this.resolveDataElementOptions(e,t),r=this._sharedOptions,i=this.getSharedOptions(n),a=this.includeOptions(t,i)||i!==r;return this.updateSharedOptions(i,t,n),{sharedOptions:i,includeOptions:a}}updateElement(e,t,n,r){ol(r)?Object.assign(e,n):this._resolveAnimations(t,r).update(e,n)}updateSharedOptions(e,t,n){e&&!ol(t)&&this._resolveAnimations(void 0,t).update(e,n)}_setStyle(e,t,n,r){e.active=r;let i=this.getStyle(t,r);this._resolveAnimations(t,n,r).update(e,{options:!r&&this.getSharedOptions(i)||i})}removeHoverStyle(e,t,n){this._setStyle(e,n,`active`,!1)}setHoverStyle(e,t,n){this._setStyle(e,n,`active`,!0)}_removeDatasetHoverStyle(){let e=this._cachedMeta.dataset;e&&this._setStyle(e,void 0,`active`,!1)}_setDatasetHoverStyle(){let e=this._cachedMeta.dataset;e&&this._setStyle(e,void 0,`active`,!0)}_resyncElements(e){let t=this._data,n=this._cachedMeta.data;for(let[e,t,n]of this._syncList)this[e](t,n);this._syncList=[];let r=n.length,i=t.length,a=Math.min(i,r);a&&this.parse(0,a),i>r?this._insertElements(r,i-r,e):i<r&&this._removeElements(i,r-i)}_insertElements(e,t,n=!0){let r=this._cachedMeta,i=r.data,a=e+t,o,s=e=>{for(e.length+=t,o=e.length-1;o>=a;o--)e[o]=e[o-t]};for(s(i),o=e;o<a;++o)i[o]=new this.dataElementType;this._parsing&&s(r._parsed),this.parse(e,t),n&&this.updateElements(i,e,t,`reset`)}updateElements(e,t,n,r){}_removeElements(e,t){let n=this._cachedMeta;if(this._parsing){let r=n._parsed.splice(e,t);n._stacked&&al(n,r)}n.data.splice(e,t)}_sync(e){if(this._parsing)this._syncList.push(e);else{let[t,n,r]=e;this[t](n,r)}this.chart._dataChanges.push([this.index,...e])}_onDataPush(){let e=arguments.length;this._sync([`_insertElements`,this.getDataset().data.length-e,e])}_onDataPop(){this._sync([`_removeElements`,this._cachedMeta.data.length-1,1])}_onDataShift(){this._sync([`_removeElements`,0,1])}_onDataSplice(e,t){t&&this._sync([`_removeElements`,e,t]);let n=arguments.length-2;n&&this._sync([`_insertElements`,e,n])}_onDataUnshift(){this._sync([`_insertElements`,0,arguments.length])}};function ul(e,t){if(!e._cache.$bar){let n=e.getMatchingVisibleMetas(t),r=[];for(let t=0,i=n.length;t<i;t++)r=r.concat(n[t].controller.getAllParsedValues(e));e._cache.$bar=Jo(r.sort((e,t)=>e-t))}return e._cache.$bar}function dl(e){let t=e.iScale,n=ul(t,e.type),r=t._length,i,a,o,s,c=()=>{o!==32767&&o!==-32768&&(fo(s)&&(r=Math.min(r,Math.abs(o-s)||r)),s=o)};for(i=0,a=n.length;i<a;++i)o=t.getPixelForValue(n[i]),c();for(s=void 0,i=0,a=t.ticks.length;i<a;++i)o=t.getPixelForTick(i),c();return r}function fl(e,t,n,r){let i=n.barThickness,a,o;return U(i)?(a=t.min*n.categoryPercentage,o=n.barPercentage):(a=i*r,o=1),{chunk:a/r,ratio:o,start:t.pixels[e]-a/2}}function pl(e,t,n,r){let i=t.pixels,a=i[e],o=e>0?i[e-1]:null,s=e<i.length-1?i[e+1]:null,c=n.categoryPercentage;o===null&&(o=a-(s===null?t.end-t.start:s-a)),s===null&&(s=a+a-o);let l=a-(a-Math.min(o,s))/2*c;return{chunk:Math.abs(s-o)/2*c/r,ratio:n.barPercentage,start:l}}function ml(e,t,n,r){let i=n.parse(e[0],r),a=n.parse(e[1],r),o=Math.min(i,a),s=Math.max(i,a),c=o,l=s;Math.abs(o)>Math.abs(s)&&(c=s,l=o),t[n.axis]=l,t._custom={barStart:c,barEnd:l,start:i,end:a,min:o,max:s}}function hl(e,t,n,r){return W(e)?ml(e,t,n,r):t[n.axis]=n.parse(e,r),t}function gl(e,t,n,r){let i=e.iScale,a=e.vScale,o=i.getLabels(),s=i===a,c=[],l,u,d,f;for(l=n,u=n+r;l<u;++l)f=t[l],d={},d[i.axis]=s||i.parse(o[l],l),c.push(hl(f,d,a,l));return c}function _l(e){return e&&e.barStart!==void 0&&e.barEnd!==void 0}function vl(e,t,n){return e===0?(t.isHorizontal()?1:-1)*(t.min>=n?1:-1):Co(e)}function yl(e){let t,n,r,i,a;return e.horizontal?(t=e.base>e.x,n=`left`,r=`right`):(t=e.base<e.y,n=`bottom`,r=`top`),t?(i=`end`,a=`start`):(i=`start`,a=`end`),{start:n,end:r,reverse:t,top:i,bottom:a}}function bl(e,t,n,r){let i=t.borderSkipped,a={};if(!i){e.borderSkipped=a;return}if(i===!0){e.borderSkipped={top:!0,right:!0,bottom:!0,left:!0};return}let{start:o,end:s,reverse:c,top:l,bottom:u}=yl(e);i===`middle`&&n&&(e.enableBorderRadius=!0,(n._top||0)===r?i=l:(n._bottom||0)===r?i=u:(a[xl(u,o,s,c)]=!0,i=l)),a[xl(i,o,s,c)]=!0,e.borderSkipped=a}function xl(e,t,n,r){return r?(e=Sl(e,t,n),e=Cl(e,n,t)):e=Cl(e,t,n),e}function Sl(e,t,n){return e===t?n:e===n?t:e}function Cl(e,t,n){return e===`start`?t:e===`end`?n:e}function wl(e,{inflateAmount:t},n){e.inflateAmount=t===`auto`?n===1?.33:0:t}var Tl=class extends ll{static id=`bar`;static defaults={datasetElementType:!1,dataElementType:`bar`,categoryPercentage:.8,barPercentage:.9,grouped:!0,animations:{numbers:{type:`number`,properties:[`x`,`y`,`base`,`width`,`height`]}}};static overrides={scales:{_index_:{type:`category`,offset:!0,grid:{offset:!0}},_value_:{type:`linear`,beginAtZero:!0}}};parsePrimitiveData(e,t,n,r){return gl(e,t,n,r)}parseArrayData(e,t,n,r){return gl(e,t,n,r)}parseObjectData(e,t,n,r){let{iScale:i,vScale:a}=e,{xAxisKey:o=`x`,yAxisKey:s=`y`}=this._parsing,c=i.axis===`x`?o:s,l=a.axis===`x`?o:s,u=[],d,f,p,m;for(d=n,f=n+r;d<f;++d)m=t[d],p={},p[i.axis]=i.parse(lo(m,c),d),u.push(hl(lo(m,l),p,a,d));return u}updateRangeFromParsed(e,t,n,r){super.updateRangeFromParsed(e,t,n,r);let i=n._custom;i&&t===this._cachedMeta.vScale&&(e.min=Math.min(e.min,i.min),e.max=Math.max(e.max,i.max))}getMaxOverflow(){return 0}getLabelAndValue(e){let{iScale:t,vScale:n}=this._cachedMeta,r=this.getParsed(e),i=r._custom,a=_l(i)?`[`+i.start+`, `+i.end+`]`:``+n.getLabelForValue(r[n.axis]);return{label:``+t.getLabelForValue(r[t.axis]),value:a}}initialize(){this.enableOptionSharing=!0,super.initialize();let e=this._cachedMeta;e.stack=this.getDataset().stack}update(e){let t=this._cachedMeta;this.updateElements(t.data,0,t.data.length,e)}updateElements(e,t,n,r){let i=r===`reset`,{index:a,_cachedMeta:{vScale:o}}=this,s=o.getBasePixel(),c=o.isHorizontal(),l=this._getRuler(),{sharedOptions:u,includeOptions:d}=this._getSharedOptions(t,r);for(let f=t;f<t+n;f++){let t=this.getParsed(f),n=i||U(t[o.axis])?{base:s,head:s}:this._calculateBarValuePixels(f),p=this._calculateBarIndexPixels(f,l),m=(t._stacks||{})[o.axis],h={horizontal:c,base:n.base,enableBorderRadius:!m||_l(t._custom)||a===m._top||a===m._bottom,x:c?n.head:p.center,y:c?p.center:n.head,height:c?p.size:Math.abs(n.size),width:c?Math.abs(n.size):p.size};d&&(h.options=u||this.resolveDataElementOptions(f,e[f].active?`active`:r));let g=h.options||e[f].options;bl(h,g,m,a),wl(h,g,l.ratio),this.updateElement(e[f],f,h,r)}}_getStacks(e,t){let{iScale:n}=this._cachedMeta,r=n.getMatchingVisibleMetas(this._type).filter(e=>e.controller.options.grouped),i=n.options.stacked,a=[],o=this._cachedMeta.controller.getParsed(t),s=o&&o[n.axis],c=e=>{let t=e._parsed.find(e=>e[n.axis]===s),r=t&&t[e.vScale.axis];if(U(r)||isNaN(r))return!0};for(let n of r)if(!(t!==void 0&&c(n))&&((i===!1||a.indexOf(n.stack)===-1||i===void 0&&n.stack===void 0)&&a.push(n.stack),n.index===e))break;return a.length||a.push(void 0),a}_getStackCount(e){return this._getStacks(void 0,e).length}_getAxisCount(){return this._getAxis().length}getFirstScaleIdForIndexAxis(){let e=this.chart.scales,t=this.chart.options.indexAxis;return Object.keys(e).filter(n=>e[n].axis===t).shift()}_getAxis(){let e={},t=this.getFirstScaleIdForIndexAxis();for(let n of this.chart.data.datasets)e[q(this.chart.options.indexAxis===`x`?n.xAxisID:n.yAxisID,t)]=!0;return Object.keys(e)}_getStackIndex(e,t,n){let r=this._getStacks(e,n),i=t===void 0?-1:r.indexOf(t);return i===-1?r.length-1:i}_getRuler(){let e=this.options,t=this._cachedMeta,n=t.iScale,r=[],i,a;for(i=0,a=t.data.length;i<a;++i)r.push(n.getPixelForValue(this.getParsed(i)[n.axis],i));let o=e.barThickness;return{min:o||dl(t),pixels:r,start:n._startPixel,end:n._endPixel,stackCount:this._getStackCount(),scale:n,grouped:e.grouped,ratio:o?1:e.categoryPercentage*e.barPercentage}}_calculateBarValuePixels(e){let{_cachedMeta:{vScale:t,_stacked:n,index:r},options:{base:i,minBarLength:a}}=this,o=i||0,s=this.getParsed(e),c=s._custom,l=_l(c),u=s[t.axis],d=0,f=n?this.applyStack(t,s,n):u,p,m;f!==u&&(d=f-u,f=u),l&&(u=c.barStart,f=c.barEnd-c.barStart,u!==0&&Co(u)!==Co(c.barEnd)&&(d=0),d+=u);let h=!U(i)&&!l?i:d,g=t.getPixelForValue(h);if(p=this.chart.getDataVisibility(e)?t.getPixelForValue(d+f):g,m=p-g,Math.abs(m)<a){m=vl(m,t,o)*a,u===o&&(g-=m/2);let e=t.getPixelForDecimal(0),i=t.getPixelForDecimal(1);g=Math.max(Math.min(g,Math.max(e,i)),Math.min(e,i)),p=g+m,n&&!l&&(s._stacks[t.axis]._visualValues[r]=t.getValueForPixel(p)-t.getValueForPixel(g))}if(g===t.getPixelForValue(o)){let e=Co(m)*t.getLineWidthForValue(o)/2;g+=e,m-=e}return{size:m,base:g,head:p,center:p+m/2}}_calculateBarIndexPixels(e,t){let n=t.scale,r=this.options,i=r.skipNull,a=q(r.maxBarThickness,1/0),o,s,c=this._getAxisCount();if(t.grouped){let n=i?this._getStackCount(e):t.stackCount,l=r.barThickness===`flex`?pl(e,t,r,n*c):fl(e,t,r,n*c),u=this.chart.options.indexAxis===`x`?this.getDataset().xAxisID:this.getDataset().yAxisID,d=this._getAxis().indexOf(q(u,this.getFirstScaleIdForIndexAxis())),f=this._getStackIndex(this.index,this._cachedMeta.stack,i?e:void 0)+d;o=l.start+l.chunk*f+l.chunk/2,s=Math.min(a,l.chunk*l.ratio)}else o=n.getPixelForValue(this.getParsed(e)[n.axis],e),s=Math.min(a,t.min*t.ratio);return{base:o-s/2,head:o+s/2,center:o,size:s}}draw(){let e=this._cachedMeta,t=e.vScale,n=e.data,r=n.length,i=0;for(;i<r;++i)this.getParsed(i)[t.axis]!==null&&!n[i].hidden&&n[i].draw(this._ctx)}};function El(){throw Error(`This method is not implemented: Check that a complete date adapter is provided.`)}var Dl={_date:class e{static override(t){Object.assign(e.prototype,t)}options;constructor(e){this.options=e||{}}init(){}formats(){return El()}parse(){return El()}format(){return El()}add(){return El()}diff(){return El()}startOf(){return El()}endOf(){return El()}}};function Ol(e,t,n,r){let{controller:i,data:a,_sorted:o}=e,s=i._cachedMeta.iScale,c=e.dataset&&e.dataset.options?e.dataset.options.spanGaps:null;if(s&&t===s.axis&&t!==`r`&&o&&a.length){let o=s._reversePixels?Uo:Ho;if(!r){let r=o(a,t,n);if(c){let{vScale:t}=i._cachedMeta,{_parsed:n}=e,a=n.slice(0,r.lo+1).reverse().findIndex(e=>!U(e[t.axis]));r.lo-=Math.max(0,a);let o=n.slice(r.hi).findIndex(e=>!U(e[t.axis]));r.hi+=Math.max(0,o)}return r}if(i._sharedOptions){let e=a[0],r=typeof e.getRange==`function`&&e.getRange(t);if(r){let e=o(a,t,n-r),i=o(a,t,n+r);return{lo:e.lo,hi:i.hi}}}}return{lo:0,hi:a.length-1}}function kl(e,t,n,r,i){let a=e.getSortedVisibleDatasetMetas(),o=n[t];for(let e=0,n=a.length;e<n;++e){let{index:n,data:s}=a[e],{lo:c,hi:l}=Ol(a[e],t,o,i);for(let e=c;e<=l;++e){let t=s[e];t.skip||r(t,n,e)}}}function Al(e){let t=e.indexOf(`x`)!==-1,n=e.indexOf(`y`)!==-1;return function(e,r){let i=t?Math.abs(e.x-r.x):0,a=n?Math.abs(e.y-r.y):0;return Math.sqrt(i**2+a**2)}}function jl(e,t,n,r,i){let a=[];return!i&&!e.isPointInArea(t)||kl(e,n,t,function(n,o,s){!i&&!As(n,e.chartArea,0)||n.inRange(t.x,t.y,r)&&a.push({element:n,datasetIndex:o,index:s})},!0),a}function Ml(e,t,n,r){let i=[];function a(e,n,a){let{startAngle:o,endAngle:s}=e.getProps([`startAngle`,`endAngle`],r),{angle:c}=Po(e,{x:t.x,y:t.y});Lo(c,o,s)&&i.push({element:e,datasetIndex:n,index:a})}return kl(e,n,t,a),i}function Nl(e,t,n,r,i,a){let o=[],s=Al(n),c=1/0;function l(n,l,u){let d=n.inRange(t.x,t.y,i);if(r&&!d)return;let f=n.getCenterPoint(i);if(!(a||e.isPointInArea(f))&&!d)return;let p=s(t,f);p<c?(o=[{element:n,datasetIndex:l,index:u}],c=p):p===c&&o.push({element:n,datasetIndex:l,index:u})}return kl(e,n,t,l),o}function Pl(e,t,n,r,i,a){return!a&&!e.isPointInArea(t)?[]:n===`r`&&!r?Ml(e,t,n,i):Nl(e,t,n,r,i,a)}function Fl(e,t,n,r,i){let a=[],o=n===`x`?`inXRange`:`inYRange`,s=!1;return kl(e,n,t,(e,r,c)=>{e[o]&&e[o](t[n],i)&&(a.push({element:e,datasetIndex:r,index:c}),s||=e.inRange(t.x,t.y,i))}),r&&!s?[]:a}var Il={evaluateInteractionItems:kl,modes:{index(e,t,n,r){let i=Sc(t,e),a=n.axis||`x`,o=n.includeInvisible||!1,s=n.intersect?jl(e,i,a,r,o):Pl(e,i,a,!1,r,o),c=[];return s.length?(e.getSortedVisibleDatasetMetas().forEach(e=>{let t=s[0].index,n=e.data[t];n&&!n.skip&&c.push({element:n,datasetIndex:e.index,index:t})}),c):[]},dataset(e,t,n,r){let i=Sc(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1,s=n.intersect?jl(e,i,a,r,o):Pl(e,i,a,!1,r,o);if(s.length>0){let t=s[0].datasetIndex,n=e.getDatasetMeta(t).data;s=[];for(let e=0;e<n.length;++e)s.push({element:n[e],datasetIndex:t,index:e})}return s},point(e,t,n,r){return jl(e,Sc(t,e),n.axis||`xy`,r,n.includeInvisible||!1)},nearest(e,t,n,r){let i=Sc(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1;return Pl(e,i,a,n.intersect,r,o)},x(e,t,n,r){return Fl(e,Sc(t,e),`x`,n.intersect,r)},y(e,t,n,r){return Fl(e,Sc(t,e),`y`,n.intersect,r)}}},Ll=[`left`,`top`,`right`,`bottom`];function Rl(e,t){return e.filter(e=>e.pos===t)}function zl(e,t){return e.filter(e=>Ll.indexOf(e.pos)===-1&&e.box.axis===t)}function Bl(e,t){return e.sort((e,n)=>{let r=t?n:e,i=t?e:n;return r.weight===i.weight?r.index-i.index:r.weight-i.weight})}function Vl(e){let t=[],n,r,i,a,o,s;for(n=0,r=(e||[]).length;n<r;++n)i=e[n],{position:a,options:{stack:o,stackWeight:s=1}}=i,t.push({index:n,box:i,pos:a,horizontal:i.isHorizontal(),weight:i.weight,stack:o&&a+o,stackWeight:s});return t}function Hl(e){let t={};for(let n of e){let{stack:e,pos:r,stackWeight:i}=n;if(!e||!Ll.includes(r))continue;let a=t[e]||(t[e]={count:0,placed:0,weight:0,size:0});a.count++,a.weight+=i}return t}function Ul(e,t){let n=Hl(e),{vBoxMaxWidth:r,hBoxMaxHeight:i}=t,a,o,s;for(a=0,o=e.length;a<o;++a){s=e[a];let{fullSize:o}=s.box,c=n[s.stack],l=c&&s.stackWeight/c.weight;s.horizontal?(s.width=l?l*r:o&&t.availableWidth,s.height=i):(s.width=r,s.height=l?l*i:o&&t.availableHeight)}return n}function Wl(e){let t=Vl(e),n=Bl(t.filter(e=>e.box.fullSize),!0),r=Bl(Rl(t,`left`),!0),i=Bl(Rl(t,`right`)),a=Bl(Rl(t,`top`),!0),o=Bl(Rl(t,`bottom`)),s=zl(t,`x`),c=zl(t,`y`);return{fullSize:n,leftAndTop:r.concat(a),rightAndBottom:i.concat(c).concat(o).concat(s),chartArea:Rl(t,`chartArea`),vertical:r.concat(i).concat(c),horizontal:a.concat(o).concat(s)}}function Gl(e,t,n,r){return Math.max(e[n],t[n])+Math.max(e[r],t[r])}function Kl(e,t){e.top=Math.max(e.top,t.top),e.left=Math.max(e.left,t.left),e.bottom=Math.max(e.bottom,t.bottom),e.right=Math.max(e.right,t.right)}function ql(e,t,n,r){let{pos:i,box:a}=n,o=e.maxPadding;if(!G(i)){n.size&&(e[i]-=n.size);let t=r[n.stack]||{size:0,count:1};t.size=Math.max(t.size,n.horizontal?a.height:a.width),n.size=t.size/t.count,e[i]+=n.size}a.getPadding&&Kl(o,a.getPadding());let s=Math.max(0,t.outerWidth-Gl(o,e,`left`,`right`)),c=Math.max(0,t.outerHeight-Gl(o,e,`top`,`bottom`)),l=s!==e.w,u=c!==e.h;return e.w=s,e.h=c,n.horizontal?{same:l,other:u}:{same:u,other:l}}function Jl(e){let t=e.maxPadding;function n(n){let r=Math.max(t[n]-e[n],0);return e[n]+=r,r}e.y+=n(`top`),e.x+=n(`left`),n(`right`),n(`bottom`)}function Yl(e,t){let n=t.maxPadding;function r(e){let r={left:0,top:0,right:0,bottom:0};return e.forEach(e=>{r[e]=Math.max(t[e],n[e])}),r}return r(e?[`left`,`right`]:[`top`,`bottom`])}function Xl(e,t,n,r){let i=[],a,o,s,c,l,u;for(a=0,o=e.length,l=0;a<o;++a){s=e[a],c=s.box,c.update(s.width||t.w,s.height||t.h,Yl(s.horizontal,t));let{same:o,other:d}=ql(t,n,s,r);l|=o&&i.length,u||=d,c.fullSize||i.push(s)}return l&&Xl(i,t,n,r)||u}function Zl(e,t,n,r,i){e.top=n,e.left=t,e.right=t+r,e.bottom=n+i,e.width=r,e.height=i}function Ql(e,t,n,r){let i=n.padding,{x:a,y:o}=t;for(let s of e){let e=s.box,c=r[s.stack]||{count:1,placed:0,weight:1},l=s.stackWeight/c.weight||1;if(s.horizontal){let r=t.w*l,a=c.size||e.height;fo(c.start)&&(o=c.start),e.fullSize?Zl(e,i.left,o,n.outerWidth-i.right-i.left,a):Zl(e,t.left+c.placed,o,r,a),c.start=o,c.placed+=r,o=e.bottom}else{let r=t.h*l,o=c.size||e.width;fo(c.start)&&(a=c.start),e.fullSize?Zl(e,a,i.top,o,n.outerHeight-i.bottom-i.top):Zl(e,a,t.top+c.placed,o,r),c.start=a,c.placed+=r,a=e.right}}t.x=a,t.y=o}var $l={addBox(e,t){e.boxes||=[],t.fullSize=t.fullSize||!1,t.position=t.position||`top`,t.weight=t.weight||0,t._layers=t._layers||function(){return[{z:0,draw(e){t.draw(e)}}]},e.boxes.push(t)},removeBox(e,t){let n=e.boxes?e.boxes.indexOf(t):-1;n!==-1&&e.boxes.splice(n,1)},configure(e,t,n){t.fullSize=n.fullSize,t.position=n.position,t.weight=n.weight},update(e,t,n,r){if(!e)return;let i=Q(e.options.layout.padding),a=Math.max(t-i.width,0),o=Math.max(n-i.height,0),s=Wl(e.boxes),c=s.vertical,l=s.horizontal;Y(e.boxes,e=>{typeof e.beforeLayout==`function`&&e.beforeLayout()});let u=c.reduce((e,t)=>t.box.options&&t.box.options.display===!1?e:e+1,0)||1,d=Object.freeze({outerWidth:t,outerHeight:n,padding:i,availableWidth:a,availableHeight:o,vBoxMaxWidth:a/2/u,hBoxMaxHeight:o/2}),f=Object.assign({},i);Kl(f,Q(r));let p=Object.assign({maxPadding:f,w:a,h:o,x:i.left,y:i.top},i),m=Ul(c.concat(l),d);Xl(s.fullSize,p,d,m),Xl(c,p,d,m),Xl(l,p,d,m)&&Xl(c,p,d,m),Jl(p),Ql(s.leftAndTop,p,d,m),p.x+=p.w,p.y+=p.h,Ql(s.rightAndBottom,p,d,m),e.chartArea={left:p.left,top:p.top,right:p.left+p.w,bottom:p.top+p.h,height:p.h,width:p.w},Y(s.chartArea,t=>{let n=t.box;Object.assign(n,e.chartArea),n.update(p.w,p.h,{left:0,top:0,right:0,bottom:0})})}},eu=class{acquireContext(e,t){}releaseContext(e){return!1}addEventListener(e,t,n){}removeEventListener(e,t,n){}getDevicePixelRatio(){return 1}getMaximumSize(e,t,n,r){return t=Math.max(0,t||e.width),n||=e.height,{width:t,height:Math.max(0,r?Math.floor(t/r):n)}}isAttached(e){return!0}updateConfig(e){}},tu=class extends eu{acquireContext(e){return e&&e.getContext&&e.getContext(`2d`)||null}updateConfig(e){e.options.animation=!1}},nu=`$chartjs`,ru={touchstart:`mousedown`,touchmove:`mousemove`,touchend:`mouseup`,pointerenter:`mouseenter`,pointerdown:`mousedown`,pointermove:`mousemove`,pointerup:`mouseup`,pointerleave:`mouseout`,pointerout:`mouseout`},iu=e=>e===null||e===``;function au(e,t){let n=e.style,r=e.getAttribute(`height`),i=e.getAttribute(`width`);if(e[nu]={initial:{height:r,width:i,style:{display:n.display,height:n.height,width:n.width}}},n.display=n.display||`block`,n.boxSizing=n.boxSizing||`border-box`,iu(i)){let t=Oc(e,`width`);t!==void 0&&(e.width=t)}if(iu(r)){if(e.style.height===``)e.height=e.width/(t||2);else{let t=Oc(e,`height`);t!==void 0&&(e.height=t)}}return e}var ou=Dc?{passive:!0}:!1;function su(e,t,n){e&&e.addEventListener(t,n,ou)}function cu(e,t,n){e&&e.canvas&&e.canvas.removeEventListener(t,n,ou)}function lu(e,t){let n=ru[e.type]||e.type,{x:r,y:i}=Sc(e,t);return{type:n,chart:t,native:e,x:r===void 0?null:r,y:i===void 0?null:i}}function uu(e,t){for(let n of e)if(n===t||n.contains(t))return!0}function du(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=uu(n.addedNodes,r),t&&=!uu(n.removedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}function fu(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=uu(n.removedNodes,r),t&&=!uu(n.addedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}var pu=new Map,mu=0;function hu(){let e=window.devicePixelRatio;e!==mu&&(mu=e,pu.forEach((t,n)=>{n.currentDevicePixelRatio!==e&&t()}))}function gu(e,t){pu.size||window.addEventListener(`resize`,hu),pu.set(e,t)}function _u(e){pu.delete(e),pu.size||window.removeEventListener(`resize`,hu)}function vu(e,t,n){let r=e.canvas,i=r&&mc(r);if(!i)return;let a=Xo((e,t)=>{let r=i.clientWidth;n(e,t),r<i.clientWidth&&n()},window),o=new ResizeObserver(e=>{let t=e[0],n=t.contentRect.width,r=t.contentRect.height;(n!==0||r!==0)&&a(n,r)});return o.observe(i),gu(e,a),o}function yu(e,t,n){n&&n.disconnect(),t===`resize`&&_u(e)}function bu(e,t,n){let r=e.canvas,i=Xo(t=>{e.ctx!==null&&n(lu(t,e))},e);return su(r,t,i),i}var xu=class extends eu{acquireContext(e,t){let n=e&&e.getContext&&e.getContext(`2d`);return n&&n.canvas===e?(au(e,t),n):null}releaseContext(e){let t=e.canvas;if(!t[nu])return!1;let n=t[nu].initial;[`height`,`width`].forEach(e=>{let r=n[e];U(r)?t.removeAttribute(e):t.setAttribute(e,r)});let r=n.style||{};return Object.keys(r).forEach(e=>{t.style[e]=r[e]}),t.width=t.width,delete t[nu],!0}addEventListener(e,t,n){this.removeEventListener(e,t);let r=e.$proxies||={};r[t]=({attach:du,detach:fu,resize:vu}[t]||bu)(e,t,n)}removeEventListener(e,t){let n=e.$proxies||={},r=n[t];r&&(({attach:yu,detach:yu,resize:yu}[t]||cu)(e,t,r),n[t]=void 0)}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(e,t,n,r){return Tc(e,t,n,r)}isAttached(e){let t=e&&mc(e);return!!(t&&t.isConnected)}};function Su(e){return!pc()||typeof OffscreenCanvas<`u`&&e instanceof OffscreenCanvas?tu:xu}var Cu=class{static defaults={};static defaultRoutes=void 0;x;y;active=!1;options;$animations;tooltipPosition(e){let{x:t,y:n}=this.getProps([`x`,`y`],e);return{x:t,y:n}}hasValue(){return Oo(this.x)&&Oo(this.y)}getProps(e,t){let n=this.$animations;if(!t||!n)return this;let r={};return e.forEach(e=>{r[e]=n[e]&&n[e].active()?n[e]._to:this[e]}),r}};function wu(e,t){let n=e.options.ticks,r=Tu(e),i=Math.min(n.maxTicksLimit||r,r),a=n.major.enabled?Du(t):[],o=a.length,s=a[0],c=a[o-1],l=[];if(o>i)return Ou(t,l,a,o/i),l;let u=Eu(a,t,i);if(o>0){let e,n,r=o>1?Math.round((c-s)/(o-1)):null;for(ku(t,l,u,U(r)?0:s-r,s),e=0,n=o-1;e<n;e++)ku(t,l,u,a[e],a[e+1]);return ku(t,l,u,c,U(r)?t.length:c+r),l}return ku(t,l,u),l}function Tu(e){let t=e.options.offset,n=e._tickSize(),r=e._length/n+ +!t,i=e._maxLength/n;return Math.floor(Math.min(r,i))}function Eu(e,t,n){let r=Au(e),i=t.length/n;if(!r)return Math.max(i,1);let a=Eo(r);for(let e=0,t=a.length-1;e<t;e++){let t=a[e];if(t>i)return t}return Math.max(i,1)}function Du(e){let t=[],n,r;for(n=0,r=e.length;n<r;n++)e[n].major&&t.push(n);return t}function Ou(e,t,n,r){let i=0,a=n[0],o;for(r=Math.ceil(r),o=0;o<e.length;o++)o===a&&(t.push(e[o]),i++,a=n[i*r])}function ku(e,t,n,r,i){let a=q(r,0),o=Math.min(q(i,e.length),e.length),s=0,c,l,u;for(n=Math.ceil(n),i&&(c=i-r,n=c/Math.floor(c/n)),u=a;u<0;)s++,u=Math.round(a+s*n);for(l=Math.max(a,0);l<o;l++)l===u&&(t.push(e[l]),s++,u=Math.round(a+s*n))}function Au(e){let t=e.length,n,r;if(t<2)return!1;for(r=e[0],n=1;n<t;++n)if(e[n]-e[n-1]!==r)return!1;return r}var ju=e=>e===`left`?`right`:e===`right`?`left`:e,Mu=(e,t,n)=>t===`top`||t===`left`?e[t]+n:e[t]-n,Nu=(e,t)=>Math.min(t||e,e);function Pu(e,t){let n=[],r=e.length/t,i=e.length,a=0;for(;a<i;a+=r)n.push(e[Math.floor(a)]);return n}function Fu(e,t,n){let r=e.ticks.length,i=Math.min(t,r-1),a=e._startPixel,o=e._endPixel,s=1e-6,c=e.getPixelForTick(i),l;if(!(n&&(l=r===1?Math.max(c-a,o-c):t===0?(e.getPixelForTick(1)-c)/2:(c-e.getPixelForTick(i-1))/2,c+=i<t?l:-l,c<a-s||c>o+s)))return c}function Iu(e,t){Y(e,e=>{let n=e.gc,r=n.length/2,i;if(r>t){for(i=0;i<r;++i)delete e.data[n[i]];n.splice(0,r)}})}function Lu(e){return e.drawTicks?e.tickLength:0}function Ru(e,t){if(!e.display)return 0;let n=$(e.font,t),r=Q(e.padding);return(W(e.text)?e.text.length:1)*n.lineHeight+r.height}function zu(e,t){return qs(e,{scale:t,type:`scale`})}function Bu(e,t,n){return qs(e,{tick:n,index:t,type:`tick`})}function Vu(e,t,n){let r=Qo(e);return(n&&t!==`right`||!n&&t===`right`)&&(r=ju(r)),r}function Hu(e,t,n,r){let{top:i,left:a,bottom:o,right:s,chart:c}=e,{chartArea:l,scales:u}=c,d=0,f,p,m,h=o-i,g=s-a;if(e.isHorizontal()){if(p=$o(r,a,s),G(n)){let e=Object.keys(n)[0],r=n[e];m=u[e].getPixelForValue(r)+h-t}else m=n===`center`?(l.bottom+l.top)/2+h-t:Mu(e,n,t);f=s-a}else{if(G(n)){let e=Object.keys(n)[0],r=n[e];p=u[e].getPixelForValue(r)-g+t}else p=n===`center`?(l.left+l.right)/2-g+t:Mu(e,n,t);m=$o(r,o,i),d=n===`left`?-yo:yo}return{titleX:p,titleY:m,maxWidth:f,rotation:d}}var Uu=class e extends Cu{constructor(e){super(),this.id=e.id,this.type=e.type,this.options=void 0,this.ctx=e.ctx,this.chart=e.chart,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this._margins={left:0,right:0,top:0,bottom:0},this.maxWidth=void 0,this.maxHeight=void 0,this.paddingTop=void 0,this.paddingBottom=void 0,this.paddingLeft=void 0,this.paddingRight=void 0,this.axis=void 0,this.labelRotation=void 0,this.min=void 0,this.max=void 0,this._range=void 0,this.ticks=[],this._gridLineItems=null,this._labelItems=null,this._labelSizes=null,this._length=0,this._maxLength=0,this._longestTextCache={},this._startPixel=void 0,this._endPixel=void 0,this._reversePixels=!1,this._userMax=void 0,this._userMin=void 0,this._suggestedMax=void 0,this._suggestedMin=void 0,this._ticksLength=0,this._borderValue=0,this._cache={},this._dataLimitsCached=!1,this.$context=void 0}init(e){this.options=e.setContext(this.getContext()),this.axis=e.axis,this._userMin=this.parse(e.min),this._userMax=this.parse(e.max),this._suggestedMin=this.parse(e.suggestedMin),this._suggestedMax=this.parse(e.suggestedMax)}parse(e,t){return e}getUserBounds(){let{_userMin:e,_userMax:t,_suggestedMin:n,_suggestedMax:r}=this;return e=Za(e,1/0),t=Za(t,-1/0),n=Za(n,1/0),r=Za(r,-1/0),{min:Za(e,n),max:Za(t,r),minDefined:K(e),maxDefined:K(t)}}getMinMax(e){let{min:t,max:n,minDefined:r,maxDefined:i}=this.getUserBounds(),a;if(r&&i)return{min:t,max:n};let o=this.getMatchingVisibleMetas();for(let s=0,c=o.length;s<c;++s)a=o[s].controller.getMinMax(this,e),r||(t=Math.min(t,a.min)),i||(n=Math.max(n,a.max));return t=i&&t>n?n:t,n=r&&t>n?t:n,{min:Za(t,Za(n,t)),max:Za(n,Za(t,n))}}getPadding(){return{left:this.paddingLeft||0,top:this.paddingTop||0,right:this.paddingRight||0,bottom:this.paddingBottom||0}}getTicks(){return this.ticks}getLabels(){let e=this.chart.data;return this.options.labels||(this.isHorizontal()?e.xLabels:e.yLabels)||e.labels||[]}getLabelItems(e=this.chart.chartArea){return this._labelItems||=this._computeLabelItems(e)}beforeLayout(){this._cache={},this._dataLimitsCached=!1}beforeUpdate(){J(this.options.beforeUpdate,[this])}update(e,t,n){let{beginAtZero:r,grace:i,ticks:a}=this.options,o=a.sampleSize;this.beforeUpdate(),this.maxWidth=e,this.maxHeight=t,this._margins=n=Object.assign({left:0,right:0,top:0,bottom:0},n),this.ticks=null,this._labelSizes=null,this._gridLineItems=null,this._labelItems=null,this.beforeSetDimensions(),this.setDimensions(),this.afterSetDimensions(),this._maxLength=this.isHorizontal()?this.width+n.left+n.right:this.height+n.top+n.bottom,this._dataLimitsCached||=(this.beforeDataLimits(),this.determineDataLimits(),this.afterDataLimits(),this._range=Ks(this,i,r),!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();let s=o<this.ticks.length;this._convertTicksToLabels(s?Pu(this.ticks,o):this.ticks),this.configure(),this.beforeCalculateLabelRotation(),this.calculateLabelRotation(),this.afterCalculateLabelRotation(),a.display&&(a.autoSkip||a.source===`auto`)&&(this.ticks=wu(this,this.ticks),this._labelSizes=null,this.afterAutoSkip()),s&&this._convertTicksToLabels(this.ticks),this.beforeFit(),this.fit(),this.afterFit(),this.afterUpdate()}configure(){let e=this.options.reverse,t,n;this.isHorizontal()?(t=this.left,n=this.right):(t=this.top,n=this.bottom,e=!e),this._startPixel=t,this._endPixel=n,this._reversePixels=e,this._length=n-t,this._alignToPixels=this.options.alignToPixels}afterUpdate(){J(this.options.afterUpdate,[this])}beforeSetDimensions(){J(this.options.beforeSetDimensions,[this])}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=0,this.right=this.width):(this.height=this.maxHeight,this.top=0,this.bottom=this.height),this.paddingLeft=0,this.paddingTop=0,this.paddingRight=0,this.paddingBottom=0}afterSetDimensions(){J(this.options.afterSetDimensions,[this])}_callHooks(e){this.chart.notifyPlugins(e,this.getContext()),J(this.options[e],[this])}beforeDataLimits(){this._callHooks(`beforeDataLimits`)}determineDataLimits(){}afterDataLimits(){this._callHooks(`afterDataLimits`)}beforeBuildTicks(){this._callHooks(`beforeBuildTicks`)}buildTicks(){return[]}afterBuildTicks(){this._callHooks(`afterBuildTicks`)}beforeTickToLabelConversion(){J(this.options.beforeTickToLabelConversion,[this])}generateTickLabels(e){let t=this.options.ticks,n,r,i;for(n=0,r=e.length;n<r;n++)i=e[n],i.label=J(t.callback,[i.value,n,e],this)}afterTickToLabelConversion(){J(this.options.afterTickToLabelConversion,[this])}beforeCalculateLabelRotation(){J(this.options.beforeCalculateLabelRotation,[this])}calculateLabelRotation(){let e=this.options,t=e.ticks,n=Nu(this.ticks.length,e.ticks.maxTicksLimit),r=t.minRotation||0,i=t.maxRotation,a=r,o,s,c;if(!this._isVisible()||!t.display||r>=i||n<=1||!this.isHorizontal()){this.labelRotation=r;return}let l=this._getLabelSizes(),u=l.widest.width,d=l.highest.height,f=Ro(this.chart.width-u,0,this.maxWidth);o=e.offset?this.maxWidth/n:f/(n-1),u+6>o&&(o=f/(n-(e.offset?.5:1)),s=this.maxHeight-Lu(e.grid)-t.padding-Ru(e.title,this.chart.options.font),c=Math.sqrt(u*u+d*d),a=Mo(Math.min(Math.asin(Ro((l.highest.height+6)/o,-1,1)),Math.asin(Ro(s/c,-1,1))-Math.asin(Ro(d/c,-1,1)))),a=Math.max(r,Math.min(i,a))),this.labelRotation=a}afterCalculateLabelRotation(){J(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){J(this.options.beforeFit,[this])}fit(){let e={width:0,height:0},{chart:t,options:{ticks:n,title:r,grid:i}}=this,a=this._isVisible(),o=this.isHorizontal();if(a){let a=Ru(r,t.options.font);if(o?(e.width=this.maxWidth,e.height=Lu(i)+a):(e.height=this.maxHeight,e.width=Lu(i)+a),n.display&&this.ticks.length){let{first:t,last:r,widest:i,highest:a}=this._getLabelSizes(),s=n.padding*2,c=jo(this.labelRotation),l=Math.cos(c),u=Math.sin(c);if(o){let t=n.mirror?0:u*i.width+l*a.height;e.height=Math.min(this.maxHeight,e.height+t+s)}else{let t=n.mirror?0:l*i.width+u*a.height;e.width=Math.min(this.maxWidth,e.width+t+s)}this._calculatePadding(t,r,u,l)}}this._handleMargins(),o?(this.width=this._length=t.width-this._margins.left-this._margins.right,this.height=e.height):(this.width=e.width,this.height=this._length=t.height-this._margins.top-this._margins.bottom)}_calculatePadding(e,t,n,r){let{ticks:{align:i,padding:a},position:o}=this.options,s=this.labelRotation!==0,c=o!==`top`&&this.axis===`x`;if(this.isHorizontal()){let o=this.getPixelForTick(0)-this.left,l=this.right-this.getPixelForTick(this.ticks.length-1),u=0,d=0;s?c?(u=r*e.width,d=n*t.height):(u=n*e.height,d=r*t.width):i===`start`?d=t.width:i===`end`?u=e.width:i!==`inner`&&(u=e.width/2,d=t.width/2),this.paddingLeft=Math.max((u-o+a)*this.width/(this.width-o),0),this.paddingRight=Math.max((d-l+a)*this.width/(this.width-l),0)}else{let n=t.height/2,r=e.height/2;i===`start`?(n=0,r=e.height):i===`end`&&(n=t.height,r=0),this.paddingTop=n+a,this.paddingBottom=r+a}}_handleMargins(){this._margins&&(this._margins.left=Math.max(this.paddingLeft,this._margins.left),this._margins.top=Math.max(this.paddingTop,this._margins.top),this._margins.right=Math.max(this.paddingRight,this._margins.right),this._margins.bottom=Math.max(this.paddingBottom,this._margins.bottom))}afterFit(){J(this.options.afterFit,[this])}isHorizontal(){let{axis:e,position:t}=this.options;return t===`top`||t===`bottom`||e===`x`}isFullSize(){return this.options.fullSize}_convertTicksToLabels(e){this.beforeTickToLabelConversion(),this.generateTickLabels(e);let t,n;for(t=0,n=e.length;t<n;t++)U(e[t].label)&&(e.splice(t,1),n--,t--);this.afterTickToLabelConversion()}_getLabelSizes(){let e=this._labelSizes;if(!e){let t=this.options.ticks.sampleSize,n=this.ticks;t<n.length&&(n=Pu(n,t)),this._labelSizes=e=this._computeLabelSizes(n,n.length,this.options.ticks.maxTicksLimit)}return e}_computeLabelSizes(e,t,n){let{ctx:r,_longestTextCache:i}=this,a=[],o=[],s=Math.floor(t/Nu(t,n)),c=0,l=0,u,d,f,p,m,h,g,_,v,y,b;for(u=0;u<t;u+=s){if(p=e[u].label,m=this._resolveTickFontOptions(u),r.font=h=m.string,g=i[h]=i[h]||{data:{},gc:[]},_=m.lineHeight,v=y=0,!U(p)&&!W(p))v=ws(r,g.data,g.gc,v,p),y=_;else if(W(p))for(d=0,f=p.length;d<f;++d)b=p[d],!U(b)&&!W(b)&&(v=ws(r,g.data,g.gc,v,b),y+=_);a.push(v),o.push(y),c=Math.max(v,c),l=Math.max(y,l)}Iu(i,t);let x=a.indexOf(c),S=o.indexOf(l),C=e=>({width:a[e]||0,height:o[e]||0});return{first:C(0),last:C(t-1),widest:C(x),highest:C(S),widths:a,heights:o}}getLabelForValue(e){return e}getPixelForValue(e,t){return NaN}getValueForPixel(e){}getPixelForTick(e){let t=this.ticks;return e<0||e>t.length-1?null:this.getPixelForValue(t[e].value)}getPixelForDecimal(e){this._reversePixels&&(e=1-e);let t=this._startPixel+e*this._length;return zo(this._alignToPixels?Es(this.chart,t,0):t)}getDecimalForPixel(e){let t=(e-this._startPixel)/this._length;return this._reversePixels?1-t:t}getBasePixel(){return this.getPixelForValue(this.getBaseValue())}getBaseValue(){let{min:e,max:t}=this;return e<0&&t<0?t:e>0&&t>0?e:0}getContext(e){let t=this.ticks||[];if(e>=0&&e<t.length){let n=t[e];return n.$context||=Bu(this.getContext(),e,n)}return this.$context||=zu(this.chart.getContext(),this)}_tickSize(){let e=this.options.ticks,t=jo(this.labelRotation),n=Math.abs(Math.cos(t)),r=Math.abs(Math.sin(t)),i=this._getLabelSizes(),a=e.autoSkipPadding||0,o=i?i.widest.width+a:0,s=i?i.highest.height+a:0;return this.isHorizontal()?s*n>o*r?o/n:s/r:s*r<o*n?s/n:o/r}_isVisible(){let e=this.options.display;return e===`auto`?this.getMatchingVisibleMetas().length>0:!!e}_computeGridLineItems(e){let t=this.axis,n=this.chart,r=this.options,{grid:i,position:a,border:o}=r,s=i.offset,c=this.isHorizontal(),l=this.ticks.length+ +!!s,u=Lu(i),d=[],f=o.setContext(this.getContext()),p=f.display?f.width:0,m=p/2,h=function(e){return Es(n,e,p)},g,_,v,y,b,x,S,C,w,T,E,D;if(a===`top`)g=h(this.bottom),x=this.bottom-u,C=g-m,T=h(e.top)+m,D=e.bottom;else if(a===`bottom`)g=h(this.top),T=e.top,D=h(e.bottom)-m,x=g+m,C=this.top+u;else if(a===`left`)g=h(this.right),b=this.right-u,S=g-m,w=h(e.left)+m,E=e.right;else if(a===`right`)g=h(this.left),w=e.left,E=h(e.right)-m,b=g+m,S=this.left+u;else if(t===`x`){if(a===`center`)g=h((e.top+e.bottom)/2+.5);else if(G(a)){let e=Object.keys(a)[0],t=a[e];g=h(this.chart.scales[e].getPixelForValue(t))}T=e.top,D=e.bottom,x=g+m,C=x+u}else if(t===`y`){if(a===`center`)g=h((e.left+e.right)/2);else if(G(a)){let e=Object.keys(a)[0],t=a[e];g=h(this.chart.scales[e].getPixelForValue(t))}b=g-m,S=b-u,w=e.left,E=e.right}let O=q(r.ticks.maxTicksLimit,l),k=Math.max(1,Math.ceil(l/O));for(_=0;_<l;_+=k){let e=this.getContext(_),t=i.setContext(e),r=o.setContext(e),a=t.lineWidth,l=t.color,u=r.dash||[],f=r.dashOffset,p=t.tickWidth,m=t.tickColor,h=t.tickBorderDash||[],g=t.tickBorderDashOffset;v=Fu(this,_,s),v!==void 0&&(y=Es(n,v,a),c?b=S=w=E=y:x=C=T=D=y,d.push({tx1:b,ty1:x,tx2:S,ty2:C,x1:w,y1:T,x2:E,y2:D,width:a,color:l,borderDash:u,borderDashOffset:f,tickWidth:p,tickColor:m,tickBorderDash:h,tickBorderDashOffset:g}))}return this._ticksLength=l,this._borderValue=g,d}_computeLabelItems(e){let t=this.axis,n=this.options,{position:r,ticks:i}=n,a=this.isHorizontal(),o=this.ticks,{align:s,crossAlign:c,padding:l,mirror:u}=i,d=Lu(n.grid),f=d+l,p=u?-l:f,m=-jo(this.labelRotation),h=[],g,_,v,y,b,x,S,C,w,T,E,D,O=`middle`;if(r===`top`)x=this.bottom-p,S=this._getXAxisLabelAlignment();else if(r===`bottom`)x=this.top+p,S=this._getXAxisLabelAlignment();else if(r===`left`){let e=this._getYAxisLabelAlignment(d);S=e.textAlign,b=e.x}else if(r===`right`){let e=this._getYAxisLabelAlignment(d);S=e.textAlign,b=e.x}else if(t===`x`){if(r===`center`)x=(e.top+e.bottom)/2+f;else if(G(r)){let e=Object.keys(r)[0],t=r[e];x=this.chart.scales[e].getPixelForValue(t)+f}S=this._getXAxisLabelAlignment()}else if(t===`y`){if(r===`center`)b=(e.left+e.right)/2-f;else if(G(r)){let e=Object.keys(r)[0],t=r[e];b=this.chart.scales[e].getPixelForValue(t)}S=this._getYAxisLabelAlignment(d).textAlign}t===`y`&&(s===`start`?O=`top`:s===`end`&&(O=`bottom`));let k=this._getLabelSizes();for(g=0,_=o.length;g<_;++g){v=o[g],y=v.label;let e=i.setContext(this.getContext(g));C=this.getPixelForTick(g)+i.labelOffset,w=this._resolveTickFontOptions(g),T=w.lineHeight,E=W(y)?y.length:1;let t=E/2,n=e.color,s=e.textStrokeColor,l=e.textStrokeWidth,d=S;a?(b=C,S===`inner`&&(d=g===_-1?this.options.reverse?`left`:`right`:g===0?this.options.reverse?`right`:`left`:`center`),D=r===`top`?c===`near`||m!==0?-E*T+T/2:c===`center`?-k.highest.height/2-t*T+T:-k.highest.height+T/2:c===`near`||m!==0?T/2:c===`center`?k.highest.height/2-t*T:k.highest.height-E*T,u&&(D*=-1),m!==0&&!e.showLabelBackdrop&&(b+=T/2*Math.sin(m))):(x=C,D=(1-E)*T/2);let f;if(e.showLabelBackdrop){let t=Q(e.backdropPadding),n=k.heights[g],r=k.widths[g],i=D-t.top,a=0-t.left;switch(O){case`middle`:i-=n/2;break;case`bottom`:i-=n}switch(S){case`center`:a-=r/2;break;case`right`:a-=r;break;case`inner`:g===_-1?a-=r:g>0&&(a-=r/2)}f={left:a,top:i,width:r+t.width,height:n+t.height,color:e.backdropColor}}h.push({label:y,font:w,textOffset:D,options:{rotation:m,color:n,strokeColor:s,strokeWidth:l,textAlign:d,textBaseline:O,translation:[b,x],backdrop:f}})}return h}_getXAxisLabelAlignment(){let{position:e,ticks:t}=this.options;if(-jo(this.labelRotation))return e===`top`?`left`:`right`;let n=`center`;return t.align===`start`?n=`left`:t.align===`end`?n=`right`:t.align===`inner`&&(n=`inner`),n}_getYAxisLabelAlignment(e){let{position:t,ticks:{crossAlign:n,mirror:r,padding:i}}=this.options,a=this._getLabelSizes(),o=e+i,s=a.widest.width,c,l;return t===`left`?r?(l=this.right+i,n===`near`?c=`left`:n===`center`?(c=`center`,l+=s/2):(c=`right`,l+=s)):(l=this.right-o,n===`near`?c=`right`:n===`center`?(c=`center`,l-=s/2):(c=`left`,l=this.left)):t===`right`?r?(l=this.left+i,n===`near`?c=`right`:n===`center`?(c=`center`,l-=s/2):(c=`left`,l-=s)):(l=this.left+o,n===`near`?c=`left`:n===`center`?(c=`center`,l+=s/2):(c=`right`,l=this.right)):c=`right`,{textAlign:c,x:l}}_computeLabelArea(){if(this.options.ticks.mirror)return;let e=this.chart,t=this.options.position;if(t===`left`||t===`right`)return{top:0,left:this.left,bottom:e.height,right:this.right};if(t===`top`||t===`bottom`)return{top:this.top,left:0,bottom:this.bottom,right:e.width}}drawBackground(){let{ctx:e,options:{backgroundColor:t},left:n,top:r,width:i,height:a}=this;t&&(e.save(),e.fillStyle=t,e.fillRect(n,r,i,a),e.restore())}getLineWidthForValue(e){let t=this.options.grid;if(!this._isVisible()||!t.display)return 0;let n=this.ticks.findIndex(t=>t.value===e);return n>=0?t.setContext(this.getContext(n)).lineWidth:0}drawGrid(e){let t=this.options.grid,n=this.ctx,r=this._gridLineItems||=this._computeGridLineItems(e),i,a,o=(e,t,r)=>{!r.width||!r.color||(n.save(),n.lineWidth=r.width,n.strokeStyle=r.color,n.setLineDash(r.borderDash||[]),n.lineDashOffset=r.borderDashOffset,n.beginPath(),n.moveTo(e.x,e.y),n.lineTo(t.x,t.y),n.stroke(),n.restore())};if(t.display)for(i=0,a=r.length;i<a;++i){let e=r[i];t.drawOnChartArea&&o({x:e.x1,y:e.y1},{x:e.x2,y:e.y2},e),t.drawTicks&&o({x:e.tx1,y:e.ty1},{x:e.tx2,y:e.ty2},{color:e.tickColor,width:e.tickWidth,borderDash:e.tickBorderDash,borderDashOffset:e.tickBorderDashOffset})}}drawBorder(){let{chart:e,ctx:t,options:{border:n,grid:r}}=this,i=n.setContext(this.getContext()),a=n.display?i.width:0;if(!a)return;let o=r.setContext(this.getContext(0)).lineWidth,s=this._borderValue,c,l,u,d;this.isHorizontal()?(c=Es(e,this.left,a)-a/2,l=Es(e,this.right,o)+o/2,u=d=s):(u=Es(e,this.top,a)-a/2,d=Es(e,this.bottom,o)+o/2,c=l=s),t.save(),t.lineWidth=i.width,t.strokeStyle=i.color,t.beginPath(),t.moveTo(c,u),t.lineTo(l,d),t.stroke(),t.restore()}drawLabels(e){if(!this.options.ticks.display)return;let t=this.ctx,n=this._computeLabelArea();n&&js(t,n);let r=this.getLabelItems(e);for(let e of r){let n=e.options,r=e.font,i=e.label,a=e.textOffset;Is(t,i,0,a,r,n)}n&&Ms(t)}drawTitle(){let{ctx:e,options:{position:t,title:n,reverse:r}}=this;if(!n.display)return;let i=$(n.font),a=Q(n.padding),o=n.align,s=i.lineHeight/2;t===`bottom`||t===`center`||G(t)?(s+=a.bottom,W(n.text)&&(s+=i.lineHeight*(n.text.length-1))):s+=a.top;let{titleX:c,titleY:l,maxWidth:u,rotation:d}=Hu(this,s,t,o);Is(e,n.text,0,0,i,{color:n.color,maxWidth:u,rotation:d,textAlign:Vu(o,t,r),textBaseline:`middle`,translation:[c,l]})}draw(e){this._isVisible()&&(this.drawBackground(),this.drawGrid(e),this.drawBorder(),this.drawTitle(),this.drawLabels(e))}_layers(){let t=this.options,n=t.ticks&&t.ticks.z||0,r=q(t.grid&&t.grid.z,-1),i=q(t.border&&t.border.z,0);return!this._isVisible()||this.draw!==e.prototype.draw?[{z:n,draw:e=>{this.draw(e)}}]:[{z:r,draw:e=>{this.drawBackground(),this.drawGrid(e),this.drawTitle()}},{z:i,draw:()=>{this.drawBorder()}},{z:n,draw:e=>{this.drawLabels(e)}}]}getMatchingVisibleMetas(e){let t=this.chart.getSortedVisibleDatasetMetas(),n=this.axis+`AxisID`,r=[],i,a;for(i=0,a=t.length;i<a;++i){let a=t[i];a[n]===this.id&&(!e||a.type===e)&&r.push(a)}return r}_resolveTickFontOptions(e){return $(this.options.ticks.setContext(this.getContext(e)).font)}_maxDigits(){let e=this._resolveTickFontOptions(0).lineHeight;return(this.isHorizontal()?this.width:this.height)/e}},Wu=class{constructor(e,t,n){this.type=e,this.scope=t,this.override=n,this.items=Object.create(null)}isForType(e){return Object.prototype.isPrototypeOf.call(this.type.prototype,e.prototype)}register(e){let t=Object.getPrototypeOf(e),n;qu(t)&&(n=this.register(t));let r=this.items,i=e.id,a=this.scope+`.`+i;if(!i)throw Error(`class does not have id: `+e);return i in r?a:(r[i]=e,Gu(e,a,n),this.override&&Z.override(e.id,e.overrides),a)}get(e){return this.items[e]}unregister(e){let t=this.items,n=e.id,r=this.scope;n in t&&delete t[n],r&&n in Z[r]&&(delete Z[r][n],this.override&&delete ys[n])}};function Gu(e,t,n){let r=ro(Object.create(null),[n?Z.get(n):{},Z.get(t),e.defaults]);Z.set(t,r),e.defaultRoutes&&Ku(t,e.defaultRoutes),e.descriptors&&Z.describe(t,e.descriptors)}function Ku(e,t){Object.keys(t).forEach(n=>{let r=n.split(`.`),i=r.pop(),a=[e].concat(r).join(`.`),o=t[n].split(`.`),s=o.pop(),c=o.join(`.`);Z.route(a,i,c,s)})}function qu(e){return`id`in e&&`defaults`in e}var Ju=new class{constructor(){this.controllers=new Wu(ll,`datasets`,!0),this.elements=new Wu(Cu,`elements`),this.plugins=new Wu(Object,`plugins`),this.scales=new Wu(Uu,`scales`),this._typedRegistries=[this.controllers,this.scales,this.elements]}add(...e){this._each(`register`,e)}remove(...e){this._each(`unregister`,e)}addControllers(...e){this._each(`register`,e,this.controllers)}addElements(...e){this._each(`register`,e,this.elements)}addPlugins(...e){this._each(`register`,e,this.plugins)}addScales(...e){this._each(`register`,e,this.scales)}getController(e){return this._get(e,this.controllers,`controller`)}getElement(e){return this._get(e,this.elements,`element`)}getPlugin(e){return this._get(e,this.plugins,`plugin`)}getScale(e){return this._get(e,this.scales,`scale`)}removeControllers(...e){this._each(`unregister`,e,this.controllers)}removeElements(...e){this._each(`unregister`,e,this.elements)}removePlugins(...e){this._each(`unregister`,e,this.plugins)}removeScales(...e){this._each(`unregister`,e,this.scales)}_each(e,t,n){[...t].forEach(t=>{let r=n||this._getRegistryForType(t);n||r.isForType(t)||r===this.plugins&&t.id?this._exec(e,r,t):Y(t,t=>{let r=n||this._getRegistryForType(t);this._exec(e,r,t)})})}_exec(e,t,n){let r=uo(e);J(n[`before`+r],[],n),t[e](n),J(n[`after`+r],[],n)}_getRegistryForType(e){for(let t=0;t<this._typedRegistries.length;t++){let n=this._typedRegistries[t];if(n.isForType(e))return n}return this.plugins}_get(e,t,n){let r=t.get(e);if(r===void 0)throw Error(`"`+e+`" is not a registered `+n+`.`);return r}},Yu=class{constructor(){this._init=void 0}notify(e,t,n,r){if(t===`beforeInit`&&(this._init=this._createDescriptors(e,!0),this._notify(this._init,e,`install`)),this._init===void 0)return;let i=r?this._descriptors(e).filter(r):this._descriptors(e),a=this._notify(i,e,t,n);return t===`afterDestroy`&&(this._notify(i,e,`stop`),this._notify(this._init,e,`uninstall`),this._init=void 0),a}_notify(e,t,n,r){r||={};for(let i of e){let e=i.plugin,a=e[n];if(J(a,[t,r,i.options],e)===!1&&r.cancelable)return!1}return!0}invalidate(){U(this._cache)||(this._oldCache=this._cache,this._cache=void 0)}_descriptors(e){if(this._cache)return this._cache;let t=this._cache=this._createDescriptors(e);return this._notifyStateChanges(e),t}_createDescriptors(e,t){let n=e&&e.config,r=q(n.options&&n.options.plugins,{}),i=Xu(n);return r===!1&&!t?[]:Qu(e,i,r,t)}_notifyStateChanges(e){let t=this._oldCache||[],n=this._cache,r=(e,t)=>e.filter(e=>!t.some(t=>e.plugin.id===t.plugin.id));this._notify(r(t,n),e,`stop`),this._notify(r(n,t),e,`start`)}};function Xu(e){let t={},n=[],r=Object.keys(Ju.plugins.items);for(let e=0;e<r.length;e++)n.push(Ju.getPlugin(r[e]));let i=e.plugins||[];for(let e=0;e<i.length;e++){let r=i[e];n.indexOf(r)===-1&&(n.push(r),t[r.id]=!0)}return{plugins:n,localIds:t}}function Zu(e,t){return!t&&e===!1?null:e===!0?{}:e}function Qu(e,{plugins:t,localIds:n},r,i){let a=[],o=e.getContext();for(let s of t){let t=s.id,c=Zu(r[t],i);c!==null&&a.push({plugin:s,options:$u(e.config,{plugin:s,local:n[t]},c,o)})}return a}function $u(e,{plugin:t,local:n},r,i){let a=e.pluginScopeKeys(t),o=e.getOptionScopes(r,a);return n&&t.defaults&&o.push(t.defaults),e.createResolver(o,i,[``],{scriptable:!1,indexable:!1,allKeys:!0})}function ed(e,t){let n=Z.datasets[e]||{};return((t.datasets||{})[e]||{}).indexAxis||t.indexAxis||n.indexAxis||`x`}function td(e,t){let n=e;return e===`_index_`?n=t:e===`_value_`&&(n=t===`x`?`y`:`x`),n}function nd(e,t){return e===t?`_index_`:`_value_`}function rd(e){if(e===`x`||e===`y`||e===`r`)return e}function id(e){if(e===`top`||e===`bottom`)return`x`;if(e===`left`||e===`right`)return`y`}function ad(e,...t){if(rd(e))return e;for(let n of t){let t=n.axis||id(n.position)||e.length>1&&rd(e[0].toLowerCase());if(t)return t}throw Error(`Cannot determine type of '${e}' axis. Please provide 'axis' or 'position' option.`)}function od(e,t,n){if(n[t+`AxisID`]===e)return{axis:t}}function sd(e,t){if(t.data&&t.data.datasets){let n=t.data.datasets.filter(t=>t.xAxisID===e||t.yAxisID===e);if(n.length)return od(e,`x`,n[0])||od(e,`y`,n[0])}return{}}function cd(e,t){let n=ys[e.type]||{scales:{}},r=t.scales||{},i=ed(e.type,t),a=Object.create(null);return Object.keys(r).forEach(t=>{let o=r[t];if(!G(o))return console.error(`Invalid scale configuration for scale: ${t}`);if(o._proxy)return console.warn(`Ignoring resolver passed as options for scale: ${t}`);let s=ad(t,o,sd(t,e),Z.scales[o.type]),c=nd(s,i),l=n.scales||{};a[t]=io(Object.create(null),[{axis:s},o,l[s],l[c]])}),e.data.datasets.forEach(n=>{let i=n.type||e.type,o=n.indexAxis||ed(i,t),s=(ys[i]||{}).scales||{};Object.keys(s).forEach(e=>{let t=td(e,o),i=n[t+`AxisID`]||t;a[i]=a[i]||Object.create(null),io(a[i],[{axis:t},r[i],s[e]])})}),Object.keys(a).forEach(e=>{let t=a[e];io(t,[Z.scales[t.type],Z.scale])}),a}function ld(e){let t=e.options||={};t.plugins=q(t.plugins,{}),t.scales=cd(e,t)}function ud(e){return e||={},e.datasets=e.datasets||[],e.labels=e.labels||[],e}function dd(e){return e||={},e.data=ud(e.data),ld(e),e}var fd=new Map,pd=new Set;function md(e,t){let n=fd.get(e);return n||(n=t(),fd.set(e,n),pd.add(n)),n}var hd=(e,t,n)=>{let r=lo(t,n);r!==void 0&&e.add(r)},gd=class{constructor(e){this._config=dd(e),this._scopeCache=new Map,this._resolverCache=new Map}get platform(){return this._config.platform}get type(){return this._config.type}set type(e){this._config.type=e}get data(){return this._config.data}set data(e){this._config.data=ud(e)}get options(){return this._config.options}set options(e){this._config.options=e}get plugins(){return this._config.plugins}update(){let e=this._config;this.clearCache(),ld(e)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(e){return md(e,()=>[[`datasets.${e}`,``]])}datasetAnimationScopeKeys(e,t){return md(`${e}.transition.${t}`,()=>[[`datasets.${e}.transitions.${t}`,`transitions.${t}`],[`datasets.${e}`,``]])}datasetElementScopeKeys(e,t){return md(`${e}-${t}`,()=>[[`datasets.${e}.elements.${t}`,`datasets.${e}`,`elements.${t}`,``]])}pluginScopeKeys(e){let t=e.id,n=this.type;return md(`${n}-plugin-${t}`,()=>[[`plugins.${t}`,...e.additionalOptionScopes||[]]])}_cachedScopes(e,t){let n=this._scopeCache,r=n.get(e);return(!r||t)&&(r=new Map,n.set(e,r)),r}getOptionScopes(e,t,n){let{options:r,type:i}=this,a=this._cachedScopes(e,n),o=a.get(t);if(o)return o;let s=new Set;t.forEach(t=>{e&&(s.add(e),t.forEach(t=>hd(s,e,t))),t.forEach(e=>hd(s,r,e)),t.forEach(e=>hd(s,ys[i]||{},e)),t.forEach(e=>hd(s,Z,e)),t.forEach(e=>hd(s,bs,e))});let c=Array.from(s);return c.length===0&&c.push(Object.create(null)),pd.has(t)&&a.set(t,c),c}chartOptionScopes(){let{options:e,type:t}=this;return[e,ys[t]||{},Z.datasets[t]||{},{type:t},Z,bs]}resolveNamedOptions(e,t,n,r=[``]){let i={$shared:!0},{resolver:a,subPrefixes:o}=_d(this._resolverCache,e,r),s=a;if(yd(a,t)){i.$shared=!1,n=po(n)?n():n;let t=this.createResolver(e,n,o);s=Ys(a,n,t)}for(let e of t)i[e]=s[e];return i}createResolver(e,t,n=[``],r){let{resolver:i}=_d(this._resolverCache,e,n);return G(t)?Ys(i,t,void 0,r):i}};function _d(e,t,n){let r=e.get(t);r||(r=new Map,e.set(t,r));let i=n.join(),a=r.get(i);return a||(a={resolver:Js(t,n),subPrefixes:n.filter(e=>!e.toLowerCase().includes(`hover`))},r.set(i,a)),a}var vd=e=>G(e)&&Object.getOwnPropertyNames(e).some(t=>po(e[t]));function yd(e,t){let{isScriptable:n,isIndexable:r}=Xs(e);for(let i of t){let t=n(i),a=r(i),o=(a||t)&&e[i];if(t&&(po(o)||vd(o))||a&&W(o))return!0}return!1}var bd=`4.5.1`,xd=[`top`,`bottom`,`left`,`right`,`chartArea`];function Sd(e,t){return e===`top`||e===`bottom`||xd.indexOf(e)===-1&&t===`x`}function Cd(e,t){return function(n,r){return n[e]===r[e]?n[t]-r[t]:n[e]-r[e]}}function wd(e){let t=e.chart,n=t.options.animation;t.notifyPlugins(`afterRender`),J(n&&n.onComplete,[e],t)}function Td(e){let t=e.chart,n=t.options.animation;J(n&&n.onProgress,[e],t)}function Ed(e){return pc()&&typeof e==`string`?e=document.getElementById(e):e&&e.length&&(e=e[0]),e&&e.canvas&&(e=e.canvas),e}var Dd={},Od=e=>{let t=Ed(e);return Object.values(Dd).filter(e=>e.canvas===t).pop()};function kd(e,t,n){let r=Object.keys(e);for(let i of r){let r=+i;if(r>=t){let a=e[i];delete e[i],(n>0||r>t)&&(e[r+n]=a)}}}function Ad(e,t,n,r){return!n||e.type===`mouseout`?null:r?t:e}var jd=class{static defaults=Z;static instances=Dd;static overrides=ys;static registry=Ju;static version=bd;static getChart=Od;static register(...e){Ju.add(...e),Md()}static unregister(...e){Ju.remove(...e),Md()}constructor(e,t){let n=this.config=new gd(t),r=Ed(e),i=Od(r);if(i)throw Error(`Canvas is already in use. Chart with ID '`+i.id+`' must be destroyed before the canvas with ID '`+i.canvas.id+`' can be reused.`);let a=n.createResolver(n.chartOptionScopes(),this.getContext());this.platform=new(n.platform||(Su(r))),this.platform.updateConfig(n);let o=this.platform.acquireContext(r,a.aspectRatio),s=o&&o.canvas,c=s&&s.height,l=s&&s.width;if(this.id=Xa(),this.ctx=o,this.canvas=s,this.width=l,this.height=c,this._options=a,this._aspectRatio=this.aspectRatio,this._layers=[],this._metasets=[],this._stacks=void 0,this.boxes=[],this.currentDevicePixelRatio=void 0,this.chartArea=void 0,this._active=[],this._lastEvent=void 0,this._listeners={},this._responsiveListeners=void 0,this._sortedMetasets=[],this.scales={},this._plugins=new Yu,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=Zo(e=>this.update(e),a.resizeDelay||0),this._dataChanges=[],Dd[this.id]=this,!o||!s){console.error(`Failed to create chart: can't acquire context from the given item`);return}Lc.listen(this,`complete`,wd),Lc.listen(this,`progress`,Td),this._initialize(),this.attached&&this.update()}get aspectRatio(){let{options:{aspectRatio:e,maintainAspectRatio:t},width:n,height:r,_aspectRatio:i}=this;return U(e)?t&&i?i:r?n/r:null:e}get data(){return this.config.data}set data(e){this.config.data=e}get options(){return this._options}set options(e){this.config.options=e}get registry(){return Ju}_initialize(){return this.notifyPlugins(`beforeInit`),this.options.responsive?this.resize():Ec(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins(`afterInit`),this}clear(){return Ds(this.canvas,this.ctx),this}stop(){return Lc.stop(this),this}resize(e,t){Lc.running(this)?this._resizeBeforeDraw={width:e,height:t}:this._resize(e,t)}_resize(e,t){let n=this.options,r=this.canvas,i=n.maintainAspectRatio&&this.aspectRatio,a=this.platform.getMaximumSize(r,e,t,i),o=n.devicePixelRatio||this.platform.getDevicePixelRatio(),s=this.width?`resize`:`attach`;this.width=a.width,this.height=a.height,this._aspectRatio=this.aspectRatio,Ec(this,o,!0)&&(this.notifyPlugins(`resize`,{size:a}),J(n.onResize,[this,a],this),this.attached&&this._doResize(s)&&this.render())}ensureScalesHaveIDs(){Y(this.options.scales||{},(e,t)=>{e.id=t})}buildOrUpdateScales(){let e=this.options,t=e.scales,n=this.scales,r=Object.keys(n).reduce((e,t)=>(e[t]=!1,e),{}),i=[];t&&(i=i.concat(Object.keys(t).map(e=>{let n=t[e],r=ad(e,n),i=r===`r`,a=r===`x`;return{options:n,dposition:i?`chartArea`:a?`bottom`:`left`,dtype:i?`radialLinear`:a?`category`:`linear`}}))),Y(i,t=>{let i=t.options,a=i.id,o=ad(a,i),s=q(i.type,t.dtype);(i.position===void 0||Sd(i.position,o)!==Sd(t.dposition))&&(i.position=t.dposition),r[a]=!0;let c=null;a in n&&n[a].type===s?c=n[a]:(c=new(Ju.getScale(s))({id:a,type:s,ctx:this.ctx,chart:this}),n[c.id]=c),c.init(i,e)}),Y(r,(e,t)=>{e||delete n[t]}),Y(n,e=>{$l.configure(this,e,e.options),$l.addBox(this,e)})}_updateMetasets(){let e=this._metasets,t=this.data.datasets.length,n=e.length;if(e.sort((e,t)=>e.index-t.index),n>t){for(let e=t;e<n;++e)this._destroyDatasetMeta(e);e.splice(t,n-t)}this._sortedMetasets=e.slice(0).sort(Cd(`order`,`index`))}_removeUnreferencedMetasets(){let{_metasets:e,data:{datasets:t}}=this;e.length>t.length&&delete this._stacks,e.forEach((e,n)=>{t.filter(t=>t===e._dataset).length===0&&this._destroyDatasetMeta(n)})}buildOrUpdateControllers(){let e=[],t=this.data.datasets,n,r;for(this._removeUnreferencedMetasets(),n=0,r=t.length;n<r;n++){let r=t[n],i=this.getDatasetMeta(n),a=r.type||this.config.type;if(i.type&&i.type!==a&&(this._destroyDatasetMeta(n),i=this.getDatasetMeta(n)),i.type=a,i.indexAxis=r.indexAxis||ed(a,this.options),i.order=r.order||0,i.index=n,i.label=``+r.label,i.visible=this.isDatasetVisible(n),i.controller)i.controller.updateIndex(n),i.controller.linkScales();else{let t=Ju.getController(a),{datasetElementType:r,dataElementType:o}=Z.datasets[a];Object.assign(t,{dataElementType:Ju.getElement(o),datasetElementType:r&&Ju.getElement(r)}),i.controller=new t(this,n),e.push(i.controller)}}return this._updateMetasets(),e}_resetElements(){Y(this.data.datasets,(e,t)=>{this.getDatasetMeta(t).controller.reset()},this)}reset(){this._resetElements(),this.notifyPlugins(`reset`)}update(e){let t=this.config;t.update();let n=this._options=t.createResolver(t.chartOptionScopes(),this.getContext()),r=this._animationsDisabled=!n.animation;if(this._updateScales(),this._checkEventBindings(),this._updateHiddenIndices(),this._plugins.invalidate(),this.notifyPlugins(`beforeUpdate`,{mode:e,cancelable:!0})===!1)return;let i=this.buildOrUpdateControllers();this.notifyPlugins(`beforeElementsUpdate`);let a=0;for(let e=0,t=this.data.datasets.length;e<t;e++){let{controller:t}=this.getDatasetMeta(e),n=!r&&i.indexOf(t)===-1;t.buildOrUpdateElements(n),a=Math.max(+t.getMaxOverflow(),a)}a=this._minPadding=n.layout.autoPadding?a:0,this._updateLayout(a),r||Y(i,e=>{e.reset()}),this._updateDatasets(e),this.notifyPlugins(`afterUpdate`,{mode:e}),this._layers.sort(Cd(`z`,`_idx`));let{_active:o,_lastEvent:s}=this;s?this._eventHandler(s,!0):o.length&&this._updateHoverStyles(o,o,!0),this.render()}_updateScales(){Y(this.scales,e=>{$l.removeBox(this,e)}),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){let e=this.options;(!mo(new Set(Object.keys(this._listeners)),new Set(e.events))||!!this._responsiveListeners!==e.responsive)&&(this.unbindEvents(),this.bindEvents())}_updateHiddenIndices(){let{_hiddenIndices:e}=this,t=this._getUniformDataChanges()||[];for(let{method:n,start:r,count:i}of t)kd(e,r,n===`_removeElements`?-i:i)}_getUniformDataChanges(){let e=this._dataChanges;if(!e||!e.length)return;this._dataChanges=[];let t=this.data.datasets.length,n=t=>new Set(e.filter(e=>e[0]===t).map((e,t)=>t+`,`+e.splice(1).join(`,`))),r=n(0);for(let e=1;e<t;e++)if(!mo(r,n(e)))return;return Array.from(r).map(e=>e.split(`,`)).map(e=>({method:e[1],start:+e[2],count:+e[3]}))}_updateLayout(e){if(this.notifyPlugins(`beforeLayout`,{cancelable:!0})===!1)return;$l.update(this,this.width,this.height,e);let t=this.chartArea,n=t.width<=0||t.height<=0;this._layers=[],Y(this.boxes,e=>{n&&e.position===`chartArea`||(e.configure&&e.configure(),this._layers.push(...e._layers()))},this),this._layers.forEach((e,t)=>{e._idx=t}),this.notifyPlugins(`afterLayout`)}_updateDatasets(e){if(this.notifyPlugins(`beforeDatasetsUpdate`,{mode:e,cancelable:!0})!==!1){for(let e=0,t=this.data.datasets.length;e<t;++e)this.getDatasetMeta(e).controller.configure();for(let t=0,n=this.data.datasets.length;t<n;++t)this._updateDataset(t,po(e)?e({datasetIndex:t}):e);this.notifyPlugins(`afterDatasetsUpdate`,{mode:e})}}_updateDataset(e,t){let n=this.getDatasetMeta(e),r={meta:n,index:e,mode:t,cancelable:!0};this.notifyPlugins(`beforeDatasetUpdate`,r)!==!1&&(n.controller._update(t),r.cancelable=!1,this.notifyPlugins(`afterDatasetUpdate`,r))}render(){this.notifyPlugins(`beforeRender`,{cancelable:!0})!==!1&&(Lc.has(this)?this.attached&&!Lc.running(this)&&Lc.start(this):(this.draw(),wd({chart:this})))}draw(){let e;if(this._resizeBeforeDraw){let{width:e,height:t}=this._resizeBeforeDraw;this._resizeBeforeDraw=null,this._resize(e,t)}if(this.clear(),this.width<=0||this.height<=0||this.notifyPlugins(`beforeDraw`,{cancelable:!0})===!1)return;let t=this._layers;for(e=0;e<t.length&&t[e].z<=0;++e)t[e].draw(this.chartArea);for(this._drawDatasets();e<t.length;++e)t[e].draw(this.chartArea);this.notifyPlugins(`afterDraw`)}_getSortedDatasetMetas(e){let t=this._sortedMetasets,n=[],r,i;for(r=0,i=t.length;r<i;++r){let i=t[r];(!e||i.visible)&&n.push(i)}return n}getSortedVisibleDatasetMetas(){return this._getSortedDatasetMetas(!0)}_drawDatasets(){if(this.notifyPlugins(`beforeDatasetsDraw`,{cancelable:!0})===!1)return;let e=this.getSortedVisibleDatasetMetas();for(let t=e.length-1;t>=0;--t)this._drawDataset(e[t]);this.notifyPlugins(`afterDatasetsDraw`)}_drawDataset(e){let t=this.ctx,n={meta:e,index:e.index,cancelable:!0},r=Ic(this,e);this.notifyPlugins(`beforeDatasetDraw`,n)!==!1&&(r&&js(t,r),e.controller.draw(),r&&Ms(t),n.cancelable=!1,this.notifyPlugins(`afterDatasetDraw`,n))}isPointInArea(e){return As(e,this.chartArea,this._minPadding)}getElementsAtEventForMode(e,t,n,r){let i=Il.modes[t];return typeof i==`function`?i(this,e,n,r):[]}getDatasetMeta(e){let t=this.data.datasets[e],n=this._metasets,r=n.filter(e=>e&&e._dataset===t).pop();return r||(r={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:t&&t.order||0,index:e,_dataset:t,_parsed:[],_sorted:!1},n.push(r)),r}getContext(){return this.$context||=qs(null,{chart:this,type:`chart`})}getVisibleDatasetCount(){return this.getSortedVisibleDatasetMetas().length}isDatasetVisible(e){let t=this.data.datasets[e];if(!t)return!1;let n=this.getDatasetMeta(e);return typeof n.hidden==`boolean`?!n.hidden:!t.hidden}setDatasetVisibility(e,t){let n=this.getDatasetMeta(e);n.hidden=!t}toggleDataVisibility(e){this._hiddenIndices[e]=!this._hiddenIndices[e]}getDataVisibility(e){return!this._hiddenIndices[e]}_updateVisibility(e,t,n){let r=n?`show`:`hide`,i=this.getDatasetMeta(e),a=i.controller._resolveAnimations(void 0,r);fo(t)?(i.data[t].hidden=!n,this.update()):(this.setDatasetVisibility(e,n),a.update(i,{visible:n}),this.update(t=>t.datasetIndex===e?r:void 0))}hide(e,t){this._updateVisibility(e,t,!1)}show(e,t){this._updateVisibility(e,t,!0)}_destroyDatasetMeta(e){let t=this._metasets[e];t&&t.controller&&t.controller._destroy(),delete this._metasets[e]}_stop(){let e,t;for(this.stop(),Lc.remove(this),e=0,t=this.data.datasets.length;e<t;++e)this._destroyDatasetMeta(e)}destroy(){this.notifyPlugins(`beforeDestroy`);let{canvas:e,ctx:t}=this;this._stop(),this.config.clearCache(),e&&(this.unbindEvents(),Ds(e,t),this.platform.releaseContext(t),this.canvas=null,this.ctx=null),delete Dd[this.id],this.notifyPlugins(`afterDestroy`)}toBase64Image(...e){return this.canvas.toDataURL(...e)}bindEvents(){this.bindUserEvents(),this.options.responsive?this.bindResponsiveEvents():this.attached=!0}bindUserEvents(){let e=this._listeners,t=this.platform,n=(n,r)=>{t.addEventListener(this,n,r),e[n]=r},r=(e,t,n)=>{e.offsetX=t,e.offsetY=n,this._eventHandler(e)};Y(this.options.events,e=>n(e,r))}bindResponsiveEvents(){this._responsiveListeners||={};let e=this._responsiveListeners,t=this.platform,n=(n,r)=>{t.addEventListener(this,n,r),e[n]=r},r=(n,r)=>{e[n]&&(t.removeEventListener(this,n,r),delete e[n])},i=(e,t)=>{this.canvas&&this.resize(e,t)},a,o=()=>{r(`attach`,o),this.attached=!0,this.resize(),n(`resize`,i),n(`detach`,a)};a=()=>{this.attached=!1,r(`resize`,i),this._stop(),this._resize(0,0),n(`attach`,o)},t.isAttached(this.canvas)?o():a()}unbindEvents(){Y(this._listeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._listeners={},Y(this._responsiveListeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._responsiveListeners=void 0}updateHoverStyle(e,t,n){let r=n?`set`:`remove`,i,a,o,s;for(t===`dataset`&&(i=this.getDatasetMeta(e[0].datasetIndex),i.controller[`_`+r+`DatasetHoverStyle`]()),o=0,s=e.length;o<s;++o){a=e[o];let t=a&&this.getDatasetMeta(a.datasetIndex).controller;t&&t[r+`HoverStyle`](a.element,a.datasetIndex,a.index)}}getActiveElements(){return this._active||[]}setActiveElements(e){let t=this._active||[],n=e.map(({datasetIndex:e,index:t})=>{let n=this.getDatasetMeta(e);if(!n)throw Error(`No dataset found at index `+e);return{datasetIndex:e,element:n.data[t],index:t}});$a(n,t)||(this._active=n,this._lastEvent=null,this._updateHoverStyles(n,t))}notifyPlugins(e,t,n){return this._plugins.notify(this,e,t,n)}isPluginEnabled(e){return this._plugins._cache.filter(t=>t.plugin.id===e).length===1}_updateHoverStyles(e,t,n){let r=this.options.hover,i=(e,t)=>e.filter(e=>!t.some(t=>e.datasetIndex===t.datasetIndex&&e.index===t.index)),a=i(t,e),o=n?e:i(e,t);a.length&&this.updateHoverStyle(a,r.mode,!1),o.length&&r.mode&&this.updateHoverStyle(o,r.mode,!0)}_eventHandler(e,t){let n={event:e,replay:t,cancelable:!0,inChartArea:this.isPointInArea(e)},r=t=>(t.options.events||this.options.events).includes(e.native.type);if(this.notifyPlugins(`beforeEvent`,n,r)===!1)return;let i=this._handleEvent(e,t,n.inChartArea);return n.cancelable=!1,this.notifyPlugins(`afterEvent`,n,r),(i||n.changed)&&this.render(),this}_handleEvent(e,t,n){let{_active:r=[],options:i}=this,a=t,o=this._getActiveElements(e,r,n,a),s=ho(e),c=Ad(e,this._lastEvent,n,s);n&&(this._lastEvent=null,J(i.onHover,[e,o,this],this),s&&J(i.onClick,[e,o,this],this));let l=!$a(o,r);return(l||t)&&(this._active=o,this._updateHoverStyles(o,r,t)),this._lastEvent=c,l}_getActiveElements(e,t,n,r){if(e.type===`mouseout`)return[];if(!n)return t;let i=this.options.hover;return this.getElementsAtEventForMode(e,i.mode,i,r)}};function Md(){return Y(jd.instances,e=>e._plugins.invalidate())}function Nd(e,t){let{x:n,y:r,base:i,width:a,height:o}=e.getProps([`x`,`y`,`base`,`width`,`height`],t),s,c,l,u,d;return e.horizontal?(d=o/2,s=Math.min(n,i),c=Math.max(n,i),l=r-d,u=r+d):(d=a/2,s=n-d,c=n+d,l=Math.min(r,i),u=Math.max(r,i)),{left:s,top:l,right:c,bottom:u}}function Pd(e,t,n,r){return e?0:Ro(t,n,r)}function Fd(e,t,n){let r=e.options.borderWidth,i=e.borderSkipped,a=Us(r);return{t:Pd(i.top,a.top,0,n),r:Pd(i.right,a.right,0,t),b:Pd(i.bottom,a.bottom,0,n),l:Pd(i.left,a.left,0,t)}}function Id(e,t,n){let{enableBorderRadius:r}=e.getProps([`enableBorderRadius`]),i=e.options.borderRadius,a=Ws(i),o=Math.min(t,n),s=e.borderSkipped,c=r||G(i);return{topLeft:Pd(!c||s.top||s.left,a.topLeft,0,o),topRight:Pd(!c||s.top||s.right,a.topRight,0,o),bottomLeft:Pd(!c||s.bottom||s.left,a.bottomLeft,0,o),bottomRight:Pd(!c||s.bottom||s.right,a.bottomRight,0,o)}}function Ld(e){let t=Nd(e),n=t.right-t.left,r=t.bottom-t.top,i=Fd(e,n/2,r/2),a=Id(e,n/2,r/2);return{outer:{x:t.left,y:t.top,w:n,h:r,radius:a},inner:{x:t.left+i.l,y:t.top+i.t,w:n-i.l-i.r,h:r-i.t-i.b,radius:{topLeft:Math.max(0,a.topLeft-Math.max(i.t,i.l)),topRight:Math.max(0,a.topRight-Math.max(i.t,i.r)),bottomLeft:Math.max(0,a.bottomLeft-Math.max(i.b,i.l)),bottomRight:Math.max(0,a.bottomRight-Math.max(i.b,i.r))}}}}function Rd(e,t,n,r){let i=t===null,a=n===null,o=e&&!(i&&a)&&Nd(e,r);return o&&(i||Bo(t,o.left,o.right))&&(a||Bo(n,o.top,o.bottom))}function zd(e){return e.topLeft||e.topRight||e.bottomLeft||e.bottomRight}function Bd(e,t){e.rect(t.x,t.y,t.w,t.h)}function Vd(e,t,n={}){let r=e.x===n.x?0:-t,i=e.y===n.y?0:-t,a=(e.x+e.w===n.x+n.w?0:t)-r,o=(e.y+e.h===n.y+n.h?0:t)-i;return{x:e.x+r,y:e.y+i,w:e.w+a,h:e.h+o,radius:e.radius}}var Hd=class extends Cu{static id=`bar`;static defaults={borderSkipped:`start`,borderWidth:0,borderRadius:0,inflateAmount:`auto`,pointStyle:void 0};static defaultRoutes={backgroundColor:`backgroundColor`,borderColor:`borderColor`};constructor(e){super(),this.options=void 0,this.horizontal=void 0,this.base=void 0,this.width=void 0,this.height=void 0,this.inflateAmount=void 0,e&&Object.assign(this,e)}draw(e){let{inflateAmount:t,options:{borderColor:n,backgroundColor:r}}=this,{inner:i,outer:a}=Ld(this),o=zd(a.radius)?Ls:Bd;e.save(),(a.w!==i.w||a.h!==i.h)&&(e.beginPath(),o(e,Vd(a,t,i)),e.clip(),o(e,Vd(i,-t,a)),e.fillStyle=n,e.fill(`evenodd`)),e.beginPath(),o(e,Vd(i,t)),e.fillStyle=r,e.fill(),e.restore()}inRange(e,t,n){return Rd(this,e,t,n)}inXRange(e,t){return Rd(this,e,null,t)}inYRange(e,t){return Rd(this,null,e,t)}getCenterPoint(e){let{x:t,y:n,base:r,horizontal:i}=this.getProps([`x`,`y`,`base`,`horizontal`],e);return{x:i?(t+r)/2:t,y:i?n:(n+r)/2}}getRange(e){return e===`x`?this.width/2:this.height/2}},Ud=(e,t)=>{let{boxHeight:n=t,boxWidth:r=t}=e;return e.usePointStyle&&(n=Math.min(n,t),r=e.pointStyleWidth||Math.min(r,t)),{boxWidth:r,boxHeight:n,itemHeight:Math.max(t,n)}},Wd=(e,t)=>e!==null&&t!==null&&e.datasetIndex===t.datasetIndex&&e.index===t.index,Gd=class extends Cu{constructor(e){super(),this._added=!1,this.legendHitBoxes=[],this._hoveredItem=null,this.doughnutMode=!1,this.chart=e.chart,this.options=e.options,this.ctx=e.ctx,this.legendItems=void 0,this.columnSizes=void 0,this.lineWidths=void 0,this.maxHeight=void 0,this.maxWidth=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.height=void 0,this.width=void 0,this._margins=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(e,t,n){this.maxWidth=e,this.maxHeight=t,this._margins=n,this.setDimensions(),this.buildLabels(),this.fit()}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=this._margins.left,this.right=this.width):(this.height=this.maxHeight,this.top=this._margins.top,this.bottom=this.height)}buildLabels(){let e=this.options.labels||{},t=J(e.generateLabels,[this.chart],this)||[];e.filter&&(t=t.filter(t=>e.filter(t,this.chart.data))),e.sort&&(t=t.sort((t,n)=>e.sort(t,n,this.chart.data))),this.options.reverse&&t.reverse(),this.legendItems=t}fit(){let{options:e,ctx:t}=this;if(!e.display){this.width=this.height=0;return}let n=e.labels,r=$(n.font),i=r.size,a=this._computeTitleHeight(),{boxWidth:o,itemHeight:s}=Ud(n,i),c,l;t.font=r.string,this.isHorizontal()?(c=this.maxWidth,l=this._fitRows(a,i,o,s)+10):(l=this.maxHeight,c=this._fitCols(a,r,o,s)+10),this.width=Math.min(c,e.maxWidth||this.maxWidth),this.height=Math.min(l,e.maxHeight||this.maxHeight)}_fitRows(e,t,n,r){let{ctx:i,maxWidth:a,options:{labels:{padding:o}}}=this,s=this.legendHitBoxes=[],c=this.lineWidths=[0],l=r+o,u=e;i.textAlign=`left`,i.textBaseline=`middle`;let d=-1,f=-l;return this.legendItems.forEach((e,p)=>{let m=n+t/2+i.measureText(e.text).width;(p===0||c[c.length-1]+m+2*o>a)&&(u+=l,c[c.length-(p>0?0:1)]=0,f+=l,d++),s[p]={left:0,top:f,row:d,width:m,height:r},c[c.length-1]+=m+o}),u}_fitCols(e,t,n,r){let{ctx:i,maxHeight:a,options:{labels:{padding:o}}}=this,s=this.legendHitBoxes=[],c=this.columnSizes=[],l=a-e,u=o,d=0,f=0,p=0,m=0;return this.legendItems.forEach((e,a)=>{let{itemWidth:h,itemHeight:g}=Kd(n,t,i,e,r);a>0&&f+g+2*o>l&&(u+=d+o,c.push({width:d,height:f}),p+=d+o,m++,d=f=0),s[a]={left:p,top:f,col:m,width:h,height:g},d=Math.max(d,h),f+=g+o}),u+=d,c.push({width:d,height:f}),u}adjustHitBoxes(){if(!this.options.display)return;let e=this._computeTitleHeight(),{legendHitBoxes:t,options:{align:n,labels:{padding:r},rtl:i}}=this,a=jc(i,this.left,this.width);if(this.isHorizontal()){let i=0,o=$o(n,this.left+r,this.right-this.lineWidths[i]);for(let s of t)i!==s.row&&(i=s.row,o=$o(n,this.left+r,this.right-this.lineWidths[i])),s.top+=this.top+e+r,s.left=a.leftForLtr(a.x(o),s.width),o+=s.width+r}else{let i=0,o=$o(n,this.top+e+r,this.bottom-this.columnSizes[i].height);for(let s of t)s.col!==i&&(i=s.col,o=$o(n,this.top+e+r,this.bottom-this.columnSizes[i].height)),s.top=o,s.left+=this.left+r,s.left=a.leftForLtr(a.x(s.left),s.width),o+=s.height+r}}isHorizontal(){return this.options.position===`top`||this.options.position===`bottom`}draw(){if(this.options.display){let e=this.ctx;js(e,this),this._draw(),Ms(e)}}_draw(){let{options:e,columnSizes:t,lineWidths:n,ctx:r}=this,{align:i,labels:a}=e,o=Z.color,s=jc(e.rtl,this.left,this.width),c=$(a.font),{padding:l}=a,u=c.size,d=u/2,f;this.drawTitle(),r.textAlign=s.textAlign(`left`),r.textBaseline=`middle`,r.lineWidth=.5,r.font=c.string;let{boxWidth:p,boxHeight:m,itemHeight:h}=Ud(a,u),g=function(e,t,n){if(isNaN(p)||p<=0||isNaN(m)||m<0)return;r.save();let i=q(n.lineWidth,1);if(r.fillStyle=q(n.fillStyle,o),r.lineCap=q(n.lineCap,`butt`),r.lineDashOffset=q(n.lineDashOffset,0),r.lineJoin=q(n.lineJoin,`miter`),r.lineWidth=i,r.strokeStyle=q(n.strokeStyle,o),r.setLineDash(q(n.lineDash,[])),a.usePointStyle){let o={radius:m*Math.SQRT2/2,pointStyle:n.pointStyle,rotation:n.rotation,borderWidth:i},c=s.xPlus(e,p/2),l=t+d;ks(r,o,c,l,a.pointStyleWidth&&p)}else{let a=t+Math.max((u-m)/2,0),o=s.leftForLtr(e,p),c=Ws(n.borderRadius);r.beginPath(),Object.values(c).some(e=>e!==0)?Ls(r,{x:o,y:a,w:p,h:m,radius:c}):r.rect(o,a,p,m),r.fill(),i!==0&&r.stroke()}r.restore()},_=function(e,t,n){Is(r,n.text,e,t+h/2,c,{strikethrough:n.hidden,textAlign:s.textAlign(n.textAlign)})},v=this.isHorizontal(),y=this._computeTitleHeight();f=v?{x:$o(i,this.left+l,this.right-n[0]),y:this.top+l+y,line:0}:{x:this.left+l,y:$o(i,this.top+y+l,this.bottom-t[0].height),line:0},Mc(this.ctx,e.textDirection);let b=h+l;this.legendItems.forEach((o,u)=>{r.strokeStyle=o.fontColor,r.fillStyle=o.fontColor;let m=r.measureText(o.text).width,h=s.textAlign(o.textAlign||=a.textAlign),x=p+d+m,S=f.x,C=f.y;s.setWidth(this.width),v?u>0&&S+x+l>this.right&&(C=f.y+=b,f.line++,S=f.x=$o(i,this.left+l,this.right-n[f.line])):u>0&&C+b>this.bottom&&(S=f.x=S+t[f.line].width+l,f.line++,C=f.y=$o(i,this.top+y+l,this.bottom-t[f.line].height));let w=s.x(S);if(g(w,C,o),S=es(h,S+p+d,v?S+x:this.right,e.rtl),_(s.x(S),C,o),v)f.x+=x+l;else if(typeof o.text!=`string`){let e=c.lineHeight;f.y+=Yd(o,e)+l}else f.y+=b}),Nc(this.ctx,e.textDirection)}drawTitle(){let e=this.options,t=e.title,n=$(t.font),r=Q(t.padding);if(!t.display)return;let i=jc(e.rtl,this.left,this.width),a=this.ctx,o=t.position,s=n.size/2,c=r.top+s,l,u=this.left,d=this.width;if(this.isHorizontal())d=Math.max(...this.lineWidths),l=this.top+c,u=$o(e.align,u,this.right-d);else{let t=this.columnSizes.reduce((e,t)=>Math.max(e,t.height),0);l=c+$o(e.align,this.top,this.bottom-t-e.labels.padding-this._computeTitleHeight())}let f=$o(o,u,u+d);a.textAlign=i.textAlign(Qo(o)),a.textBaseline=`middle`,a.strokeStyle=t.color,a.fillStyle=t.color,a.font=n.string,Is(a,t.text,f,l,n)}_computeTitleHeight(){let e=this.options.title,t=$(e.font),n=Q(e.padding);return e.display?t.lineHeight+n.height:0}_getLegendItemAt(e,t){let n,r,i;if(Bo(e,this.left,this.right)&&Bo(t,this.top,this.bottom)){for(i=this.legendHitBoxes,n=0;n<i.length;++n)if(r=i[n],Bo(e,r.left,r.left+r.width)&&Bo(t,r.top,r.top+r.height))return this.legendItems[n]}return null}handleEvent(e){let t=this.options;if(!Xd(e.type,t))return;let n=this._getLegendItemAt(e.x,e.y);if(e.type===`mousemove`||e.type===`mouseout`){let r=this._hoveredItem,i=Wd(r,n);r&&!i&&J(t.onLeave,[e,r,this],this),this._hoveredItem=n,n&&!i&&J(t.onHover,[e,n,this],this)}else n&&J(t.onClick,[e,n,this],this)}};function Kd(e,t,n,r,i){return{itemWidth:qd(r,e,t,n),itemHeight:Jd(i,r,t.lineHeight)}}function qd(e,t,n,r){let i=e.text;return i&&typeof i!=`string`&&(i=i.reduce((e,t)=>e.length>t.length?e:t)),t+n.size/2+r.measureText(i).width}function Jd(e,t,n){let r=e;return typeof t.text!=`string`&&(r=Yd(t,n)),r}function Yd(e,t){return t*(e.text?e.text.length:0)}function Xd(e,t){return!!((e===`mousemove`||e===`mouseout`)&&(t.onHover||t.onLeave)||t.onClick&&(e===`click`||e===`mouseup`))}var Zd={id:`legend`,_element:Gd,start(e,t,n){let r=e.legend=new Gd({ctx:e.ctx,options:n,chart:e});$l.configure(e,r,n),$l.addBox(e,r)},stop(e){$l.removeBox(e,e.legend),delete e.legend},beforeUpdate(e,t,n){let r=e.legend;$l.configure(e,r,n),r.options=n},afterUpdate(e){let t=e.legend;t.buildLabels(),t.adjustHitBoxes()},afterEvent(e,t){t.replay||e.legend.handleEvent(t.event)},defaults:{display:!0,position:`top`,align:`center`,fullSize:!0,reverse:!1,weight:1e3,onClick(e,t,n){let r=t.datasetIndex,i=n.chart;i.isDatasetVisible(r)?(i.hide(r),t.hidden=!0):(i.show(r),t.hidden=!1)},onHover:null,onLeave:null,labels:{color:e=>e.chart.options.color,boxWidth:40,padding:10,generateLabels(e){let t=e.data.datasets,{labels:{usePointStyle:n,pointStyle:r,textAlign:i,color:a,useBorderRadius:o,borderRadius:s}}=e.legend.options;return e._getSortedDatasetMetas().map(e=>{let c=e.controller.getStyle(n?0:void 0),l=Q(c.borderWidth);return{text:t[e.index].label,fillStyle:c.backgroundColor,fontColor:a,hidden:!e.visible,lineCap:c.borderCapStyle,lineDash:c.borderDash,lineDashOffset:c.borderDashOffset,lineJoin:c.borderJoinStyle,lineWidth:(l.width+l.height)/4,strokeStyle:c.borderColor,pointStyle:r||c.pointStyle,rotation:c.rotation,textAlign:i||c.textAlign,borderRadius:o&&(s||c.borderRadius),datasetIndex:e.index}},this)}},title:{color:e=>e.chart.options.color,display:!1,position:`center`,text:``}},descriptors:{_scriptable:e=>!e.startsWith(`on`),labels:{_scriptable:e=>![`generateLabels`,`filter`,`sort`].includes(e)}}},Qd={average(e){if(!e.length)return!1;let t,n,r=new Set,i=0,a=0;for(t=0,n=e.length;t<n;++t){let n=e[t].element;if(n&&n.hasValue()){let e=n.tooltipPosition();r.add(e.x),i+=e.y,++a}}return a===0||r.size===0?!1:{x:[...r].reduce((e,t)=>e+t)/r.size,y:i/a}},nearest(e,t){if(!e.length)return!1;let n=t.x,r=t.y,i=1/0,a,o,s;for(a=0,o=e.length;a<o;++a){let n=e[a].element;if(n&&n.hasValue()){let e=Fo(t,n.getCenterPoint());e<i&&(i=e,s=n)}}if(s){let e=s.tooltipPosition();n=e.x,r=e.y}return{x:n,y:r}}};function $d(e,t){return t&&(W(t)?Array.prototype.push.apply(e,t):e.push(t)),e}function ef(e){return(typeof e==`string`||e instanceof String)&&e.indexOf(`
`)>-1?e.split(`
`):e}function tf(e,t){let{element:n,datasetIndex:r,index:i}=t,a=e.getDatasetMeta(r).controller,{label:o,value:s}=a.getLabelAndValue(i);return{chart:e,label:o,parsed:a.getParsed(i),raw:e.data.datasets[r].data[i],formattedValue:s,dataset:a.getDataset(),dataIndex:i,datasetIndex:r,element:n}}function nf(e,t){let n=e.chart.ctx,{body:r,footer:i,title:a}=e,{boxWidth:o,boxHeight:s}=t,c=$(t.bodyFont),l=$(t.titleFont),u=$(t.footerFont),d=a.length,f=i.length,p=r.length,m=Q(t.padding),h=m.height,g=0,_=r.reduce((e,t)=>e+t.before.length+t.lines.length+t.after.length,0);if(_+=e.beforeBody.length+e.afterBody.length,d&&(h+=d*l.lineHeight+(d-1)*t.titleSpacing+t.titleMarginBottom),_){let e=t.displayColors?Math.max(s,c.lineHeight):c.lineHeight;h+=p*e+(_-p)*c.lineHeight+(_-1)*t.bodySpacing}f&&(h+=t.footerMarginTop+f*u.lineHeight+(f-1)*t.footerSpacing);let v=0,y=function(e){g=Math.max(g,n.measureText(e).width+v)};return n.save(),n.font=l.string,Y(e.title,y),n.font=c.string,Y(e.beforeBody.concat(e.afterBody),y),v=t.displayColors?o+2+t.boxPadding:0,Y(r,e=>{Y(e.before,y),Y(e.lines,y),Y(e.after,y)}),v=0,n.font=u.string,Y(e.footer,y),n.restore(),g+=m.width,{width:g,height:h}}function rf(e,t){let{y:n,height:r}=t;return n<r/2?`top`:n>e.height-r/2?`bottom`:`center`}function af(e,t,n,r){let{x:i,width:a}=r,o=n.caretSize+n.caretPadding;if(e===`left`&&i+a+o>t.width||e===`right`&&i-a-o<0)return!0}function of(e,t,n,r){let{x:i,width:a}=n,{width:o,chartArea:{left:s,right:c}}=e,l=`center`;return r===`center`?l=i<=(s+c)/2?`left`:`right`:i<=a/2?l=`left`:i>=o-a/2&&(l=`right`),af(l,e,t,n)&&(l=`center`),l}function sf(e,t,n){let r=n.yAlign||t.yAlign||rf(e,n);return{xAlign:n.xAlign||t.xAlign||of(e,t,n,r),yAlign:r}}function cf(e,t){let{x:n,width:r}=e;return t===`right`?n-=r:t===`center`&&(n-=r/2),n}function lf(e,t,n){let{y:r,height:i}=e;return t===`top`?r+=n:r-=t===`bottom`?i+n:i/2,r}function uf(e,t,n,r){let{caretSize:i,caretPadding:a,cornerRadius:o}=e,{xAlign:s,yAlign:c}=n,l=i+a,{topLeft:u,topRight:d,bottomLeft:f,bottomRight:p}=Ws(o),m=cf(t,s),h=lf(t,c,l);return c===`center`?s===`left`?m+=l:s===`right`&&(m-=l):s===`left`?m-=Math.max(u,f)+i:s===`right`&&(m+=Math.max(d,p)+i),{x:Ro(m,0,r.width-t.width),y:Ro(h,0,r.height-t.height)}}function df(e,t,n){let r=Q(n.padding);return t===`center`?e.x+e.width/2:t===`right`?e.x+e.width-r.right:e.x+r.left}function ff(e){return $d([],ef(e))}function pf(e,t,n){return qs(e,{tooltip:t,tooltipItems:n,type:`tooltip`})}function mf(e,t){let n=t&&t.dataset&&t.dataset.tooltip&&t.dataset.tooltip.callbacks;return n?e.override(n):e}var hf={beforeTitle:Ya,title(e){if(e.length>0){let t=e[0],n=t.chart.data.labels,r=n?n.length:0;if(this&&this.options&&this.options.mode===`dataset`)return t.dataset.label||``;if(t.label)return t.label;if(r>0&&t.dataIndex<r)return n[t.dataIndex]}return``},afterTitle:Ya,beforeBody:Ya,beforeLabel:Ya,label(e){if(this&&this.options&&this.options.mode===`dataset`)return e.label+`: `+e.formattedValue||e.formattedValue;let t=e.dataset.label||``;t&&(t+=`: `);let n=e.formattedValue;return U(n)||(t+=n),t},labelColor(e){let t=e.chart.getDatasetMeta(e.datasetIndex).controller.getStyle(e.dataIndex);return{borderColor:t.borderColor,backgroundColor:t.backgroundColor,borderWidth:t.borderWidth,borderDash:t.borderDash,borderDashOffset:t.borderDashOffset,borderRadius:0}},labelTextColor(){return this.options.bodyColor},labelPointStyle(e){let t=e.chart.getDatasetMeta(e.datasetIndex).controller.getStyle(e.dataIndex);return{pointStyle:t.pointStyle,rotation:t.rotation}},afterLabel:Ya,afterBody:Ya,beforeFooter:Ya,footer:Ya,afterFooter:Ya};function gf(e,t,n,r){let i=e[t].call(n,r);return i===void 0?hf[t].call(n,r):i}var _f=class extends Cu{static positioners=Qd;constructor(e){super(),this.opacity=0,this._active=[],this._eventPosition=void 0,this._size=void 0,this._cachedAnimations=void 0,this._tooltipItems=[],this.$animations=void 0,this.$context=void 0,this.chart=e.chart,this.options=e.options,this.dataPoints=void 0,this.title=void 0,this.beforeBody=void 0,this.body=void 0,this.afterBody=void 0,this.footer=void 0,this.xAlign=void 0,this.yAlign=void 0,this.x=void 0,this.y=void 0,this.height=void 0,this.width=void 0,this.caretX=void 0,this.caretY=void 0,this.labelColors=void 0,this.labelPointStyles=void 0,this.labelTextColors=void 0}initialize(e){this.options=e,this._cachedAnimations=void 0,this.$context=void 0}_resolveAnimations(){let e=this._cachedAnimations;if(e)return e;let t=this.chart,n=this.options.setContext(this.getContext()),r=n.enabled&&t.options.animation&&n.animations,i=new Vc(this.chart,r);return r._cacheable&&(this._cachedAnimations=Object.freeze(i)),i}getContext(){return this.$context||=pf(this.chart.getContext(),this,this._tooltipItems)}getTitle(e,t){let{callbacks:n}=t,r=gf(n,`beforeTitle`,this,e),i=gf(n,`title`,this,e),a=gf(n,`afterTitle`,this,e),o=[];return o=$d(o,ef(r)),o=$d(o,ef(i)),o=$d(o,ef(a)),o}getBeforeBody(e,t){return ff(gf(t.callbacks,`beforeBody`,this,e))}getBody(e,t){let{callbacks:n}=t,r=[];return Y(e,e=>{let t={before:[],lines:[],after:[]},i=mf(n,e);$d(t.before,ef(gf(i,`beforeLabel`,this,e))),$d(t.lines,gf(i,`label`,this,e)),$d(t.after,ef(gf(i,`afterLabel`,this,e))),r.push(t)}),r}getAfterBody(e,t){return ff(gf(t.callbacks,`afterBody`,this,e))}getFooter(e,t){let{callbacks:n}=t,r=gf(n,`beforeFooter`,this,e),i=gf(n,`footer`,this,e),a=gf(n,`afterFooter`,this,e),o=[];return o=$d(o,ef(r)),o=$d(o,ef(i)),o=$d(o,ef(a)),o}_createItems(e){let t=this._active,n=this.chart.data,r=[],i=[],a=[],o=[],s,c;for(s=0,c=t.length;s<c;++s)o.push(tf(this.chart,t[s]));return e.filter&&(o=o.filter((t,r,i)=>e.filter(t,r,i,n))),e.itemSort&&(o=o.sort((t,r)=>e.itemSort(t,r,n))),Y(o,t=>{let n=mf(e.callbacks,t);r.push(gf(n,`labelColor`,this,t)),i.push(gf(n,`labelPointStyle`,this,t)),a.push(gf(n,`labelTextColor`,this,t))}),this.labelColors=r,this.labelPointStyles=i,this.labelTextColors=a,this.dataPoints=o,o}update(e,t){let n=this.options.setContext(this.getContext()),r=this._active,i,a=[];if(!r.length)this.opacity!==0&&(i={opacity:0});else{let e=Qd[n.position].call(this,r,this._eventPosition);a=this._createItems(n),this.title=this.getTitle(a,n),this.beforeBody=this.getBeforeBody(a,n),this.body=this.getBody(a,n),this.afterBody=this.getAfterBody(a,n),this.footer=this.getFooter(a,n);let t=this._size=nf(this,n),o=Object.assign({},e,t),s=sf(this.chart,n,o),c=uf(n,o,s,this.chart);this.xAlign=s.xAlign,this.yAlign=s.yAlign,i={opacity:1,x:c.x,y:c.y,width:t.width,height:t.height,caretX:e.x,caretY:e.y}}this._tooltipItems=a,this.$context=void 0,i&&this._resolveAnimations().update(this,i),e&&n.external&&n.external.call(this,{chart:this.chart,tooltip:this,replay:t})}drawCaret(e,t,n,r){let i=this.getCaretPosition(e,n,r);t.lineTo(i.x1,i.y1),t.lineTo(i.x2,i.y2),t.lineTo(i.x3,i.y3)}getCaretPosition(e,t,n){let{xAlign:r,yAlign:i}=this,{caretSize:a,cornerRadius:o}=n,{topLeft:s,topRight:c,bottomLeft:l,bottomRight:u}=Ws(o),{x:d,y:f}=e,{width:p,height:m}=t,h,g,_,v,y,b;return i===`center`?(y=f+m/2,r===`left`?(h=d,g=h-a,v=y+a,b=y-a):(h=d+p,g=h+a,v=y-a,b=y+a),_=h):(g=r===`left`?d+Math.max(s,l)+a:r===`right`?d+p-Math.max(c,u)-a:this.caretX,i===`top`?(v=f,y=v-a,h=g-a,_=g+a):(v=f+m,y=v+a,h=g+a,_=g-a),b=v),{x1:h,x2:g,x3:_,y1:v,y2:y,y3:b}}drawTitle(e,t,n){let r=this.title,i=r.length,a,o,s;if(i){let c=jc(n.rtl,this.x,this.width);for(e.x=df(this,n.titleAlign,n),t.textAlign=c.textAlign(n.titleAlign),t.textBaseline=`middle`,a=$(n.titleFont),o=n.titleSpacing,t.fillStyle=n.titleColor,t.font=a.string,s=0;s<i;++s)t.fillText(r[s],c.x(e.x),e.y+a.lineHeight/2),e.y+=a.lineHeight+o,s+1===i&&(e.y+=n.titleMarginBottom-o)}}_drawColorBox(e,t,n,r,i){let a=this.labelColors[n],o=this.labelPointStyles[n],{boxHeight:s,boxWidth:c}=i,l=$(i.bodyFont),u=df(this,`left`,i),d=r.x(u),f=s<l.lineHeight?(l.lineHeight-s)/2:0,p=t.y+f;if(i.usePointStyle){let t={radius:Math.min(c,s)/2,pointStyle:o.pointStyle,rotation:o.rotation,borderWidth:1},n=r.leftForLtr(d,c)+c/2,l=p+s/2;e.strokeStyle=i.multiKeyBackground,e.fillStyle=i.multiKeyBackground,Os(e,t,n,l),e.strokeStyle=a.borderColor,e.fillStyle=a.backgroundColor,Os(e,t,n,l)}else{e.lineWidth=G(a.borderWidth)?Math.max(...Object.values(a.borderWidth)):a.borderWidth||1,e.strokeStyle=a.borderColor,e.setLineDash(a.borderDash||[]),e.lineDashOffset=a.borderDashOffset||0;let t=r.leftForLtr(d,c),n=r.leftForLtr(r.xPlus(d,1),c-2),o=Ws(a.borderRadius);Object.values(o).some(e=>e!==0)?(e.beginPath(),e.fillStyle=i.multiKeyBackground,Ls(e,{x:t,y:p,w:c,h:s,radius:o}),e.fill(),e.stroke(),e.fillStyle=a.backgroundColor,e.beginPath(),Ls(e,{x:n,y:p+1,w:c-2,h:s-2,radius:o}),e.fill()):(e.fillStyle=i.multiKeyBackground,e.fillRect(t,p,c,s),e.strokeRect(t,p,c,s),e.fillStyle=a.backgroundColor,e.fillRect(n,p+1,c-2,s-2))}e.fillStyle=this.labelTextColors[n]}drawBody(e,t,n){let{body:r}=this,{bodySpacing:i,bodyAlign:a,displayColors:o,boxHeight:s,boxWidth:c,boxPadding:l}=n,u=$(n.bodyFont),d=u.lineHeight,f=0,p=jc(n.rtl,this.x,this.width),m=function(n){t.fillText(n,p.x(e.x+f),e.y+d/2),e.y+=d+i},h=p.textAlign(a),g,_,v,y,b,x,S;for(t.textAlign=a,t.textBaseline=`middle`,t.font=u.string,e.x=df(this,h,n),t.fillStyle=n.bodyColor,Y(this.beforeBody,m),f=o&&h!==`right`?a===`center`?c/2+l:c+2+l:0,y=0,x=r.length;y<x;++y){for(g=r[y],_=this.labelTextColors[y],t.fillStyle=_,Y(g.before,m),v=g.lines,o&&v.length&&(this._drawColorBox(t,e,y,p,n),d=Math.max(u.lineHeight,s)),b=0,S=v.length;b<S;++b)m(v[b]),d=u.lineHeight;Y(g.after,m)}f=0,d=u.lineHeight,Y(this.afterBody,m),e.y-=i}drawFooter(e,t,n){let r=this.footer,i=r.length,a,o;if(i){let s=jc(n.rtl,this.x,this.width);for(e.x=df(this,n.footerAlign,n),e.y+=n.footerMarginTop,t.textAlign=s.textAlign(n.footerAlign),t.textBaseline=`middle`,a=$(n.footerFont),t.fillStyle=n.footerColor,t.font=a.string,o=0;o<i;++o)t.fillText(r[o],s.x(e.x),e.y+a.lineHeight/2),e.y+=a.lineHeight+n.footerSpacing}}drawBackground(e,t,n,r){let{xAlign:i,yAlign:a}=this,{x:o,y:s}=e,{width:c,height:l}=n,{topLeft:u,topRight:d,bottomLeft:f,bottomRight:p}=Ws(r.cornerRadius);t.fillStyle=r.backgroundColor,t.strokeStyle=r.borderColor,t.lineWidth=r.borderWidth,t.beginPath(),t.moveTo(o+u,s),a===`top`&&this.drawCaret(e,t,n,r),t.lineTo(o+c-d,s),t.quadraticCurveTo(o+c,s,o+c,s+d),a===`center`&&i===`right`&&this.drawCaret(e,t,n,r),t.lineTo(o+c,s+l-p),t.quadraticCurveTo(o+c,s+l,o+c-p,s+l),a===`bottom`&&this.drawCaret(e,t,n,r),t.lineTo(o+f,s+l),t.quadraticCurveTo(o,s+l,o,s+l-f),a===`center`&&i===`left`&&this.drawCaret(e,t,n,r),t.lineTo(o,s+u),t.quadraticCurveTo(o,s,o+u,s),t.closePath(),t.fill(),r.borderWidth>0&&t.stroke()}_updateAnimationTarget(e){let t=this.chart,n=this.$animations,r=n&&n.x,i=n&&n.y;if(r||i){let n=Qd[e.position].call(this,this._active,this._eventPosition);if(!n)return;let a=this._size=nf(this,e),o=Object.assign({},n,this._size),s=sf(t,e,o),c=uf(e,o,s,t);(r._to!==c.x||i._to!==c.y)&&(this.xAlign=s.xAlign,this.yAlign=s.yAlign,this.width=a.width,this.height=a.height,this.caretX=n.x,this.caretY=n.y,this._resolveAnimations().update(this,c))}}_willRender(){return!!this.opacity}draw(e){let t=this.options.setContext(this.getContext()),n=this.opacity;if(!n)return;this._updateAnimationTarget(t);let r={width:this.width,height:this.height},i={x:this.x,y:this.y};n=Math.abs(n)<.001?0:n;let a=Q(t.padding),o=this.title.length||this.beforeBody.length||this.body.length||this.afterBody.length||this.footer.length;t.enabled&&o&&(e.save(),e.globalAlpha=n,this.drawBackground(i,e,r,t),Mc(e,t.textDirection),i.y+=a.top,this.drawTitle(i,e,t),this.drawBody(i,e,t),this.drawFooter(i,e,t),Nc(e,t.textDirection),e.restore())}getActiveElements(){return this._active||[]}setActiveElements(e,t){let n=this._active,r=e.map(({datasetIndex:e,index:t})=>{let n=this.chart.getDatasetMeta(e);if(!n)throw Error(`Cannot find a dataset at index `+e);return{datasetIndex:e,element:n.data[t],index:t}}),i=!$a(n,r),a=this._positionChanged(r,t);(i||a)&&(this._active=r,this._eventPosition=t,this._ignoreReplayEvents=!0,this.update(!0))}handleEvent(e,t,n=!0){if(t&&this._ignoreReplayEvents)return!1;this._ignoreReplayEvents=!1;let r=this.options,i=this._active||[],a=this._getActiveElements(e,i,t,n),o=this._positionChanged(a,e),s=t||!$a(a,i)||o;return s&&(this._active=a,(r.enabled||r.external)&&(this._eventPosition={x:e.x,y:e.y},this.update(!0,t))),s}_getActiveElements(e,t,n,r){let i=this.options;if(e.type===`mouseout`)return[];if(!r)return t.filter(e=>this.chart.data.datasets[e.datasetIndex]&&this.chart.getDatasetMeta(e.datasetIndex).controller.getParsed(e.index)!==void 0);let a=this.chart.getElementsAtEventForMode(e,i.mode,i,n);return i.reverse&&a.reverse(),a}_positionChanged(e,t){let{caretX:n,caretY:r,options:i}=this,a=Qd[i.position].call(this,e,t);return a!==!1&&(n!==a.x||r!==a.y)}},vf={id:`tooltip`,_element:_f,positioners:Qd,afterInit(e,t,n){n&&(e.tooltip=new _f({chart:e,options:n}))},beforeUpdate(e,t,n){e.tooltip&&e.tooltip.initialize(n)},reset(e,t,n){e.tooltip&&e.tooltip.initialize(n)},afterDraw(e){let t=e.tooltip;if(t&&t._willRender()){let n={tooltip:t};if(e.notifyPlugins(`beforeTooltipDraw`,{...n,cancelable:!0})===!1)return;t.draw(e.ctx),e.notifyPlugins(`afterTooltipDraw`,n)}},afterEvent(e,t){if(e.tooltip){let n=t.replay;e.tooltip.handleEvent(t.event,n,t.inChartArea)&&(t.changed=!0)}},defaults:{enabled:!0,external:null,position:`average`,backgroundColor:`rgba(0,0,0,0.8)`,titleColor:`#fff`,titleFont:{weight:`bold`},titleSpacing:2,titleMarginBottom:6,titleAlign:`left`,bodyColor:`#fff`,bodySpacing:2,bodyFont:{},bodyAlign:`left`,footerColor:`#fff`,footerSpacing:2,footerMarginTop:6,footerFont:{weight:`bold`},footerAlign:`left`,padding:6,caretPadding:2,caretSize:5,cornerRadius:6,boxHeight:(e,t)=>t.bodyFont.size,boxWidth:(e,t)=>t.bodyFont.size,multiKeyBackground:`#fff`,displayColors:!0,boxPadding:0,borderColor:`rgba(0,0,0,0)`,borderWidth:0,animation:{duration:400,easing:`easeOutQuart`},animations:{numbers:{type:`number`,properties:[`x`,`y`,`width`,`height`,`caretX`,`caretY`]},opacity:{easing:`linear`,duration:200}},callbacks:hf},defaultRoutes:{bodyFont:`font`,footerFont:`font`,titleFont:`font`},descriptors:{_scriptable:e=>e!==`filter`&&e!==`itemSort`&&e!==`external`,_indexable:!1,callbacks:{_scriptable:!1,_indexable:!1},animation:{_fallback:!1},animations:{_fallback:`animation`}},additionalOptionScopes:[`interaction`]},yf=(e,t,n,r)=>(typeof t==`string`?(n=e.push(t)-1,r.unshift({index:n,label:t})):isNaN(t)&&(n=null),n);function bf(e,t,n,r){let i=e.indexOf(t);return i===-1?yf(e,t,n,r):i===e.lastIndexOf(t)?i:n}var xf=(e,t)=>e===null?null:Ro(Math.round(e),0,t);function Sf(e){let t=this.getLabels();return e>=0&&e<t.length?t[e]:e}var Cf=class extends Uu{static id=`category`;static defaults={ticks:{callback:Sf}};constructor(e){super(e),this._startValue=void 0,this._valueRange=0,this._addedLabels=[]}init(e){let t=this._addedLabels;if(t.length){let e=this.getLabels();for(let{index:n,label:r}of t)e[n]===r&&e.splice(n,1);this._addedLabels=[]}super.init(e)}parse(e,t){if(U(e))return null;let n=this.getLabels();return t=isFinite(t)&&n[t]===e?t:bf(n,e,q(t,e),this._addedLabels),xf(t,n.length-1)}determineDataLimits(){let{minDefined:e,maxDefined:t}=this.getUserBounds(),{min:n,max:r}=this.getMinMax(!0);this.options.bounds===`ticks`&&(e||(n=0),t||(r=this.getLabels().length-1)),this.min=n,this.max=r}buildTicks(){let e=this.min,t=this.max,n=this.options.offset,r=[],i=this.getLabels();i=e===0&&t===i.length-1?i:i.slice(e,t+1),this._valueRange=Math.max(i.length-+!n,1),this._startValue=this.min-(n?.5:0);for(let n=e;n<=t;n++)r.push({value:n});return r}getLabelForValue(e){return Sf.call(this,e)}configure(){super.configure(),this.isHorizontal()||(this._reversePixels=!this._reversePixels)}getPixelForValue(e){return typeof e!=`number`&&(e=this.parse(e)),e===null?NaN:this.getPixelForDecimal((e-this._startValue)/this._valueRange)}getPixelForTick(e){let t=this.ticks;return e<0||e>t.length-1?null:this.getPixelForValue(t[e].value)}getValueForPixel(e){return Math.round(this._startValue+this.getDecimalForPixel(e)*this._valueRange)}getBasePixel(){return this.bottom}};function wf(e,t){let n=[],{bounds:r,step:i,min:a,max:o,precision:s,count:c,maxTicks:l,maxDigits:u,includeBounds:d}=e,f=i||1,p=l-1,{min:m,max:h}=t,g=!U(a),_=!U(o),v=!U(c),y=(h-m)/(u+1),b=To((h-m)/p/f)*f,x,S,C,w;if(b<1e-14&&!g&&!_)return[{value:m},{value:h}];w=Math.ceil(h/b)-Math.floor(m/b),w>p&&(b=To(w*b/p/f)*f),U(s)||(x=10**s,b=Math.ceil(b*x)/x),r===`ticks`?(S=Math.floor(m/b)*b,C=Math.ceil(h/b)*b):(S=m,C=h),g&&_&&i&&ko((o-a)/i,b/1e3)?(w=Math.round(Math.min((o-a)/b,l)),b=(o-a)/w,S=a,C=o):v?(S=g?a:S,C=_?o:C,w=c-1,b=(C-S)/w):(w=(C-S)/b,w=wo(w,Math.round(w),b/1e3)?Math.round(w):Math.ceil(w));let T=Math.max(No(b),No(S));x=10**(U(s)?T:s),S=Math.round(S*x)/x,C=Math.round(C*x)/x;let E=0;for(g&&(d&&S!==a?(n.push({value:a}),S<a&&E++,wo(Math.round((S+E*b)*x)/x,a,Tf(a,y,e))&&E++):S<a&&E++);E<w;++E){let e=Math.round((S+E*b)*x)/x;if(_&&e>o)break;n.push({value:e})}return _&&d&&C!==o?n.length&&wo(n[n.length-1].value,o,Tf(o,y,e))?n[n.length-1].value=o:n.push({value:o}):(!_||C===o)&&n.push({value:C}),n}function Tf(e,t,{horizontal:n,minRotation:r}){let i=jo(r),a=(n?Math.sin(i):Math.cos(i))||.001,o=.75*t*(``+e).length;return Math.min(t/a,o)}var Ef=class extends Uu{constructor(e){super(e),this.start=void 0,this.end=void 0,this._startValue=void 0,this._endValue=void 0,this._valueRange=0}parse(e,t){return U(e)||(typeof e==`number`||e instanceof Number)&&!isFinite(+e)?null:+e}handleTickRangeOptions(){let{beginAtZero:e}=this.options,{minDefined:t,maxDefined:n}=this.getUserBounds(),{min:r,max:i}=this,a=e=>r=t?r:e,o=e=>i=n?i:e;if(e){let e=Co(r),t=Co(i);e<0&&t<0?o(0):e>0&&t>0&&a(0)}if(r===i){let t=i===0?1:Math.abs(i*.05);o(i+t),e||a(r-t)}this.min=r,this.max=i}getTickLimit(){let{maxTicksLimit:e,stepSize:t}=this.options.ticks,n;return t?(n=Math.ceil(this.max/t)-Math.floor(this.min/t)+1,n>1e3&&(console.warn(`scales.${this.id}.ticks.stepSize: ${t} would result generating up to ${n} ticks. Limiting to 1000.`),n=1e3)):(n=this.computeTickLimit(),e||=11),e&&(n=Math.min(e,n)),n}computeTickLimit(){return 1/0}buildTicks(){let e=this.options,t=e.ticks,n=this.getTickLimit();n=Math.max(2,n);let r=wf({maxTicks:n,bounds:e.bounds,min:e.min,max:e.max,precision:t.precision,step:t.stepSize,count:t.count,maxDigits:this._maxDigits(),horizontal:this.isHorizontal(),minRotation:t.minRotation||0,includeBounds:t.includeBounds!==!1},this._range||this);return e.bounds===`ticks`&&Ao(r,this,`value`),e.reverse?(r.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),r}configure(){let e=this.ticks,t=this.min,n=this.max;if(super.configure(),this.options.offset&&e.length){let r=(n-t)/Math.max(e.length-1,1)/2;t-=r,n+=r}this._startValue=t,this._endValue=n,this._valueRange=n-t}getLabelForValue(e){return ms(e,this.chart.options.locale,this.options.ticks.format)}},Df=class extends Ef{static id=`linear`;static defaults={ticks:{callback:_s.formatters.numeric}};determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=K(e)?e:0,this.max=K(t)?t:1,this.handleTickRangeOptions()}computeTickLimit(){let e=this.isHorizontal(),t=e?this.width:this.height,n=jo(this.options.ticks.minRotation),r=(e?Math.sin(n):Math.cos(n))||.001,i=this._resolveTickFontOptions(0);return Math.ceil(t/Math.min(40,i.lineHeight/r))}getPixelForValue(e){return e===null?NaN:this.getPixelForDecimal((e-this._startValue)/this._valueRange)}getValueForPixel(e){return this._startValue+this.getDecimalForPixel(e)*this._valueRange}},Of=e=>Math.floor(So(e)),kf=(e,t)=>10**(Of(e)+t);function Af(e){return e/10**Of(e)==1}function jf(e,t,n){let r=10**n,i=Math.floor(e/r);return Math.ceil(t/r)-i}function Mf(e,t){let n=Of(t-e);for(;jf(e,t,n)>10;)n++;for(;jf(e,t,n)<10;)n--;return Math.min(n,Of(e))}function Nf(e,{min:t,max:n}){t=Za(e.min,t);let r=[],i=Of(t),a=Mf(t,n),o=a<0?10**Math.abs(a):1,s=10**a,c=i>a?10**i:0,l=Math.round((t-c)*o)/o,u=Math.floor((t-c)/s/10)*s*10,d=Math.floor((l-u)/10**a),f=Za(e.min,Math.round((c+u+d*10**a)*o)/o);for(;f<n;)r.push({value:f,major:Af(f),significand:d}),d>=10?d=d<15?15:20:d++,d>=20&&(a++,d=2,o=a>=0?1:o),f=Math.round((c+u+d*10**a)*o)/o;let p=Za(e.max,f);return r.push({value:p,major:Af(p),significand:d}),r}(class extends Uu{static id=`logarithmic`;static defaults={ticks:{callback:_s.formatters.logarithmic,major:{enabled:!0}}};constructor(e){super(e),this.start=void 0,this.end=void 0,this._startValue=void 0,this._valueRange=0}parse(e,t){let n=Ef.prototype.parse.apply(this,[e,t]);if(n===0){this._zero=!0;return}return K(n)&&n>0?n:null}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=K(e)?Math.max(0,e):null,this.max=K(t)?Math.max(0,t):null,this.options.beginAtZero&&(this._zero=!0),this._zero&&this.min!==this._suggestedMin&&!K(this._userMin)&&(this.min=e===kf(this.min,0)?kf(this.min,-1):kf(this.min,0)),this.handleTickRangeOptions()}handleTickRangeOptions(){let{minDefined:e,maxDefined:t}=this.getUserBounds(),n=this.min,r=this.max,i=t=>n=e?n:t,a=e=>r=t?r:e;n===r&&(n<=0?(i(1),a(10)):(i(kf(n,-1)),a(kf(r,1)))),n<=0&&i(kf(r,-1)),r<=0&&a(kf(n,1)),this.min=n,this.max=r}buildTicks(){let e=this.options,t=Nf({min:this._userMin,max:this._userMax},this);return e.bounds===`ticks`&&Ao(t,this,`value`),e.reverse?(t.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),t}getLabelForValue(e){return e===void 0?`0`:ms(e,this.chart.options.locale,this.options.ticks.format)}configure(){let e=this.min;super.configure(),this._startValue=So(e),this._valueRange=So(this.max)-So(e)}getPixelForValue(e){return(e===void 0||e===0)&&(e=this.min),e===null||isNaN(e)?NaN:this.getPixelForDecimal(e===this.min?0:(So(e)-this._startValue)/this._valueRange)}getValueForPixel(e){let t=this.getDecimalForPixel(e);return 10**(this._startValue+t*this._valueRange)}});function Pf(e){let t=e.ticks;if(t.display&&e.display){let e=Q(t.backdropPadding);return q(t.font&&t.font.size,Z.font.size)+e.height}return 0}function Ff(e,t,n){return n=W(n)?n:[n],{w:Ts(e,t.string,n),h:n.length*t.lineHeight}}function If(e,t,n,r,i){return e===r||e===i?{start:t-n/2,end:t+n/2}:e<r||e>i?{start:t-n,end:t}:{start:t,end:t+n}}function Lf(e){let t={l:e.left+e._padding.left,r:e.right-e._padding.right,t:e.top+e._padding.top,b:e.bottom-e._padding.bottom},n=Object.assign({},t),r=[],i=[],a=e._pointLabels.length,o=e.options.pointLabels,s=o.centerPointLabels?X/a:0;for(let c=0;c<a;c++){let a=o.setContext(e.getPointLabelContext(c));i[c]=a.padding;let l=e.getPointPosition(c,e.drawingArea+i[c],s),u=$(a.font),d=Ff(e.ctx,u,e._pointLabels[c]);r[c]=d;let f=Io(e.getIndexAngle(c)+s),p=Math.round(Mo(f));Rf(n,t,f,If(p,l.x,d.w,0,180),If(p,l.y,d.h,90,270))}e.setCenterPoint(t.l-n.l,n.r-t.r,t.t-n.t,n.b-t.b),e._pointLabelItems=Vf(e,r,i)}function Rf(e,t,n,r,i){let a=Math.abs(Math.sin(n)),o=Math.abs(Math.cos(n)),s=0,c=0;r.start<t.l?(s=(t.l-r.start)/a,e.l=Math.min(e.l,t.l-s)):r.end>t.r&&(s=(r.end-t.r)/a,e.r=Math.max(e.r,t.r+s)),i.start<t.t?(c=(t.t-i.start)/o,e.t=Math.min(e.t,t.t-c)):i.end>t.b&&(c=(i.end-t.b)/o,e.b=Math.max(e.b,t.b+c))}function zf(e,t,n){let r=e.drawingArea,{extra:i,additionalAngle:a,padding:o,size:s}=n,c=e.getPointPosition(t,r+i+o,a),l=Math.round(Mo(Io(c.angle+yo))),u=Wf(c.y,s.h,l),d=Hf(l),f=Uf(c.x,s.w,d);return{visible:!0,x:c.x,y:u,textAlign:d,left:f,top:u,right:f+s.w,bottom:u+s.h}}function Bf(e,t){if(!t)return!0;let{left:n,top:r,right:i,bottom:a}=e;return!(As({x:n,y:r},t)||As({x:n,y:a},t)||As({x:i,y:r},t)||As({x:i,y:a},t))}function Vf(e,t,n){let r=[],i=e._pointLabels.length,a=e.options,{centerPointLabels:o,display:s}=a.pointLabels,c={extra:Pf(a)/2,additionalAngle:o?X/i:0},l;for(let a=0;a<i;a++){c.padding=n[a],c.size=t[a];let i=zf(e,a,c);r.push(i),s===`auto`&&(i.visible=Bf(i,l),i.visible&&(l=i))}return r}function Hf(e){return e===0||e===180?`center`:e<180?`left`:`right`}function Uf(e,t,n){return n===`right`?e-=t:n===`center`&&(e-=t/2),e}function Wf(e,t,n){return n===90||n===270?e-=t/2:(n>270||n<90)&&(e-=t),e}function Gf(e,t,n){let{left:r,top:i,right:a,bottom:o}=n,{backdropColor:s}=t;if(!U(s)){let n=Ws(t.borderRadius),c=Q(t.backdropPadding);e.fillStyle=s;let l=r-c.left,u=i-c.top,d=a-r+c.width,f=o-i+c.height;Object.values(n).some(e=>e!==0)?(e.beginPath(),Ls(e,{x:l,y:u,w:d,h:f,radius:n}),e.fill()):e.fillRect(l,u,d,f)}}function Kf(e,t){let{ctx:n,options:{pointLabels:r}}=e;for(let i=t-1;i>=0;i--){let t=e._pointLabelItems[i];if(!t.visible)continue;let a=r.setContext(e.getPointLabelContext(i));Gf(n,a,t);let o=$(a.font),{x:s,y:c,textAlign:l}=t;Is(n,e._pointLabels[i],s,c+o.lineHeight/2,o,{color:a.color,textAlign:l,textBaseline:`middle`})}}function qf(e,t,n,r){let{ctx:i}=e;if(n)i.arc(e.xCenter,e.yCenter,t,0,go);else{let n=e.getPointPosition(0,t);i.moveTo(n.x,n.y);for(let a=1;a<r;a++)n=e.getPointPosition(a,t),i.lineTo(n.x,n.y)}}function Jf(e,t,n,r,i){let a=e.ctx,o=t.circular,{color:s,lineWidth:c}=t;!o&&!r||!s||!c||n<0||(a.save(),a.strokeStyle=s,a.lineWidth=c,a.setLineDash(i.dash||[]),a.lineDashOffset=i.dashOffset,a.beginPath(),qf(e,n,o,r),a.closePath(),a.stroke(),a.restore())}function Yf(e,t,n){return qs(e,{label:n,index:t,type:`pointLabel`})}(class extends Ef{static id=`radialLinear`;static defaults={display:!0,animate:!0,position:`chartArea`,angleLines:{display:!0,lineWidth:1,borderDash:[],borderDashOffset:0},grid:{circular:!1},startAngle:0,ticks:{showLabelBackdrop:!0,callback:_s.formatters.numeric},pointLabels:{backdropColor:void 0,backdropPadding:2,display:!0,font:{size:10},callback(e){return e},padding:5,centerPointLabels:!1}};static defaultRoutes={"angleLines.color":`borderColor`,"pointLabels.color":`color`,"ticks.color":`color`};static descriptors={angleLines:{_fallback:`grid`}};constructor(e){super(e),this.xCenter=void 0,this.yCenter=void 0,this.drawingArea=void 0,this._pointLabels=[],this._pointLabelItems=[]}setDimensions(){let e=this._padding=Q(Pf(this.options)/2),t=this.width=this.maxWidth-e.width,n=this.height=this.maxHeight-e.height;this.xCenter=Math.floor(this.left+t/2+e.left),this.yCenter=Math.floor(this.top+n/2+e.top),this.drawingArea=Math.floor(Math.min(t,n)/2)}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!1);this.min=K(e)&&!isNaN(e)?e:0,this.max=K(t)&&!isNaN(t)?t:0,this.handleTickRangeOptions()}computeTickLimit(){return Math.ceil(this.drawingArea/Pf(this.options))}generateTickLabels(e){Ef.prototype.generateTickLabels.call(this,e),this._pointLabels=this.getLabels().map((e,t)=>{let n=J(this.options.pointLabels.callback,[e,t],this);return n||n===0?n:``}).filter((e,t)=>this.chart.getDataVisibility(t))}fit(){let e=this.options;e.display&&e.pointLabels.display?Lf(this):this.setCenterPoint(0,0,0,0)}setCenterPoint(e,t,n,r){this.xCenter+=Math.floor((e-t)/2),this.yCenter+=Math.floor((n-r)/2),this.drawingArea-=Math.min(this.drawingArea/2,Math.max(e,t,n,r))}getIndexAngle(e){let t=go/(this._pointLabels.length||1),n=this.options.startAngle||0;return Io(e*t+jo(n))}getDistanceFromCenterForValue(e){if(U(e))return NaN;let t=this.drawingArea/(this.max-this.min);return this.options.reverse?(this.max-e)*t:(e-this.min)*t}getValueForDistanceFromCenter(e){if(U(e))return NaN;let t=e/(this.drawingArea/(this.max-this.min));return this.options.reverse?this.max-t:this.min+t}getPointLabelContext(e){let t=this._pointLabels||[];if(e>=0&&e<t.length){let n=t[e];return Yf(this.getContext(),e,n)}}getPointPosition(e,t,n=0){let r=this.getIndexAngle(e)-yo+n;return{x:Math.cos(r)*t+this.xCenter,y:Math.sin(r)*t+this.yCenter,angle:r}}getPointPositionForValue(e,t){return this.getPointPosition(e,this.getDistanceFromCenterForValue(t))}getBasePosition(e){return this.getPointPositionForValue(e||0,this.getBaseValue())}getPointLabelPosition(e){let{left:t,top:n,right:r,bottom:i}=this._pointLabelItems[e];return{left:t,top:n,right:r,bottom:i}}drawBackground(){let{backgroundColor:e,grid:{circular:t}}=this.options;if(e){let n=this.ctx;n.save(),n.beginPath(),qf(this,this.getDistanceFromCenterForValue(this._endValue),t,this._pointLabels.length),n.closePath(),n.fillStyle=e,n.fill(),n.restore()}}drawGrid(){let e=this.ctx,t=this.options,{angleLines:n,grid:r,border:i}=t,a=this._pointLabels.length,o,s,c;if(t.pointLabels.display&&Kf(this,a),r.display&&this.ticks.forEach((e,t)=>{if(t!==0||t===0&&this.min<0){s=this.getDistanceFromCenterForValue(e.value);let n=this.getContext(t),o=r.setContext(n),c=i.setContext(n);Jf(this,o,s,a,c)}}),n.display){for(e.save(),o=a-1;o>=0;o--){let r=n.setContext(this.getPointLabelContext(o)),{color:i,lineWidth:a}=r;!a||!i||(e.lineWidth=a,e.strokeStyle=i,e.setLineDash(r.borderDash),e.lineDashOffset=r.borderDashOffset,s=this.getDistanceFromCenterForValue(t.reverse?this.min:this.max),c=this.getPointPosition(o,s),e.beginPath(),e.moveTo(this.xCenter,this.yCenter),e.lineTo(c.x,c.y),e.stroke())}e.restore()}}drawBorder(){}drawLabels(){let e=this.ctx,t=this.options,n=t.ticks;if(!n.display)return;let r=this.getIndexAngle(0),i,a;e.save(),e.translate(this.xCenter,this.yCenter),e.rotate(r),e.textAlign=`center`,e.textBaseline=`middle`,this.ticks.forEach((r,o)=>{if(o===0&&this.min>=0&&!t.reverse)return;let s=n.setContext(this.getContext(o)),c=$(s.font);if(i=this.getDistanceFromCenterForValue(this.ticks[o].value),s.showLabelBackdrop){e.font=c.string,a=e.measureText(r.label).width,e.fillStyle=s.backdropColor;let t=Q(s.backdropPadding);e.fillRect(-a/2-t.left,-i-c.size/2-t.top,a+t.width,c.size+t.height)}Is(e,r.label,0,-i,c,{color:s.color,strokeColor:s.textStrokeColor,strokeWidth:s.textStrokeWidth})}),e.restore()}drawTitle(){}});var Xf={millisecond:{common:!0,size:1,steps:1e3},second:{common:!0,size:1e3,steps:60},minute:{common:!0,size:6e4,steps:60},hour:{common:!0,size:36e5,steps:24},day:{common:!0,size:864e5,steps:30},week:{common:!1,size:6048e5,steps:4},month:{common:!0,size:2628e6,steps:12},quarter:{common:!1,size:7884e6,steps:4},year:{common:!0,size:3154e7}},Zf=Object.keys(Xf);function Qf(e,t){return e-t}function $f(e,t){if(U(t))return null;let n=e._adapter,{parser:r,round:i,isoWeekday:a}=e._parseOpts,o=t;return typeof r==`function`&&(o=r(o)),K(o)||(o=typeof r==`string`?n.parse(o,r):n.parse(o)),o===null?null:(i&&(o=i===`week`&&(Oo(a)||a===!0)?n.startOf(o,`isoWeek`,a):n.startOf(o,i)),+o)}function ep(e,t,n,r){let i=Zf.length;for(let a=Zf.indexOf(e);a<i-1;++a){let e=Xf[Zf[a]],i=e.steps?e.steps:2**53-1;if(e.common&&Math.ceil((n-t)/(i*e.size))<=r)return Zf[a]}return Zf[i-1]}function tp(e,t,n,r,i){for(let a=Zf.length-1;a>=Zf.indexOf(n);a--){let n=Zf[a];if(Xf[n].common&&e._adapter.diff(i,r,n)>=t-1)return n}return Zf[n?Zf.indexOf(n):0]}function np(e){for(let t=Zf.indexOf(e)+1,n=Zf.length;t<n;++t)if(Xf[Zf[t]].common)return Zf[t]}function rp(e,t,n){if(!n)e[t]=!0;else if(n.length){let{lo:r,hi:i}=Vo(n,t),a=n[r]>=t?n[r]:n[i];e[a]=!0}}function ip(e,t,n,r){let i=e._adapter,a=+i.startOf(t[0].value,r),o=t[t.length-1].value,s,c;for(s=a;s<=o;s=+i.add(s,1,r))c=n[s],c>=0&&(t[c].major=!0);return t}function ap(e,t,n){let r=[],i={},a=t.length,o,s;for(o=0;o<a;++o)s=t[o],i[s]=o,r.push({value:s,major:!1});return a===0||!n?r:ip(e,r,i,n)}var op=class extends Uu{static id=`time`;static defaults={bounds:`data`,adapters:{},time:{parser:!1,unit:!1,round:!1,isoWeekday:!1,minUnit:`millisecond`,displayFormats:{}},ticks:{source:`auto`,callback:!1,major:{enabled:!1}}};constructor(e){super(e),this._cache={data:[],labels:[],all:[]},this._unit=`day`,this._majorUnit=void 0,this._offsets={},this._normalized=!1,this._parseOpts=void 0}init(e,t={}){let n=e.time||={},r=this._adapter=new Dl._date(e.adapters.date);r.init(t),io(n.displayFormats,r.formats()),this._parseOpts={parser:n.parser,round:n.round,isoWeekday:n.isoWeekday},super.init(e),this._normalized=t.normalized}parse(e,t){return e===void 0?null:$f(this,e)}beforeLayout(){super.beforeLayout(),this._cache={data:[],labels:[],all:[]}}determineDataLimits(){let e=this.options,t=this._adapter,n=e.time.unit||`day`,{min:r,max:i,minDefined:a,maxDefined:o}=this.getUserBounds();function s(e){!a&&!isNaN(e.min)&&(r=Math.min(r,e.min)),!o&&!isNaN(e.max)&&(i=Math.max(i,e.max))}(!a||!o)&&(s(this._getLabelBounds()),(e.bounds!==`ticks`||e.ticks.source!==`labels`)&&s(this.getMinMax(!1))),r=K(r)&&!isNaN(r)?r:+t.startOf(Date.now(),n),i=K(i)&&!isNaN(i)?i:+t.endOf(Date.now(),n)+1,this.min=Math.min(r,i-1),this.max=Math.max(r+1,i)}_getLabelBounds(){let e=this.getLabelTimestamps(),t=1/0,n=-1/0;return e.length&&(t=e[0],n=e[e.length-1]),{min:t,max:n}}buildTicks(){let e=this.options,t=e.time,n=e.ticks,r=n.source===`labels`?this.getLabelTimestamps():this._generate();e.bounds===`ticks`&&r.length&&(this.min=this._userMin||r[0],this.max=this._userMax||r[r.length-1]);let i=this.min,a=this.max,o=Wo(r,i,a);return this._unit=t.unit||(n.autoSkip?ep(t.minUnit,this.min,this.max,this._getLabelCapacity(i)):tp(this,o.length,t.minUnit,this.min,this.max)),this._majorUnit=!n.major.enabled||this._unit===`year`?void 0:np(this._unit),this.initOffsets(r),e.reverse&&o.reverse(),ap(this,o,this._majorUnit)}afterAutoSkip(){this.options.offsetAfterAutoskip&&this.initOffsets(this.ticks.map(e=>+e.value))}initOffsets(e=[]){let t=0,n=0,r,i;this.options.offset&&e.length&&(r=this.getDecimalForValue(e[0]),t=e.length===1?1-r:(this.getDecimalForValue(e[1])-r)/2,i=this.getDecimalForValue(e[e.length-1]),n=e.length===1?i:(i-this.getDecimalForValue(e[e.length-2]))/2);let a=e.length<3?.5:.25;t=Ro(t,0,a),n=Ro(n,0,a),this._offsets={start:t,end:n,factor:1/(t+1+n)}}_generate(){let e=this._adapter,t=this.min,n=this.max,r=this.options,i=r.time,a=i.unit||ep(i.minUnit,t,n,this._getLabelCapacity(t)),o=q(r.ticks.stepSize,1),s=a===`week`&&i.isoWeekday,c=Oo(s)||s===!0,l={},u=t,d,f;if(c&&(u=+e.startOf(u,`isoWeek`,s)),u=+e.startOf(u,c?`day`:a),e.diff(n,t,a)>1e5*o)throw Error(t+` and `+n+` are too far apart with stepSize of `+o+` `+a);let p=r.ticks.source===`data`&&this.getDataTimestamps();for(d=u,f=0;d<n;d=+e.add(d,o,a),f++)rp(l,d,p);return(d===n||r.bounds===`ticks`||f===1)&&rp(l,d,p),Object.keys(l).sort(Qf).map(e=>+e)}getLabelForValue(e){let t=this._adapter,n=this.options.time;return n.tooltipFormat?t.format(e,n.tooltipFormat):t.format(e,n.displayFormats.datetime)}format(e,t){let n=this.options.time.displayFormats,r=this._unit,i=t||n[r];return this._adapter.format(e,i)}_tickFormatFunction(e,t,n,r){let i=this.options,a=i.ticks.callback;if(a)return J(a,[e,t,n],this);let o=i.time.displayFormats,s=this._unit,c=this._majorUnit,l=s&&o[s],u=c&&o[c],d=n[t],f=c&&u&&d&&d.major;return this._adapter.format(e,r||(f?u:l))}generateTickLabels(e){let t,n,r;for(t=0,n=e.length;t<n;++t)r=e[t],r.label=this._tickFormatFunction(r.value,t,e)}getDecimalForValue(e){return e===null?NaN:(e-this.min)/(this.max-this.min)}getPixelForValue(e){let t=this._offsets,n=this.getDecimalForValue(e);return this.getPixelForDecimal((t.start+n)*t.factor)}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return this.min+n*(this.max-this.min)}_getLabelSize(e){let t=this.options.ticks,n=this.ctx.measureText(e).width,r=jo(this.isHorizontal()?t.maxRotation:t.minRotation),i=Math.cos(r),a=Math.sin(r),o=this._resolveTickFontOptions(0).size;return{w:n*i+o*a,h:n*a+o*i}}_getLabelCapacity(e){let t=this.options.time,n=t.displayFormats,r=n[t.unit]||n.millisecond,i=this._tickFormatFunction(e,0,ap(this,[e],this._majorUnit),r),a=this._getLabelSize(i),o=Math.floor(this.isHorizontal()?this.width/a.w:this.height/a.h)-1;return o>0?o:1}getDataTimestamps(){let e=this._cache.data||[],t,n;if(e.length)return e;let r=this.getMatchingVisibleMetas();if(this._normalized&&r.length)return this._cache.data=r[0].controller.getAllParsedValues(this);for(t=0,n=r.length;t<n;++t)e=e.concat(r[t].controller.getAllParsedValues(this));return this._cache.data=this.normalize(e)}getLabelTimestamps(){let e=this._cache.labels||[],t,n;if(e.length)return e;let r=this.getLabels();for(t=0,n=r.length;t<n;++t)e.push($f(this,r[t]));return this._cache.labels=this._normalized?e:this.normalize(e)}normalize(e){return Jo(e.sort(Qf))}};function sp(e,t,n){let r=0,i=e.length-1,a,o,s,c;n?(t>=e[r].pos&&t<=e[i].pos&&({lo:r,hi:i}=Ho(e,`pos`,t)),{pos:a,time:s}=e[r],{pos:o,time:c}=e[i]):(t>=e[r].time&&t<=e[i].time&&({lo:r,hi:i}=Ho(e,`time`,t)),{time:a,pos:s}=e[r],{time:o,pos:c}=e[i]);let l=o-a;return l?s+(c-s)*(t-a)/l:s}(class extends op{static id=`timeseries`;static defaults=op.defaults;constructor(e){super(e),this._table=[],this._minPos=void 0,this._tableRange=void 0}initOffsets(){let e=this._getTimestampsForTable(),t=this._table=this.buildLookupTable(e);this._minPos=sp(t,this.min),this._tableRange=sp(t,this.max)-this._minPos,super.initOffsets(e)}buildLookupTable(e){let{min:t,max:n}=this,r=[],i=[],a,o,s,c,l;for(a=0,o=e.length;a<o;++a)c=e[a],c>=t&&c<=n&&r.push(c);if(r.length<2)return[{time:t,pos:0},{time:n,pos:1}];for(a=0,o=r.length;a<o;++a)l=r[a+1],s=r[a-1],c=r[a],Math.round((l+s)/2)!==c&&i.push({time:c,pos:a/(o-1)});return i}_generate(){let e=this.min,t=this.max,n=super.getDataTimestamps();return(!n.includes(e)||!n.length)&&n.splice(0,0,e),(!n.includes(t)||n.length===1)&&n.push(t),n.sort((e,t)=>e-t)}_getTimestampsForTable(){let e=this._cache.all||[];if(e.length)return e;let t=this.getDataTimestamps(),n=this.getLabelTimestamps();return e=t.length&&n.length?this.normalize(t.concat(n)):t.length?t:n,e=this._cache.all=e,e}getDecimalForValue(e){return(sp(this._table,e)-this._minPos)/this._tableRange}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return sp(this._table,n*this._tableRange+this._minPos,!0)}});var cp={data:{type:Object,required:!0},options:{type:Object,default:()=>({})},plugins:{type:Array,default:()=>[]},datasetIdKey:{type:String,default:`label`},updateMode:{type:String,default:void 0}},lp={ariaLabel:{type:String},ariaDescribedby:{type:String}},up={type:{type:String,required:!0},destroyDelay:{type:Number,default:0},...cp,...lp},dp=(e,t)=>Object.assign(e,t);function fp(e){return c(e)?O(e):e}function pp(e){let t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:e;return c(t)?new Proxy(e,{}):e}function mp(e,t){let n=e.options;n&&t&&Object.assign(n,t)}function hp(e,t){e.labels=t}function gp(e,t,n){let r=[];e.datasets=t.map(t=>{let i=e.datasets.find(e=>e[n]===t[n]);return!i||!t.data||r.includes(i)?{...t}:(r.push(i),Object.assign(i,t),i)})}function _p(e,t){let n={labels:[],datasets:[]};return hp(n,e.labels),gp(n,e.datasets,t),n}var vp=R({props:up,setup(e,t){let{expose:n,slots:r}=t,i=F(null),a=w(null);n({chart:a});let o=()=>{if(!i.value)return;let{type:t,data:n,options:r,plugins:o,datasetIdKey:s}=e,c=pp(_p(n,s),n);a.value=new jd(i.value,{type:t,data:c,options:{...r},plugins:o})},s=()=>{let t=O(a.value);t&&(e.destroyDelay>0?setTimeout(()=>{t.destroy(),a.value=null},e.destroyDelay):(t.destroy(),a.value=null))},c=t=>{t.update(e.updateMode)};return Me(o),we(s),V([()=>e.options,()=>e.data],(t,n)=>{let[r,i]=t,[o,s]=n,l=O(a.value);if(!l)return;let u=!1;if(r){let e=fp(r),t=fp(o);e&&e!==t&&(mp(l,e),u=!0)}if(i){let t=fp(i.labels),n=fp(s.labels),r=fp(i.datasets),a=fp(s.datasets);t!==n&&(hp(l.config.data,t),u=!0),r&&r!==a&&(gp(l.config.data,r,e.datasetIdKey),u=!0)}u&&xe(()=>{c(l)})},{deep:!0}),()=>Ae(`canvas`,{role:`img`,"aria-label":e.ariaLabel,"aria-describedby":e.ariaDescribedby,ref:i},[Ae(`p`,{},[r.default?r.default():``])])}});function yp(e,t){return jd.register(t),R({props:cp,setup(t,n){let{expose:r}=n,i=w(null),a=w(null);V(()=>a.value?.chart??null,e=>{i.value=e},{flush:`sync`}),r({chart:i});let o=e=>{a.value=e};return()=>Ae(vp,dp({ref:o},{type:e,...t}))}})}var bp=yp(`bar`,Tl);jd.register(Tl,Hd,Cf,Df,Zd,vf);function xp(){let e=F(``),t=F(``),n=F(``);function r(){let r=getComputedStyle(document.documentElement);e.value=r.getPropertyValue(`--foreground`).trim(),t.value=r.getPropertyValue(`--muted-foreground`).trim(),n.value=r.getPropertyValue(`--border`).trim()}let i;return Me(()=>{r(),i=window.matchMedia(`(prefers-color-scheme: dark)`),i.addEventListener(`change`,r)}),Ie(()=>{i?.removeEventListener(`change`,r)}),{foreground:e,mutedForeground:t,border:n}}var Sp={cost:`Cost`,req:`Requests`,tokin:`Tokens in`,tokout:`Tokens out`},Cp=20,wp=100,Tp=3e4,Ep={hour:24,day:30,month:12},Dp={hour:`24h`,day:`30d`,month:`12mo`};function Op(e){switch(e){case`requests`:return[`req`];case`tokens`:return[`tokin`,`tokout`];case`cost`:return[`cost`];case`models`:return[]}}var kp=de(`history`,{state:()=>({scope:`total`,window:`hour`,tab:`requests`,modelMetric:`cost`,seriesByMetric:{},modelRanking:[],modelOptions:[],loading:!1,error:``,timer:void 0}),actions:{setScope(e){e!==this.scope&&(this.scope=e,this.refresh())},setWindow(e){e!==this.window&&(this.window=e,this.refresh())},setTab(e){e!==this.tab&&(this.tab=e,this.refresh())},setModelMetric(e){e!==this.modelMetric&&(this.modelMetric=e,this.refresh())},async refresh(){await Promise.all([this.tab===`models`?this.fetchModelRanking():this.fetchSeries(),this.fetchModelOptions()])},async fetchSeries(){if(je().isAuthenticated){this.loading=!0;try{let e=Ep[this.window],t=Op(this.tab),n=await Promise.all(t.map(t=>Fe(`/admin/api/usage/history?scope=${encodeURIComponent(this.scope)}&metric=${t}&window=${this.window}&span=${e}`))),r={};t.forEach((e,t)=>{r[e]=n[t].points}),this.seriesByMetric=r,this.error=``}catch(e){if(e instanceof be&&(e.status===401||e.status===403))return;this.error=e instanceof Error?e.message:String(e)}finally{this.loading=!1}}},async fetchModelRanking(){if(je().isAuthenticated){this.loading=!0;try{let e=await Fe(`/admin/api/usage/models?metric=${this.modelMetric}&window=${this.window}&limit=${Cp}`);this.modelRanking=e.models,this.error=``}catch(e){if(e instanceof be&&(e.status===401||e.status===403))return;this.error=e instanceof Error?e.message:String(e)}finally{this.loading=!1}}},async fetchModelOptions(){if(je().isAuthenticated)try{let e=await Fe(`/admin/api/usage/models?metric=req&window=${this.window}&limit=${wp}`);this.modelOptions=e.models}catch{}},startAutoRefresh(){this.timer===void 0&&(this.timer=setInterval(()=>void this.refresh(),Tp))},stopAutoRefresh(){this.timer!==void 0&&(clearInterval(this.timer),this.timer=void 0)}}}),Ap={key:0,class:`py-8 text-center text-sm text-muted-foreground`},jp=R({__name:`ModelUsageChart`,props:{metric:{},models:{}},setup(e){let t=e,{foreground:n,mutedForeground:r,border:a}=xp(),o={req:`--chart-requests`,tokin:`--chart-tokens-in`,tokout:`--chart-tokens-out`,cost:`--chart-cost`};function s(e,t){return e===`cost`?t/1e6:t}function c(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let l=M(()=>(n.value,{labels:t.models.map(e=>e.id),datasets:[{label:Sp[t.metric],backgroundColor:c(o[t.metric]),data:t.models.map(e=>s(t.metric,e.value))}]})),u=M(()=>`${Math.max(180,t.models.length*28+60)}px`),d=M(()=>({indexAxis:`y`,responsive:!0,maintainAspectRatio:!1,animation:!1,scales:{x:{beginAtZero:!0,grid:{color:a.value},ticks:{color:r.value,callback:e=>t.metric===`cost`?`$${e}`:ke(Number(e))}},y:{grid:{display:!1},ticks:{color:r.value,autoSkip:!1}}},plugins:{legend:{display:!1},tooltip:{callbacks:{label:e=>{let n=e.parsed.x??0;return t.metric===`cost`?`${Sp[t.metric]}: $${n.toFixed(4)}`:`${Sp[t.metric]}: ${ke(n)} (${Ue(n)})`}}}}}));return(t,n)=>e.models.length===0?(N(),P(`p`,Ap,` No model recorded any usage in this window. `)):(N(),P(`div`,{key:1,class:`w-full`,style:i({height:u.value})},[L(b(bp),{data:l.value,options:d.value},null,8,[`data`,`options`])],4))}}),Mp={class:`h-72 w-full`},Np=R({__name:`UsageChart`,props:{tab:{},window:{},seriesByMetric:{}},setup(e){let t=e,{foreground:n,mutedForeground:r,border:i}=xp(),a={requests:[{metric:`req`,label:`Requests`,color:`--chart-requests`}],tokens:[{metric:`tokin`,label:`Tokens in`,color:`--chart-tokens-in`},{metric:`tokout`,label:`Tokens out`,color:`--chart-tokens-out`}],cost:[{metric:`cost`,label:`Cost (USD)`,color:`--chart-cost`}]};function o(e,t){return e===`cost`?t/1e6:t}let s=M(()=>{let e=a[t.tab],n=new Set;for(let r of e)for(let e of t.seriesByMetric[r.metric]??[])n.add(e.bucket);return Array.from(n).sort()}),c=M(()=>s.value.map(e=>_e(e,t.window)));function l(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let u=M(()=>{n.value;let e=s.value;return{labels:c.value,datasets:a[t.tab].map(n=>{let r=new Map((t.seriesByMetric[n.metric]??[]).map(e=>[e.bucket,e.value]));return{label:n.label,backgroundColor:l(n.color),data:e.map(e=>o(n.metric,r.get(e)??0))}})}}),d=M(()=>a[t.tab].length>1),f=M(()=>({responsive:!0,maintainAspectRatio:!1,animation:!1,scales:{x:{stacked:d.value,grid:{color:i.value,display:!1},ticks:{color:r.value}},y:{stacked:d.value,beginAtZero:!0,grid:{color:i.value},ticks:{color:r.value,callback:e=>t.tab===`cost`?`$${e}`:ke(Number(e))}}},plugins:{legend:{display:d.value,labels:{color:n.value}},tooltip:{callbacks:{label:e=>{let n=e.parsed.y??0;return t.tab===`cost`?`${e.dataset.label}: $${n.toFixed(4)}`:`${e.dataset.label}: ${ke(n)} (${Ue(n)})`}}}}}));return(e,t)=>(N(),P(`div`,Mp,[L(b(bp),{data:u.value,options:f.value},null,8,[`data`,`options`])]))}}),Pp={class:`flex flex-wrap items-center gap-3`},Fp={key:0,class:`text-sm text-destructive`},Ip={class:`text-sm text-muted-foreground`},Lp=R({__name:`ChartsView`,setup(e){let t=ye(),n=kp(),{query:r,normalized:i,hasQuery:a}=Pe(),o=M(()=>{let e=t.usage?.users??[],r=t.usage?.groups??[],o=e.filter(e=>!a.value||Ne(e,i.value)||`user:${e.id}`===n.scope).map(e=>({value:`user:${e.id}`,label:e.id})),s=r.filter(t=>!a.value||Ve(t,e,i.value)||`group:${t.id}`===n.scope).map(e=>({value:`group:${e.id}`,label:e.id})),c=(n.modelOptions??[]).filter(e=>!a.value||e.id.toLowerCase().includes(i.value)||`model:${e.id}`===n.scope).map(e=>({value:`model:${e.id}`,label:e.id}));return n.scope.startsWith(`model:`)&&!c.some(e=>e.value===n.scope)&&c.push({value:n.scope,label:n.scope.slice(6)}),[{value:`total`,label:`Total (all traffic)`},...s,...o,...c]}),s=[`hour`,`day`,`month`],c=[`cost`,`req`,`tokin`,`tokout`],l=M(()=>n.tab===`models`?`requests`:n.tab);function u(e){n.setTab(e)}function d(e){typeof e==`string`&&n.setScope(e)}function f(e){typeof e==`string`&&n.setModelMetric(e)}return Me(()=>{n.refresh(),n.startAutoRefresh()}),we(()=>{n.stopAutoRefresh()}),V(o,e=>{e.some(e=>e.value===n.scope)||n.setScope(`total`)}),(e,t)=>(N(),I(b(Ge),null,{default:B(()=>[L(b(Se),{class:`flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between`},{default:B(()=>[L(b(Ce),null,{default:B(()=>[...t[2]||=[ge(`Usage charts`,-1)]]),_:1}),He(`div`,Pp,[L(Be,{modelValue:b(r),"onUpdate:modelValue":t[0]||=e=>E(r)?r.value=e:null,placeholder:`Filter users, groups or models`,class:`w-56`},null,8,[`modelValue`]),b(n).tab===`models`?(N(),I(b(Xi),{key:0,"model-value":b(n).modelMetric,"onUpdate:modelValue":f},{default:B(()=>[L(b(na),{class:`w-40`,"aria-label":`Rank models by`},{default:B(()=>[L(b(ra),{placeholder:`Rank by`})]),_:1}),L(b(Zi),null,{default:B(()=>[(N(),P(k,null,me(c,e=>L(b($i),{key:e,value:e},{default:B(()=>[ge(ce(b(Sp)[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`])):(N(),I(b(Xi),{key:1,"model-value":b(n).scope,"onUpdate:modelValue":d},{default:B(()=>[L(b(na),{class:`w-56`},{default:B(()=>[L(b(ra),{placeholder:`Scope`})]),_:1}),L(b(Zi),null,{default:B(()=>[(N(!0),P(k,null,me(o.value,e=>(N(),I(b($i),{key:e.value,value:e.value},{default:B(()=>[ge(ce(e.label),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])),L(b(he),{"model-value":b(n).window,"onUpdate:modelValue":t[1]||=e=>b(n).setWindow(e)},{default:B(()=>[L(b(Te),null,{default:B(()=>[(N(),P(k,null,me(s,e=>L(b(Re),{key:e,value:e},{default:B(()=>[ge(ce(b(Dp)[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`])])]),_:1}),L(b(pe),{class:`flex flex-col gap-4`},{default:B(()=>[L(b(he),{"model-value":b(n).tab,"onUpdate:modelValue":u},{default:B(()=>[L(b(Te),null,{default:B(()=>[L(b(Re),{value:`requests`},{default:B(()=>[...t[3]||=[ge(`Requests`,-1)]]),_:1}),L(b(Re),{value:`tokens`},{default:B(()=>[...t[4]||=[ge(`Tokens`,-1)]]),_:1}),L(b(Re),{value:`cost`},{default:B(()=>[...t[5]||=[ge(`Cost`,-1)]]),_:1}),L(b(Re),{value:`models`},{default:B(()=>[...t[6]||=[ge(`Models`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`]),b(n).error?(N(),P(`p`,Fp,ce(b(n).error),1)):ze(``,!0),b(n).tab===`models`?(N(),P(k,{key:1},[He(`p`,Ip,` Models with usage in the selected window, ranked by `+ce(b(Sp)[b(n).modelMetric].toLowerCase())+`. Each row is the provider that served the traffic, so a model reached through more than one provider appears once per provider. `,1),L(jp,{metric:b(n).modelMetric,models:b(n).modelRanking},null,8,[`metric`,`models`])],64)):(N(),I(Np,{key:2,tab:l.value,window:b(n).window,"series-by-metric":b(n).seriesByMetric},null,8,[`tab`,`window`,`series-by-metric`]))]),_:1})]),_:1}))}});export{Lp as default};", + "import{$ as e,A as t,At as n,B as r,Bt as i,C as a,Ct as o,D as s,Dt as c,E as l,Et as u,F as d,Ft as f,G as p,H as m,I as h,It as g,J as _,K as v,L as y,Lt as b,M as x,Mt as S,N as C,Nt as w,O as T,Ot as E,P as D,Pt as O,Q as k,R as ee,Rt as te,S as ne,St as re,T as ie,Tt as ae,U as oe,V as se,Vt as ce,W as le,X as ue,Y as de,Z as fe,_ as pe,_t as me,a as he,at as ge,b as A,c as _e,ct as ve,d as ye,dt as j,et as M,f as be,ft as xe,g as Se,gt as N,h as Ce,ht as we,i as Te,it as P,j as Ee,jt as F,k as De,kt as Oe,l as ke,lt as Ae,m as je,mt as Me,n as Ne,nt as I,o as Pe,ot as L,p as Fe,pt as Ie,q as Le,r as Re,rt as ze,s as Be,st as R,t as Ve,tt as He,u as Ue,ut as We,v as Ge,vt as z,w as Ke,wt as B,x as qe,xt as V,y as Je,yt as Ye,z as Xe,zt as Ze}from"./index-CwP_MbOb.js";function Qe(e,t=-1/0,n=1/0){return Math.min(n,Math.max(t,e))}function $e(e,t,n){let r=n.originalEvent.target,i=new CustomEvent(e,{bubbles:!1,cancelable:!0,detail:n});t&&r.addEventListener(e,t,{once:!0}),r.dispatchEvent(i)}var et=n({layersRoot:new Set,layersWithOutsidePointerEventsDisabled:new Set,originalBodyPointerEvents:void 0,branches:new Set});function tt(e){if(typeof e!=`object`||!e)return!1;let t=Object.getPrototypeOf(e);return t!==null&&t!==Object.prototype&&Object.getPrototypeOf(t)!==null||Symbol.iterator in e?!1:Symbol.toStringTag in e?Object.prototype.toString.call(e)===`[object Module]`:!0}function nt(e,t,n=`.`,r){if(!tt(t))return nt(e,{},n,r);let i={...t};for(let t of Object.keys(e)){if(t===`__proto__`||t===`constructor`)continue;let a=e[t];a!=null&&(r&&r(i,t,a,n)||(i[t]=Array.isArray(a)&&Array.isArray(i[t])?[...a,...i[t]]:tt(a)&&tt(i[t])?nt(a,i[t],(n?`${n}.`:``)+t.toString(),r):a))}return i}function rt(e){return(...t)=>t.reduce((t,n)=>nt(t,n,``,e),{})}var it=rt(),at=d(()=>{let e=F(new Map),n=F(),r=M(()=>{for(let t of e.value.values())if(t)return!0;return!1}),i=s({scrollBody:F(!0)}),a=null,o=()=>{document.body.style.paddingRight=``,document.body.style.marginRight=``,et.layersWithOutsidePointerEventsDisabled.size===0&&(document.body.style.pointerEvents=``),document.documentElement.style.removeProperty(`--scrollbar-width`),document.body.style.overflow=n.value??``,y&&a?.(),n.value=void 0};return V(r,(e,s)=>{if(!h)return;if(!e){s&&o();return}n.value===void 0&&(n.value=document.body.style.overflow);let c=window.innerWidth-document.documentElement.clientWidth,l={padding:c,margin:0},u=i.scrollBody?.value?typeof i.scrollBody.value==`object`?it({padding:i.scrollBody.value.padding===!0?c:i.scrollBody.value.padding,margin:i.scrollBody.value.margin===!0?c:i.scrollBody.value.margin},l):l:{padding:0,margin:0};c>0&&(document.body.style.paddingRight=typeof u.padding==`number`?`${u.padding}px`:String(u.padding),document.body.style.marginRight=typeof u.margin==`number`?`${u.margin}px`:String(u.margin),document.documentElement.style.setProperty(`--scrollbar-width`,`${c}px`),document.body.style.overflow=`hidden`),y&&(a=t(document,`touchmove`,e=>ct(e),{passive:!1})),xe(()=>{r.value&&(document.body.style.pointerEvents=`none`,document.body.style.overflow=`hidden`)})},{immediate:!0,flush:`sync`}),e});function ot(e){let t=Math.random().toString(36).substring(2,7),n=at();n.value.set(t,e??!1);let i=M({get:()=>n.value.get(t)??!1,set:e=>n.value.set(t,e)});return r(()=>{n.value.delete(t)}),i}function st(e){let t=window.getComputedStyle(e);if(t.overflowX===`scroll`||t.overflowY===`scroll`||t.overflowX===`auto`&&e.clientWidth<e.scrollWidth||t.overflowY===`auto`&&e.clientHeight<e.scrollHeight)return!0;{let t=e.parentNode;return!(t instanceof Element)||t.tagName===`BODY`?!1:st(t)}}function ct(e){let t=e||window.event,n=t.target;return n instanceof Element&&st(n)?!1:t.touches.length>1||(t.preventDefault&&t.cancelable&&t.preventDefault(),!1)}var lt=0;function ut(){re(e=>{if(!h)return;let t=document.querySelectorAll(`[data-reka-focus-guard]`);document.body.insertAdjacentElement(`afterbegin`,t[0]??dt()),document.body.insertAdjacentElement(`beforeend`,t[1]??dt()),lt++,e(()=>{lt===1&&document.querySelectorAll(`[data-reka-focus-guard]`).forEach(e=>e.remove()),lt--})})}function dt(){let e=document.createElement(`span`);return e.setAttribute(`data-reka-focus-guard`,``),e.tabIndex=0,e.style.outline=`none`,e.style.opacity=`0`,e.style.position=`fixed`,e.style.pointerEvents=`none`,e}function ft(e){return M(()=>!g(e)||!!De(e)?.closest(`form`))}var pt=function(e){return typeof document>`u`?null:(Array.isArray(e)?e[0]:e).ownerDocument.body},mt=new WeakMap,ht=new WeakMap,gt={},_t=0,vt=function(e){return e&&(e.host||vt(e.parentNode))},yt=function(e,t){return t.map(function(t){if(e.contains(t))return t;var n=vt(t);return n&&e.contains(n)?n:(console.error(`aria-hidden`,t,`in not contained inside`,e,`. Doing nothing`),null)}).filter(function(e){return!!e})},bt=function(e,t,n,r){var i=yt(t,Array.isArray(e)?e:[e]);gt[n]||(gt[n]=new WeakMap);var a=gt[n],o=[],s=new Set,c=new Set(i),l=function(e){!e||s.has(e)||(s.add(e),l(e.parentNode))};i.forEach(l);var u=function(e){!e||c.has(e)||Array.prototype.forEach.call(e.children,function(e){if(s.has(e))u(e);else try{var t=e.getAttribute(r),i=t!==null&&t!==`false`,c=(mt.get(e)||0)+1,l=(a.get(e)||0)+1;mt.set(e,c),a.set(e,l),o.push(e),c===1&&i&&ht.set(e,!0),l===1&&e.setAttribute(n,`true`),i||e.setAttribute(r,`true`)}catch(t){console.error(`aria-hidden: cannot operate on `,e,t)}})};return u(t),s.clear(),_t++,function(){o.forEach(function(e){var t=mt.get(e)-1,i=a.get(e)-1;mt.set(e,t),a.set(e,i),t||(ht.has(e)||e.removeAttribute(r),ht.delete(e)),i||e.removeAttribute(n)}),_t--,_t||(mt=new WeakMap,mt=new WeakMap,ht=new WeakMap,gt={})}},xt=function(e,t,n){n===void 0&&(n=`data-aria-hidden`);var r=Array.from(Array.isArray(e)?e:[e]),i=t||pt(e);return i?(r.push.apply(r,Array.from(i.querySelectorAll(`[aria-live], script`))),bt(r,i,n,`aria-hidden`)):function(){return null}};function St(e){let t;V(()=>De(e),e=>{let n=!1;try{n=!!e?.closest(`[popover]:not(:popover-open)`)}catch{}e&&!n?t=xt(e):t&&t()}),we(()=>{t&&t()})}function Ct(e){let t=F(),n=M(()=>t.value?.width??0),r=M(()=>t.value?.height??0),i;return Me(()=>{let n=De(e);n?(t.value={width:n.offsetWidth,height:n.offsetHeight},i=new ResizeObserver(e=>{if(!Array.isArray(e)||!e.length)return;let r=e[0],i,a;if(`borderBoxSize`in r){let e=r.borderBoxSize,t=Array.isArray(e)?e[0]:e;i=t.inlineSize,a=t.blockSize}else i=n.offsetWidth,a=n.offsetHeight;t.value={width:i,height:a}}),i.observe(n,{box:`border-box`})):t.value=void 0}),we(()=>{i?.disconnect(),i=void 0}),{width:n,height:r}}function wt(e){let t=Xe(``,1e3);return{search:t,handleTypeaheadSearch:(n,r)=>{if(t.value+=n,e)e(n);else{let e=m(),n=r.map(e=>({...e,textValue:e.value?.textValue??e.ref.textContent?.trim()??``})),i=n.find(t=>t.ref===e),a=Et(n.map(e=>e.textValue),t.value,i?.textValue),o=n.find(e=>e.textValue===a);return o&&o.ref.focus(),o?.ref}},resetTypeahead:()=>{t.value=``}}}function Tt(e,t){return e.map((n,r)=>e[(t+r)%e.length])}function Et(e,t,n){let r=t.length>1&&Array.from(t).every(e=>e===t[0])?t[0]:t,i=n?e.indexOf(n):-1,a=Tt(e,Math.max(i,0));r.length===1&&(a=a.filter(e=>e!==n));let o=a.find(e=>e.toLowerCase().startsWith(r.toLowerCase()));return o===n?void 0:o}var Dt=`dismissableLayer.pointerDownOutside`,Ot=`dismissableLayer.focusOutside`;function kt(e,t){if(!(t instanceof Element))return!1;let n=t.closest(`[data-dismissable-layer]`),r=e.dataset.dismissableLayer===``?e:e.querySelector(`[data-dismissable-layer]`),i=Array.from(e.ownerDocument.querySelectorAll(`[data-dismissable-layer]`));return!!(n&&(r===n||i.indexOf(r)<i.indexOf(n)))}function At(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=F(!1),a=F(()=>{});return re(o=>{if(!h||!g(n))return;let s=async n=>{let o=n.target;if(!(!t?.value||!o)){if(kt(t.value,o)){i.value=!1;return}if(n.target&&!i.value){let t={originalEvent:n};function i(){$e(Dt,e,t)}n.pointerType===`touch`?(r.removeEventListener(`click`,a.value),a.value=i,r.addEventListener(`click`,a.value,{once:!0})):i()}else r.removeEventListener(`click`,a.value);i.value=!1}},c=window.setTimeout(()=>{r.addEventListener(`pointerdown`,s)},0);o(()=>{window.clearTimeout(c),r.removeEventListener(`pointerdown`,s),r.removeEventListener(`click`,a.value)})}),{onPointerDownCapture:()=>{g(n)&&(i.value=!0)}}}function jt(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=F(!1);return re(a=>{if(!h||!g(n))return;let o=async n=>{if(!t?.value)return;await xe(),await xe();let r=n.target;!t.value||!r||kt(t.value,r)||n.target&&!i.value&&$e(Ot,e,{originalEvent:n})};r.addEventListener(`focusin`,o),a(()=>r.removeEventListener(`focusin`,o))}),{onFocusCapture:()=>{g(n)&&(i.value=!0)},onBlurCapture:()=>{g(n)&&(i.value=!1)}}}var Mt=R({__name:`DismissableLayer`,props:{disableOutsidePointerEvents:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},present:{type:Boolean,required:!1,default:!0}},emits:[`escapeKeyDown`,`pointerDownOutside`,`focusOutside`,`interactOutside`,`dismiss`],setup(e,{emit:t}){let n=e,r=t,{forwardRef:a,currentElement:o}=ie(),s=M(()=>o.value?.ownerDocument??globalThis.document),c=M(()=>et.layersRoot),l=M(()=>o.value?Array.from(c.value).indexOf(o.value):-1),u=M(()=>et.layersWithOutsidePointerEventsDisabled.size>0),d=M(()=>{let e=Array.from(c.value),[t]=[...et.layersWithOutsidePointerEventsDisabled].slice(-1),n=e.indexOf(t);return l.value>=n}),f=At(async e=>{let t=[...et.branches].some(t=>t?.contains(e.target));!n.present||!d.value||t||(r(`pointerDownOutside`,e),r(`interactOutside`,e),await xe(),e.defaultPrevented||r(`dismiss`))},o),p=jt(e=>{let t=[...et.branches].some(t=>t?.contains(e.target));!n.present||t||(r(`focusOutside`,e),r(`interactOutside`,e),e.defaultPrevented||r(`dismiss`))},o);return T(`Escape`,e=>{n.present&&l.value===c.value.size-1&&(r(`escapeKeyDown`,e),e.defaultPrevented||r(`dismiss`))}),V([o,()=>n.disableOutsidePointerEvents,()=>n.present],([e,t,n],r,i)=>{!e||!n||t&&(et.layersWithOutsidePointerEventsDisabled.size===0&&(et.originalBodyPointerEvents=s.value.body.style.pointerEvents,s.value.body.style.pointerEvents=`none`),et.layersWithOutsidePointerEventsDisabled.add(e),i(()=>{et.layersWithOutsidePointerEventsDisabled.delete(e),et.layersWithOutsidePointerEventsDisabled.size===0&&!se(et.originalBodyPointerEvents)&&(s.value.body.style.pointerEvents=et.originalBodyPointerEvents)}))},{immediate:!0}),V([o,()=>n.present],([e,t],n,r)=>{!e||!t||(c.value.add(e),r(()=>{c.value.delete(e)}))},{immediate:!0}),re(e=>{e(()=>{o.value&&(c.value.delete(o.value),et.layersWithOutsidePointerEventsDisabled.delete(o.value))})}),(e,t)=>(N(),I(b(A),{ref:b(a),"as-child":e.asChild,as:e.as,"data-dismissable-layer":``,style:i({pointerEvents:u.value?d.value?`auto`:`none`:void 0}),onFocusCapture:b(p).onFocusCapture,onBlurCapture:b(p).onBlurCapture,onPointerdownCapture:b(f).onPointerDownCapture},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`style`,`onFocusCapture`,`onBlurCapture`,`onPointerdownCapture`]))}}),Nt=D(()=>F([]));function Pt(){let e=Nt();return{add(t){let n=e.value[0];t!==n&&n?.pause(),e.value=Ft(e.value,t),e.value.unshift(t)},remove(t){e.value=Ft(e.value,t),e.value[0]?.resume()}}}function Ft(e,t){let n=[...e],r=n.indexOf(t);return r!==-1&&n.splice(r,1),n}var It=`focusScope.autoFocusOnMount`,Lt=`focusScope.autoFocusOnUnmount`,Rt={bubbles:!1,cancelable:!0};function zt(e,{select:t=!1}={}){let n=m();for(let r of e)if(Gt(r,{select:t}),m()!==n)return!0}function Bt(e){let t=Vt(e);return[Ht(t,e),Ht(t.reverse(),e)]}function Vt(e){let t=[],n=document.createTreeWalker(e,NodeFilter.SHOW_ELEMENT,{acceptNode:e=>{let t=e.tagName===`INPUT`&&e.type===`hidden`;return e.disabled||e.hidden||t?NodeFilter.FILTER_SKIP:e.tabIndex>=0?NodeFilter.FILTER_ACCEPT:NodeFilter.FILTER_SKIP}});for(;n.nextNode();)t.push(n.currentNode);return t}function Ht(e,t){for(let n of e)if(!Ut(n,{upTo:t}))return n}function Ut(e,{upTo:t}){if(getComputedStyle(e).visibility===`hidden`)return!0;for(;e;){if(t!==void 0&&e===t)return!1;if(getComputedStyle(e).display===`none`)return!0;e=e.parentElement}return!1}function Wt(e){return e instanceof HTMLInputElement&&`select`in e}function Gt(e,{select:t=!1}={}){if(e&&e.focus){let n=m();e.focus({preventScroll:!0}),e!==n&&Wt(e)&&t&&e.select()}}var Kt=R({__name:`FocusScope`,props:{loop:{type:Boolean,required:!1,default:!1},trapped:{type:Boolean,required:!1,default:!1},present:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`mountAutoFocus`,`unmountAutoFocus`],setup(e,{emit:t}){let r=e,i=t,{currentRef:a,currentElement:o}=ie(),s=F(null),c=Pt(),l=n({paused:!1,pause(){this.paused=!0},resume(){this.paused=!1}});re(e=>{if(!h)return;let t=o.value;if(!r.trapped)return;function n(e){if(l.paused||!t)return;let n=e.target;t.contains(n)?s.value=n:Gt(s.value,{select:!0})}function i(e){if(l.paused||!t)return;let n=e.relatedTarget;n!==null&&(t.contains(n)||Gt(s.value,{select:!0}))}function a(e){let n=s.value;n!==null&&e.some(e=>e.removedNodes.length>0)&&(t.contains(n)||Gt(t))}document.addEventListener(`focusin`,n),document.addEventListener(`focusout`,i);let c=new MutationObserver(a);t&&c.observe(t,{childList:!0,subtree:!0}),e(()=>{document.removeEventListener(`focusin`,n),document.removeEventListener(`focusout`,i),c.disconnect()})});function u(e,t){let n=new CustomEvent(It,Rt),r=e=>i(`mountAutoFocus`,e);e.addEventListener(It,r),e.dispatchEvent(n),e.removeEventListener(It,r),n.defaultPrevented||(zt(Vt(e),{select:!0}),m()===t&&Gt(e))}re(async e=>{let t=o.value;if(await xe(),!t)return;r.present!==!1&&c.add(l);let n=m();!t.contains(n)&&r.present!==!1&&u(t,n),e(()=>{let e=new CustomEvent(Lt,Rt),r=e=>{i(`unmountAutoFocus`,e)};t.addEventListener(Lt,r),t.dispatchEvent(e),t.setAttribute(`data-focus-scope-unmounting`,``),setTimeout(()=>{e.defaultPrevented||Gt(n??document.body,{select:!0}),t.removeEventListener(Lt,r),c.remove(l),t.removeAttribute(`data-focus-scope-unmounting`)},0)})}),V(()=>r.present,async(e,t)=>{if(!h)return;if(e===!1&&t===!0){c.remove(l);return}if(e!==!0||t!==!1)return;c.add(l),await xe();let n=o.value;if(!n)return;let r=m();n.contains(r)||u(n,r)});function d(e){if(!r.loop&&!r.trapped||l.paused)return;let t=e.key===`Tab`&&!e.altKey&&!e.ctrlKey&&!e.metaKey,n=m();if(t&&n){let t=e.currentTarget,[i,a]=Bt(t);i&&a?!e.shiftKey&&n===a?(e.preventDefault(),r.loop&&Gt(i,{select:!0})):e.shiftKey&&n===i&&(e.preventDefault(),r.loop&&Gt(a,{select:!0})):n===t&&e.preventDefault()}}return(e,t)=>(N(),I(b(A),{ref_key:`currentRef`,ref:a,tabindex:`-1`,"as-child":e.asChild,as:e.as,onKeydown:d},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as-child`,`as`]))}}),qt=[`Enter`,` `],Jt=[`ArrowDown`,`PageUp`,`Home`],Yt=[`ArrowUp`,`PageDown`,`End`];[...Jt,...Yt],[...qt],[...qt];function Xt(e){let t=m();for(let n of e)if(n===t||(n.focus(),m()!==t))return}var Zt=R({__name:`Teleport`,props:{to:{type:null,required:!1},disabled:{type:Boolean,required:!1},defer:{type:Boolean,required:!1},forceMount:{type:Boolean,required:!1}},setup(t){let n=t,r=s({}),i=M(()=>n.to??r.teleportTo?.value??`body`),a=Ee();return(t,n)=>b(a)||t.forceMount?(N(),I(e,{key:0,to:i.value,disabled:t.disabled,defer:t.defer},[z(t.$slots,`default`)],8,[`to`,`disabled`,`defer`])):ze(`v-if`,!0)}}),Qt=R({__name:`VisuallyHidden`,props:{feature:{type:String,required:!1,default:`focusable`},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(N(),I(b(A),{as:e.as,"as-child":e.asChild,"aria-hidden":e.feature===`focusable`||e.feature===`fully-hidden`?`true`:void 0,"data-hidden":e.feature===`fully-hidden`?``:void 0,tabindex:e.feature===`fully-hidden`?`-1`:void 0,style:{position:`absolute`,border:0,width:`1px`,height:`1px`,padding:0,margin:`-1px`,overflow:`hidden`,clip:`rect(0, 0, 0, 0)`,clipPath:`inset(50%)`,whiteSpace:`nowrap`,wordWrap:`normal`,top:`-1px`,left:`-1px`}},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`aria-hidden`,`data-hidden`,`tabindex`]))}}),[$t,en]=oe(`PopperRoot`),tn=R({inheritAttrs:!1,__name:`PopperRoot`,setup(e){let t=F();return en({anchor:t,onAnchorChange:e=>t.value=e}),(e,t)=>z(e.$slots,`default`)}}),nn=R({__name:`PopperAnchor`,props:{reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{forwardRef:n,currentElement:r}=ie(),i=$t();return o(()=>{i.onAnchorChange(t.reference??r.value)}),(e,t)=>(N(),I(b(A),{ref:b(n),as:e.as,"as-child":e.asChild},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as`,`as-child`]))}});function rn(e){return e!==null}function an(e){return{name:`transformOrigin`,options:e,fn(t){let{placement:n,rects:r,middlewareData:i}=t,a=i.arrow?.centerOffset!==0,o=a?0:e.arrowWidth,s=a?0:e.arrowHeight,[c,l]=on(n),u={start:e.dir===`rtl`?`100%`:`0%`,center:`50%`,end:e.dir===`rtl`?`0%`:`100%`}[l],d={start:`0%`,center:`50%`,end:`100%`}[l],f=(i.arrow?.x??0)+o/2,p=(i.arrow?.y??0)+s/2,m=``,h=``;return c===`bottom`?(m=a?u:`${f}px`,h=`${-s}px`):c===`top`?(m=a?u:`${f}px`,h=`${r.floating.height+s}px`):c===`right`?(m=`${-s}px`,h=a?d:`${p}px`):c===`left`&&(m=`${r.floating.width+s}px`,h=a?d:`${p}px`),{data:{x:m,y:h}}}}}function on(e){let[t,n=`center`]=e.split(`-`);return[t,n]}var sn=[`top`,`right`,`bottom`,`left`],cn=Math.min,ln=Math.max,un=Math.round,dn=Math.floor,fn=e=>({x:e,y:e}),pn={left:`right`,right:`left`,bottom:`top`,top:`bottom`};function mn(e,t,n){return ln(e,cn(t,n))}function hn(e,t){return typeof e==`function`?e(t):e}function gn(e){return e.split(`-`)[0]}function _n(e){return e.split(`-`)[1]}function vn(e){return e===`x`?`y`:`x`}function yn(e){return e===`y`?`height`:`width`}function bn(e){let t=e[0];return t===`t`||t===`b`?`y`:`x`}function xn(e){return vn(bn(e))}function Sn(e,t,n){n===void 0&&(n=!1);let r=_n(e),i=xn(e),a=yn(i),o=i===`x`?r===(n?`end`:`start`)?`right`:`left`:r===`start`?`bottom`:`top`;return t.reference[a]>t.floating[a]&&(o=jn(o)),[o,jn(o)]}function Cn(e){let t=jn(e);return[wn(e),t,wn(t)]}function wn(e){return e.includes(`start`)?e.replace(`start`,`end`):e.replace(`end`,`start`)}var Tn=[`left`,`right`],En=[`right`,`left`],Dn=[`top`,`bottom`],On=[`bottom`,`top`];function kn(e,t,n){switch(e){case`top`:case`bottom`:return n?t?En:Tn:t?Tn:En;case`left`:case`right`:return t?Dn:On;default:return[]}}function An(e,t,n,r){let i=_n(e),a=kn(gn(e),n===`start`,r);return i&&(a=a.map(e=>e+`-`+i),t&&(a=a.concat(a.map(wn)))),a}function jn(e){let t=gn(e);return pn[t]+e.slice(t.length)}function Mn(e){return{top:e.top??0,right:e.right??0,bottom:e.bottom??0,left:e.left??0}}function Nn(e){return typeof e==`number`?{top:e,right:e,bottom:e,left:e}:Mn(e)}function Pn(e){let{x:t,y:n,width:r,height:i}=e;return{width:r,height:i,top:n,left:t,right:t+r,bottom:n+i,x:t,y:n}}function Fn(e,t,n){let{reference:r,floating:i}=e,a=bn(t),o=xn(t),s=yn(o),c=gn(t),l=a===`y`,u=r.x+r.width/2-i.width/2,d=r.y+r.height/2-i.height/2,f=r[s]/2-i[s]/2,p;switch(c){case`top`:p={x:u,y:r.y-i.height};break;case`bottom`:p={x:u,y:r.y+r.height};break;case`right`:p={x:r.x+r.width,y:d};break;case`left`:p={x:r.x-i.width,y:d};break;default:p={x:r.x,y:r.y}}let m=_n(t);return m&&(p[o]+=f*(m===`end`?1:-1)*(n&&l?-1:1)),p}async function In(e,t){t===void 0&&(t={});let{x:n,y:r,platform:i,rects:a,elements:o,strategy:s}=e,{boundary:c=`clippingAncestors`,rootBoundary:l=`viewport`,elementContext:u=`floating`,altBoundary:d=!1,padding:f=0}=hn(t,e),p=Nn(f),m=o[d?u===`floating`?`reference`:`floating`:u],h=Pn(await i.getClippingRect({element:await(i.isElement==null?void 0:i.isElement(m))??!0?m:m.contextElement||await(i.getDocumentElement==null?void 0:i.getDocumentElement(o.floating)),boundary:c,rootBoundary:l,strategy:s})),g=u===`floating`?{x:n,y:r,width:a.floating.width,height:a.floating.height}:a.reference,_=await(i.getOffsetParent==null?void 0:i.getOffsetParent(o.floating)),v=await(i.isElement==null?void 0:i.isElement(_))&&await(i.getScale==null?void 0:i.getScale(_))||{x:1,y:1},y=Pn(i.convertOffsetParentRelativeRectToViewportRelativeRect?await i.convertOffsetParentRelativeRectToViewportRelativeRect({elements:o,rect:g,offsetParent:_,strategy:s}):g);return{top:(h.top-y.top+p.top)/v.y,bottom:(y.bottom-h.bottom+p.bottom)/v.y,left:(h.left-y.left+p.left)/v.x,right:(y.right-h.right+p.right)/v.x}}var Ln=50,Rn=async(e,t,n)=>{let{placement:r=`bottom`,strategy:i=`absolute`,middleware:a=[],platform:o}=n,s=o.detectOverflow?o:{...o,detectOverflow:In},c=await(o.isRTL==null?void 0:o.isRTL(t)),l=await o.getElementRects({reference:e,floating:t,strategy:i}),{x:u,y:d}=Fn(l,r,c),f=r,p=0,m={};for(let n=0;n<a.length;n++){let h=a[n];if(!h)continue;let{name:g,fn:_}=h,{x:v,y,data:b,reset:x}=await _({x:u,y:d,initialPlacement:r,placement:f,strategy:i,middlewareData:m,rects:l,platform:s,elements:{reference:e,floating:t}});u=v??u,d=y??d,m[g]={...m[g],...b},x&&p<Ln&&(p++,typeof x==`object`&&(x.placement&&(f=x.placement),x.rects&&(l=x.rects===!0?await o.getElementRects({reference:e,floating:t,strategy:i}):x.rects),{x:u,y:d}=Fn(l,f,c)),n=-1)}return{x:u,y:d,placement:f,strategy:i,middlewareData:m}},zn=e=>({name:`arrow`,options:e,async fn(t){let{x:n,y:r,placement:i,rects:a,platform:o,elements:s,middlewareData:c}=t,{element:l,padding:u=0}=hn(e,t)||{};if(l==null)return{};let d=Nn(u),f={x:n,y:r},p=xn(i),m=yn(p),h=await o.getDimensions(l),g=p===`y`,_=g?`top`:`left`,v=g?`bottom`:`right`,y=g?`clientHeight`:`clientWidth`,b=a.reference[m]+a.reference[p]-f[p]-a.floating[m],x=f[p]-a.reference[p],S=await(o.getOffsetParent==null?void 0:o.getOffsetParent(l)),C=S?S[y]:0;(!C||!await(o.isElement==null?void 0:o.isElement(S)))&&(C=s.floating[y]||a.floating[m]);let w=b/2-x/2,T=C/2-h[m]/2-1,E=cn(d[_],T),D=cn(d[v],T),O=C-h[m]-D,k=C/2-h[m]/2+w,ee=mn(E,k,O),te=!c.arrow&&_n(i)!=null&&k!==ee&&a.reference[m]/2-(k<E?E:D)-h[m]/2<0,ne=te?k<E?k-E:k-O:0;return{[p]:f[p]+ne,data:{[p]:ee,centerOffset:k-ee-ne,...te&&{alignmentOffset:ne}},reset:te}}}),Bn=function(e){return e===void 0&&(e={}),{name:`flip`,options:e,async fn(t){var n;let{placement:r,middlewareData:i,rects:a,initialPlacement:o,platform:s,elements:c}=t,{mainAxis:l=!0,crossAxis:u=!0,fallbackPlacements:d,fallbackStrategy:f=`bestFit`,fallbackAxisSideDirection:p=`none`,flipAlignment:m=!0,...h}=hn(e,t);if((n=i.arrow)!=null&&n.alignmentOffset)return{};let g=gn(r),_=bn(o),v=gn(o)===o,y=await(s.isRTL==null?void 0:s.isRTL(c.floating)),b=d||(v||!m?[jn(o)]:Cn(o)),x=p!==`none`;!d&&x&&b.push(...An(o,m,p,y));let S=[o,...b],C=await s.detectOverflow(t,h),w=[],T=i.flip?.overflows||[];if(l&&w.push(C[g]),u){let e=Sn(r,a,y);w.push(C[e[0]],C[e[1]])}if(T=[...T,{placement:r,overflows:w}],!w.every(e=>e<=0)){let e=(i.flip?.index||0)+1,t=S[e];if(t&&(u!==`alignment`||_===bn(t)||T.every(e=>bn(e.placement)!==_||e.overflows[0]>0)))return{data:{index:e,overflows:T},reset:{placement:t}};let n=T.filter(e=>e.overflows[0]<=0).sort((e,t)=>e.overflows[1]-t.overflows[1])[0]?.placement;if(!n)switch(f){case`bestFit`:{let e=T.filter(e=>{if(x){let t=bn(e.placement);return t===_||t===`y`}return!0}).map(e=>[e.placement,e.overflows.filter(e=>e>0).reduce((e,t)=>e+t,0)]).sort((e,t)=>e[1]-t[1])[0]?.[0];e&&(n=e);break}case`initialPlacement`:n=o}if(r!==n)return{reset:{placement:n}}}return{}}}};function Vn(e,t){return{top:e.top-t.height,right:e.right-t.width,bottom:e.bottom-t.height,left:e.left-t.width}}function Hn(e){return sn.some(t=>e[t]>=0)}var Un=function(e){return e===void 0&&(e={}),{name:`hide`,options:e,async fn(t){let{rects:n,platform:r}=t,{strategy:i=`referenceHidden`,...a}=hn(e,t);switch(i){case`referenceHidden`:{let e=Vn(await r.detectOverflow(t,{...a,elementContext:`reference`}),n.reference);return{data:{referenceHiddenOffsets:e,referenceHidden:Hn(e)}}}case`escaped`:{let e=Vn(await r.detectOverflow(t,{...a,altBoundary:!0}),n.floating);return{data:{escapedOffsets:e,escaped:Hn(e)}}}default:return{}}}}},Wn=new Set([`left`,`top`]);async function Gn(e,t){let{placement:n,platform:r,elements:i}=e,a=await(r.isRTL==null?void 0:r.isRTL(i.floating)),o=gn(n),s=_n(n),c=bn(n)===`y`,l=Wn.has(o)?-1:1,u=a&&c?-1:1,d=hn(t,e),{mainAxis:f,crossAxis:p,alignmentAxis:m}=typeof d==`number`?{mainAxis:d,crossAxis:0,alignmentAxis:null}:{mainAxis:d.mainAxis||0,crossAxis:d.crossAxis||0,alignmentAxis:d.alignmentAxis};return s&&typeof m==`number`&&(p=s===`end`?m*-1:m),c?{x:p*u,y:f*l}:{x:f*l,y:p*u}}var Kn=function(e){return e===void 0&&(e=0),{name:`offset`,options:e,async fn(t){var n;let{x:r,y:i,placement:a,middlewareData:o}=t,s=await Gn(t,e);return a===o.offset?.placement&&(n=o.arrow)!=null&&n.alignmentOffset?{}:{x:r+s.x,y:i+s.y,data:{...s,placement:a}}}}},qn=function(e){return e===void 0&&(e={}),{name:`shift`,options:e,async fn(t){let{x:n,y:r,placement:i,platform:a}=t,{mainAxis:o=!0,crossAxis:s=!1,limiter:c={fn:e=>{let{x:t,y:n}=e;return{x:t,y:n}}},...l}=hn(e,t),u={x:n,y:r},d=await a.detectOverflow(t,l),f=bn(i),p=vn(f),m=u[p],h=u[f],g=(e,t)=>mn(t+d[e===`y`?`top`:`left`],t,t-d[e===`y`?`bottom`:`right`]);o&&(m=g(p,m)),s&&(h=g(f,h));let _=c.fn({...t,[p]:m,[f]:h});return{..._,data:{x:_.x-n,y:_.y-r,enabled:{[p]:o,[f]:s}}}}}},Jn=function(e){return e===void 0&&(e={}),{options:e,fn(t){let{x:n,y:r,placement:i,rects:a,middlewareData:o}=t,{offset:s=0,mainAxis:c=!0,crossAxis:l=!0}=hn(e,t),u={x:n,y:r},d=bn(i),f=vn(d),p=u[f],m=u[d],h=hn(s,t),g=typeof h==`number`?{mainAxis:h,crossAxis:0}:{mainAxis:h.mainAxis??0,crossAxis:h.crossAxis??0};if(c){let e=f===`y`?`height`:`width`,t=a.reference[f]-a.floating[e]+g.mainAxis,n=a.reference[f]+a.reference[e]-g.mainAxis;p<t?p=t:p>n&&(p=n)}if(l){let e=f===`y`?`width`:`height`,t=Wn.has(gn(i)),n=a.reference[d]-a.floating[e]+(t&&o.offset?.[d]||0)+(t?0:g.crossAxis),r=a.reference[d]+a.reference[e]+(t?0:o.offset?.[d]||0)-(t?g.crossAxis:0);m<n?m=n:m>r&&(m=r)}return{[f]:p,[d]:m}}}},Yn=function(e){return e===void 0&&(e={}),{name:`size`,options:e,async fn(t){let{placement:n,rects:r,platform:i,elements:a}=t,{apply:o=()=>{},...s}=hn(e,t),c=await i.detectOverflow(t,s),l=gn(n),u=_n(n),d=bn(n)===`y`,{width:f,height:p}=r.floating,m,h;l===`top`||l===`bottom`?(m=l,h=u===(await(i.isRTL==null?void 0:i.isRTL(a.floating))?`start`:`end`)?`left`:`right`):(h=l,m=u===`end`?`top`:`bottom`);let g=p-c.top-c.bottom,_=f-c.left-c.right,v=cn(p-c[m],g),y=cn(f-c[h],_),b=t.middlewareData.shift,x=!b,S=v,C=y;b!=null&&b.enabled.x&&(C=_),b!=null&&b.enabled.y&&(S=g),x&&!u&&(d?C=f-2*ln(c.left,c.right):S=p-2*ln(c.top,c.bottom)),await o({...t,availableWidth:C,availableHeight:S});let w=await i.getDimensions(a.floating);return f!==w.width||p!==w.height?{reset:{rects:!0}}:{}}}};function Xn(){return typeof window<`u`}function Zn(e){return $n(e)?(e.nodeName||``).toLowerCase():`#document`}function H(e){var t;return(e==null||(t=e.ownerDocument)==null?void 0:t.defaultView)||window}function Qn(e){return(($n(e)?e.ownerDocument:e.document)||window.document)?.documentElement}function $n(e){return Xn()?e instanceof Node||e instanceof H(e).Node:!1}function er(e){return Xn()?e instanceof Element||e instanceof H(e).Element:!1}function tr(e){return Xn()?e instanceof HTMLElement||e instanceof H(e).HTMLElement:!1}function nr(e){return!Xn()||typeof ShadowRoot>`u`?!1:e instanceof ShadowRoot||e instanceof H(e).ShadowRoot}function rr(e){let{overflow:t,overflowX:n,overflowY:r,display:i}=mr(e);return/auto|scroll|overlay|hidden|clip/.test(t+r+n)&&i!==`inline`&&i!==`contents`}function ir(e){return/^(table|td|th)$/.test(Zn(e))}function ar(e){try{if(e.matches(`:popover-open`))return!0}catch{}try{return e.matches(`:modal`)}catch{return!1}}var or=/transform|translate|scale|rotate|perspective|filter/,sr=/paint|layout|strict|content/,cr=e=>!!e&&e!==`none`,lr;function ur(e){let t=er(e)?mr(e):e;return cr(t.transform)||cr(t.translate)||cr(t.scale)||cr(t.rotate)||cr(t.perspective)||!fr()&&(cr(t.backdropFilter)||cr(t.filter))||or.test(t.willChange||``)||sr.test(t.contain||``)}function dr(e){let t=gr(e);for(;tr(t)&&!pr(t);){if(ur(t))return t;if(ar(t))return null;t=gr(t)}return null}function fr(){return lr??=typeof CSS<`u`&&CSS.supports&&CSS.supports(`-webkit-backdrop-filter`,`none`),lr}function pr(e){return/^(html|body|#document)$/.test(Zn(e))}function mr(e){return H(e).getComputedStyle(e)}function hr(e){return er(e)?{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}:{scrollLeft:e.scrollX,scrollTop:e.scrollY}}function gr(e){if(Zn(e)===`html`)return e;let t=e.assignedSlot||e.parentNode||nr(e)&&e.host||Qn(e);return nr(t)?t.host:t}function _r(e){let t=gr(e);return pr(t)?(e.ownerDocument||e).body:tr(t)&&rr(t)?t:_r(t)}function vr(e,t,n){t===void 0&&(t=[]),n===void 0&&(n=!0);let r=_r(e),i=r===e.ownerDocument?.body,a=H(r);if(i){let e=yr(a);return t.concat(a,a.visualViewport||[],rr(r)?r:[],e&&n?vr(e):[])}return t.concat(r,vr(r,[],n))}function yr(e){return e.parent&&Object.getPrototypeOf(e.parent)?e.frameElement:null}function br(e){let t=mr(e),n=parseFloat(t.width)||0,r=parseFloat(t.height)||0,i=tr(e),a=i?e.offsetWidth:n,o=i?e.offsetHeight:r,s=un(n)!==a||un(r)!==o;return s&&(n=a,r=o),{width:n,height:r,$:s}}function xr(e){return er(e)?e:e.contextElement}function Sr(e){let t=xr(e);if(!tr(t))return fn(1);let n=t.getBoundingClientRect(),{width:r,height:i,$:a}=br(t),o=(a?un(n.width):n.width)/r,s=(a?un(n.height):n.height)/i;return(!o||!Number.isFinite(o))&&(o=1),(!s||!Number.isFinite(s))&&(s=1),{x:o,y:s}}var Cr=fn(0);function wr(e){let t=H(e);return!fr()||!t.visualViewport?Cr:{x:t.visualViewport.offsetLeft,y:t.visualViewport.offsetTop}}function Tr(e,t,n){return t===void 0&&(t=!1),!!n&&t&&n===H(e)}function Er(e,t,n,r){t===void 0&&(t=!1),n===void 0&&(n=!1);let i=e.getBoundingClientRect(),a=xr(e),o=fn(1);t&&(r?er(r)&&(o=Sr(r)):o=Sr(e));let s=Tr(a,n,r)?wr(a):fn(0),c=(i.left+s.x)/o.x,l=(i.top+s.y)/o.y,u=i.width/o.x,d=i.height/o.y;if(a&&r){let e=H(a),t=er(r)?H(r):r,n=e,i=yr(n);for(;i&&t!==n;){let e=Sr(i),t=i.getBoundingClientRect(),r=mr(i),a=t.left+(i.clientLeft+parseFloat(r.paddingLeft))*e.x,o=t.top+(i.clientTop+parseFloat(r.paddingTop))*e.y;c*=e.x,l*=e.y,u*=e.x,d*=e.y,c+=a,l+=o,n=H(i),i=yr(n)}}return Pn({width:u,height:d,x:c,y:l})}function Dr(e,t){let n=hr(e).scrollLeft;return t?t.left+n:Er(Qn(e)).left+n}function Or(e,t){let n=e.getBoundingClientRect();return{x:n.left+t.scrollLeft-Dr(e,n),y:n.top+t.scrollTop}}function kr(e){let{elements:t,rect:n,offsetParent:r,strategy:i}=e,a=i===`fixed`,o=Qn(r),s=t?ar(t.floating):!1;if(r===o||s&&a)return n;let c={scrollLeft:0,scrollTop:0},l=fn(1),u=fn(0),d=tr(r);if((d||!a)&&((Zn(r)!==`body`||rr(o))&&(c=hr(r)),d)){let e=Er(r);l=Sr(r),u.x=e.x+r.clientLeft,u.y=e.y+r.clientTop}let f=o&&!d&&!a?Or(o,c):fn(0);return{width:n.width*l.x,height:n.height*l.y,x:n.x*l.x-c.scrollLeft*l.x+u.x+f.x,y:n.y*l.y-c.scrollTop*l.y+u.y+f.y}}function Ar(e){return e.getClientRects?Array.from(e.getClientRects()):[]}function jr(e){let t=hr(e),n=e.ownerDocument.body,r=ln(e.scrollWidth,e.clientWidth,n.scrollWidth,n.clientWidth),i=ln(e.scrollHeight,e.clientHeight,n.scrollHeight,n.clientHeight),a=-t.scrollLeft+Dr(e),o=-t.scrollTop;return mr(n).direction===`rtl`&&(a+=ln(e.clientWidth,n.clientWidth)-r),{width:r,height:i,x:a,y:o}}var Mr=25;function Nr(e,t,n){n===void 0&&(n=`viewport`);let r=n===`layoutViewport`,i=H(e),a=Qn(e),o=i.visualViewport,s=a.clientWidth,c=a.clientHeight,l=0,u=0;if(o){let e=!fr()||t===`fixed`;r?e||(l=-o.offsetLeft,u=-o.offsetTop):(s=o.width,c=o.height,e&&(l=o.offsetLeft,u=o.offsetTop))}if(Dr(a)<=0){let e=a.ownerDocument,t=e.body,n=getComputedStyle(t),r=e.compatMode===`CSS1Compat`&&parseFloat(n.marginLeft)+parseFloat(n.marginRight)||0,i=Math.abs(a.clientWidth-t.clientWidth-r),o=getComputedStyle(a).scrollbarGutter===`stable both-edges`?i/2:i;o<=Mr&&(s-=o)}return{width:s,height:c,x:l,y:u}}function Pr(e,t){let n=Er(e,!0,t===`fixed`),r=n.top+e.clientTop,i=n.left+e.clientLeft,a=Sr(e);return{width:e.clientWidth*a.x,height:e.clientHeight*a.y,x:i*a.x,y:r*a.y}}function Fr(e,t,n){let r;if(t===`viewport`||t===`layoutViewport`)r=Nr(e,n,t);else if(t===`document`)r=jr(Qn(e));else if(er(t))r=Pr(t,n);else{let n=wr(e);r={x:t.x-n.x,y:t.y-n.y,width:t.width,height:t.height}}return Pn(r)}function Ir(e,t){let n=t.get(e);if(n)return n;let r=vr(e,[],!1).filter(e=>er(e)&&Zn(e)!==`body`),i=null,a=mr(e).position===`fixed`,o=a?gr(e):e;for(;er(o)&&!pr(o);){let e=mr(o),t=ur(o),n=i?i.position:a?`fixed`:``;!t&&(n===`fixed`||n===`absolute`&&e.position===`static`)?r=r.filter(e=>e!==o):i=e,o=gr(o)}return t.set(e,r),r}function Lr(e){let{element:t,boundary:n,rootBoundary:r,strategy:i}=e,a=[...n===`clippingAncestors`?ar(t)?[]:Ir(t,this._c):[].concat(n),r],o=Fr(t,a[0],i),s=o.top,c=o.right,l=o.bottom,u=o.left;for(let e=1;e<a.length;e++){let n=Fr(t,a[e],i);s=ln(n.top,s),c=cn(n.right,c),l=cn(n.bottom,l),u=ln(n.left,u)}return{width:c-u,height:l-s,x:u,y:s}}function Rr(e){let{width:t,height:n}=br(e);return{width:t,height:n}}function zr(e,t,n){let r=tr(t),i=Qn(t),a=n===`fixed`,o=Er(e,!0,a,t),s={scrollLeft:0,scrollTop:0},c=fn(0);if((r||!a)&&((Zn(t)!==`body`||rr(i))&&(s=hr(t)),r)){let e=Er(t,!0,a,t);c.x=e.x+t.clientLeft,c.y=e.y+t.clientTop}!r&&i&&(c.x=Dr(i));let l=i&&!r&&!a?Or(i,s):fn(0);return{x:o.left+s.scrollLeft-c.x-l.x,y:o.top+s.scrollTop-c.y-l.y,width:o.width,height:o.height}}function Br(e){return mr(e).position===`static`}function Vr(e,t){if(!tr(e)||mr(e).position===`fixed`)return null;if(t)return t(e);let n=e.offsetParent;return Qn(e)===n&&(n=n.ownerDocument.body),n}function Hr(e,t){let n=H(e);if(ar(e))return n;if(!tr(e)){let t=gr(e);for(;t&&!pr(t);){if(er(t)&&!Br(t))return t;t=gr(t)}return n}let r=Vr(e,t);for(;r&&ir(r)&&Br(r);)r=Vr(r,t);return r&&pr(r)&&Br(r)&&!ur(r)?n:r||dr(e)||n}var Ur=async function(e){let t=this.getOffsetParent||Hr,n=this.getDimensions,r=await n(e.floating);return{reference:zr(e.reference,await t(e.floating),e.strategy),floating:{x:0,y:0,width:r.width,height:r.height}}};function Wr(e){return mr(e).direction===`rtl`}var Gr={convertOffsetParentRelativeRectToViewportRelativeRect:kr,getDocumentElement:Qn,getClippingRect:Lr,getOffsetParent:Hr,getElementRects:Ur,getClientRects:Ar,getDimensions:Rr,getScale:Sr,isElement:er,isRTL:Wr};function Kr(e,t){return e.x===t.x&&e.y===t.y&&e.width===t.width&&e.height===t.height}function qr(e,t,n){let r=null,i,a=Qn(e);function o(){var e;clearTimeout(i),(e=r)==null||e.disconnect(),r=null}function s(n,c){n===void 0&&(n=!1),c===void 0&&(c=1),o();let l=e.getBoundingClientRect(),{left:u,top:d,width:f,height:p}=l;if(n||t(),!f||!p)return;let m=dn(d),h=dn(a.clientWidth-(u+f)),g=dn(a.clientHeight-(d+p)),_=dn(u),v={rootMargin:-m+`px `+-h+`px `+-g+`px `+-_+`px`,threshold:ln(0,cn(1,c))||1},y=!0;function b(t){let n=t[0].intersectionRatio;if(!Kr(l,e.getBoundingClientRect()))return s();if(n!==c){if(!y)return s();n?s(!1,n):i=setTimeout(()=>{s(!1,1e-7)},1e3)}y=!1}try{r=new IntersectionObserver(b,{...v,root:a.ownerDocument})}catch{r=new IntersectionObserver(b,v)}r.observe(e)}let c=H(e),l=()=>s(n);return c.addEventListener(`resize`,l),s(!0),()=>{c.removeEventListener(`resize`,l),o()}}function Jr(e,t,n,r){r===void 0&&(r={});let{ancestorScroll:i=!0,ancestorResize:a=!0,elementResize:o=typeof ResizeObserver==`function`,layoutShift:s=typeof IntersectionObserver==`function`,animationFrame:c=!1}=r,l=xr(e),u=i||a?[...l?vr(l):[],...t?vr(t):[]]:[];u.forEach(e=>{i&&e.addEventListener(`scroll`,n),a&&e.addEventListener(`resize`,n)});let d=l&&s?qr(l,n,a):null,f=-1,p=null;o&&(p=new ResizeObserver(e=>{let[r]=e;r&&r.target===l&&p&&t&&(p.unobserve(t),cancelAnimationFrame(f),f=requestAnimationFrame(()=>{var e;(e=p)==null||e.observe(t)})),n()}),l&&!c&&p.observe(l),t&&p.observe(t));let m,h=c?Er(e):null;c&&g();function g(){let t=Er(e);h&&!Kr(h,t)&&n(),h=t,m=requestAnimationFrame(g)}return n(),()=>{var e;u.forEach(e=>{i&&e.removeEventListener(`scroll`,n),a&&e.removeEventListener(`resize`,n)}),d?.(),(e=p)==null||e.disconnect(),p=null,c&&cancelAnimationFrame(m)}}var Yr=Kn,Xr=qn,Zr=Bn,Qr=Yn,$r=Un,ei=zn,ti=Jn,ni=(e,t,n)=>{let r=new Map,i=n??{},a={...Gr,...i.platform,_c:r};return Rn(e,t,{...i,platform:a})};function ri(e){return typeof e==`object`&&!!e&&`$el`in e}function ii(e){if(ri(e)){let t=e.$el;return $n(t)&&Zn(t)===`#comment`?null:t}return e}function ai(e){return typeof e==`function`?e():b(e)}function oi(e){return{name:`arrow`,options:e,fn(t){let n=ii(ai(e.element));return n==null?{}:ei({element:n,padding:e.padding}).fn(t)}}}function si(e){return typeof window>`u`?1:(e.ownerDocument.defaultView||window).devicePixelRatio||1}function ci(e,t){let n=si(e);return Math.round(t*n)/n}function li(e,t,n){n===void 0&&(n={});let r=n.whileElementsMounted,i=M(()=>ai(n.open)??!0),a=M(()=>ai(n.middleware)),o=M(()=>ai(n.placement)??`bottom`),s=M(()=>ai(n.strategy)??`absolute`),c=M(()=>ai(n.transform)??!0),l=M(()=>ii(e.value)),d=M(()=>ii(t.value)),f=F(0),p=F(0),m=F(s.value),h=F(o.value),g=w({}),_=F(!1),v=M(()=>{let e={position:m.value,left:`0`,top:`0`};if(!d.value)return e;let t=ci(d.value,f.value),n=ci(d.value,p.value);return c.value?{...e,transform:`translate(`+t+`px, `+n+`px)`,...si(d.value)>=1.5&&{willChange:`transform`}}:{position:m.value,left:t+`px`,top:n+`px`}}),y;function b(){if(l.value==null||d.value==null)return;let e=i.value;ni(l.value,d.value,{middleware:a.value,placement:o.value,strategy:s.value}).then(t=>{f.value=t.x,p.value=t.y,m.value=t.strategy,h.value=t.placement,g.value=t.middlewareData,_.value=e!==!1})}function x(){typeof y==`function`&&(y(),y=void 0)}function C(){if(x(),r===void 0){b();return}if(l.value!=null&&d.value!=null){y=r(l.value,d.value,b);return}}function T(){i.value||(_.value=!1)}return V([a,o,s,i],b,{flush:`sync`}),V([l,d],C,{flush:`sync`}),V(i,T,{flush:`sync`}),u()&&Oe(x),{x:S(f),y:S(p),strategy:S(m),placement:S(h),middlewareData:S(g),isPositioned:S(_),floatingStyles:v,update:b}}var ui=[`dir`],di={side:`bottom`,sideOffset:0,sideFlip:!0,align:`center`,alignOffset:0,alignFlip:!0,arrowPadding:0,hideShiftedArrow:!0,avoidCollisions:!0,collisionBoundary:()=>[],collisionPadding:0,sticky:`partial`,hideWhenDetached:!1,positionStrategy:`fixed`,updatePositionStrategy:`optimized`,prioritizePosition:!1},[fi,pi]=oe(`PopperContent`),mi=R({inheritAttrs:!1,__name:`PopperContent`,props:We({memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},{...di}),emits:[`placed`],setup(e,{emit:t}){let n=e,r=t,a=$t(),{forwardRef:s,currentElement:c}=ie(),u=l(M(()=>n.dir)),d=F(),f=F(),{width:p,height:m}=Ct(f),h=M(()=>n.side+(n.align===`center`?``:`-${n.align}`)),g=M(()=>typeof n.collisionPadding==`number`?n.collisionPadding:{top:0,right:0,bottom:0,left:0,...n.collisionPadding}),_=M(()=>Array.isArray(n.collisionBoundary)?n.collisionBoundary:[n.collisionBoundary]),v=M(()=>({padding:g.value,boundary:_.value.filter(rn),altBoundary:_.value.length>0})),y=M(()=>({mainAxis:n.sideFlip,crossAxis:n.alignFlip})),x=M(()=>[Yr({mainAxis:n.sideOffset+m.value,alignmentAxis:n.alignOffset}),n.prioritizePosition&&n.avoidCollisions&&Zr({...v.value,...y.value}),n.avoidCollisions&&Xr({mainAxis:!0,crossAxis:!!n.prioritizePosition,limiter:n.sticky===`partial`?ti():void 0,...v.value}),!n.prioritizePosition&&n.avoidCollisions&&Zr({...v.value,...y.value}),Qr({...v.value,apply:({elements:e,rects:t,availableWidth:n,availableHeight:r})=>{let{width:i,height:a}=t.reference,o=e.floating.style;o.setProperty(`--reka-popper-available-width`,`${n}px`),o.setProperty(`--reka-popper-available-height`,`${r}px`),o.setProperty(`--reka-popper-anchor-width`,`${i}px`),o.setProperty(`--reka-popper-anchor-height`,`${a}px`)}}),f.value&&oi({element:f.value,padding:n.arrowPadding}),an({arrowWidth:p.value,arrowHeight:m.value,dir:u.value}),n.hideWhenDetached&&$r({strategy:`referenceHidden`,...v.value})]),{floatingStyles:S,placement:C,isPositioned:w,middlewareData:T,update:E}=li(M(()=>n.reference??a.anchor.value),d,{strategy:n.positionStrategy,placement:h,whileElementsMounted:(...e)=>Jr(...e,{layoutShift:!n.disableUpdateOnLayoutShift,animationFrame:n.updatePositionStrategy===`always`}),middleware:x}),D=M(()=>on(C.value)[0]),O=M(()=>on(C.value)[1]);o(()=>{w.value&&r(`placed`)});let k=M(()=>{let e=T.value.arrow?.centerOffset!==0;return n.hideShiftedArrow&&e}),ee=F(``);return re(()=>{c.value&&(ee.value=window.getComputedStyle(c.value).zIndex)}),pi({placedSide:D,onArrowChange:e=>f.value=e,arrowX:M(()=>T.value.arrow?.x??0),arrowY:M(()=>T.value.arrow?.y??0),shouldHideArrow:k}),(e,t)=>(N(),P(`div`,{ref_key:`floatingRef`,ref:d,"data-reka-popper-content-wrapper":``,dir:b(u),style:i({...b(S),transform:b(w)?b(S).transform:`translate(0, -200%)`,minWidth:`max-content`,zIndex:ee.value,"--reka-popper-transform-origin":[b(T).transformOrigin?.x,b(T).transformOrigin?.y].join(` `),...b(T).hide?.referenceHidden&&{visibility:`hidden`,pointerEvents:`none`}})},[n.memoDependencies?ae([n.asChild,n.as,D.value,O.value,b(w),...Object.values(e.$attrs),...n.memoDependencies],()=>(N(),I(b(A),j({key:0,ref:b(s)},e.$attrs,{"as-child":n.asChild,as:n.as,"data-side":D.value,"data-align":O.value,style:{animation:b(w)?void 0:`none`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`style`])),t,0):(N(),I(b(A),j({key:1,ref:b(s)},e.$attrs,{"as-child":n.asChild,as:n.as,"data-side":D.value,"data-align":O.value,dir:b(u),style:{animation:b(w)?void 0:`none`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`dir`,`style`]))],12,ui))}});function hi(e){let t=s({nonce:F()});return M(()=>e?.value||t.nonce?.value)}var gi=[` `,`Enter`,`ArrowUp`,`ArrowDown`],_i=[` `,`Enter`];function vi(e,t,n){return e===void 0?!1:Array.isArray(e)?e.some(e=>yi(e,t,n)):yi(e,t,n)}function yi(e,t,n){return e===void 0||t===void 0?!1:typeof e==`string`?e===t:typeof n==`function`?n(e,t):typeof n==`string`?e?.[n]===t?.[n]:le(e,t)}function bi(e){return e==null||e===``||Array.isArray(e)&&e.length===0}var xi=[`value`],[Si,Ci]=oe(`SelectRoot`),wi=R({inheritAttrs:!1,__name:`SelectRoot`,props:{open:{type:Boolean,required:!1,default:void 0},defaultOpen:{type:Boolean,required:!1},defaultValue:{type:null,required:!1},modelValue:{type:null,required:!1,default:void 0},nullableValue:{type:String,required:!1,default:``},by:{type:[String,Function],required:!1},dir:{type:String,required:!1},multiple:{type:Boolean,required:!1},autocomplete:{type:String,required:!1},disabled:{type:Boolean,required:!1},name:{type:String,required:!1},required:{type:Boolean,required:!1}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=e,r=t,{required:i,disabled:a,multiple:o,dir:s}=f(n),c=C(n,`modelValue`,r,{defaultValue:n.defaultValue??(o.value?[]:void 0),passive:n.modelValue===void 0,deep:!0}),u=C(n,`open`,r,{defaultValue:n.defaultOpen,passive:n.open===void 0}),d=F(),p=F(),m=F({x:0,y:0}),h=M(()=>o.value&&Array.isArray(c.value)?c.value?.length===0:se(c.value));Je({isProvider:!0});let g=l(s),_=ft(d),v=F(new Set),y=M(()=>Array.from(v.value).map(e=>e.value).join(`;`));function x(e){if(o.value){let t=Array.isArray(c.value)?[...c.value]:[],r=t.findIndex(t=>yi(t,e,n.by));r===-1?t.push(e):t.splice(r,1),c.value=[...t]}else c.value=e}function S(e){return Array.from(v.value).find(t=>vi(e,t.value,n.by))}return Ci({triggerElement:d,onTriggerChange:e=>{d.value=e},valueElement:p,onValueElementChange:e=>{p.value=e},contentId:``,modelValue:c,onValueChange:x,by:n.by,open:u,multiple:o,required:i,onOpenChange:e=>{u.value=e},dir:g,triggerPointerDownPosRef:m,disabled:a,isEmptyModelValue:h,optionsSet:v,onOptionAdd:e=>{let t=S(e.value);t&&v.value.delete(t),v.value.add(e)},onOptionRemove:e=>{let t=S(e.value);t&&v.value.delete(t)}}),(e,t)=>(N(),I(b(tn),null,{default:B(()=>[z(e.$slots,`default`,{modelValue:b(c),open:b(u)}),b(_)&&e.name?(N(),I(Ti,{key:y.value,"aria-hidden":`true`,tabindex:`-1`,multiple:b(o),required:b(i),name:e.name,autocomplete:e.autocomplete,disabled:b(a),value:b(c)},{default:B(()=>[b(se)(b(c))?(N(),P(`option`,{key:0,value:e.nullableValue},null,8,xi)):ze(`v-if`,!0),(N(!0),P(k,null,me(Array.from(v.value),e=>(N(),P(`option`,j({key:e.value??``},{ref_for:!0},e),null,16))),128))]),_:1},8,[`multiple`,`required`,`name`,`autocomplete`,`disabled`,`value`])):ze(`v-if`,!0)]),_:3}))}}),Ti=R({__name:`BubbleSelect`,props:{autocomplete:{type:String,required:!1},autofocus:{type:Boolean,required:!1},disabled:{type:Boolean,required:!1},form:{type:String,required:!1},multiple:{type:Boolean,required:!1},name:{type:String,required:!1},required:{type:Boolean,required:!1},size:{type:Number,required:!1},value:{type:null,required:!1}},setup(e){let t=e,n=F(),r=Si();V(()=>t.value,(e,t)=>{let r=window.HTMLSelectElement.prototype,i=Object.getOwnPropertyDescriptor(r,`value`).set;if(e!==t&&i&&n.value){let t=new Event(`change`,{bubbles:!0});i.call(n.value,e),n.value.dispatchEvent(t)}});function i(e){r.onValueChange(e.target.value)}return(e,r)=>(N(),I(b(Qt),{"as-child":``},{default:B(()=>[He(`select`,j({ref_key:`selectElement`,ref:n},t,{onInput:i}),[z(e.$slots,`default`)],16)]),_:3}))}}),Ei=R({__name:`SelectPopperPosition`,props:{memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1,default:`start`},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1,default:10},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Ke(e);return(e,n)=>(N(),I(b(mi),j(b(t),{style:{boxSizing:`border-box`,"--reka-select-content-transform-origin":`var(--reka-popper-transform-origin)`,"--reka-select-content-available-width":`var(--reka-popper-available-width)`,"--reka-select-content-available-height":`var(--reka-popper-available-height)`,"--reka-select-trigger-width":`var(--reka-popper-anchor-width)`,"--reka-select-trigger-height":`var(--reka-popper-anchor-height)`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Di={onViewportChange:()=>{},itemTextRefCallback:()=>{},itemRefCallback:()=>{}},[Oi,ki]=oe(`SelectContent`),Ai=R({__name:`SelectContentImpl`,props:{position:{type:String,required:!1,default:`item-aligned`},bodyLock:{type:Boolean,required:!1,default:!0},memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1,default:`start`},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},disableOutsidePointerEvents:{type:Boolean,required:!1,default:!0}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=Si();ut(),ot(n.bodyLock);let{CollectionSlot:a,getItems:o}=Je(),s=F();St(s);let{search:c,handleTypeaheadSearch:l}=wt(),u=F(),d=F(),f=F(),p=F(!1),m=F(!1),h=F(!1);function g(){d.value&&s.value&&Xt([d.value,s.value])}V(p,()=>{g()});let{onOpenChange:_,triggerPointerDownPosRef:v}=i;re(e=>{if(!s.value)return;let t={x:0,y:0},n=e=>{t={x:Math.abs(Math.round(e.pageX)-(v.value?.x??0)),y:Math.abs(Math.round(e.pageY)-(v.value?.y??0))}},r=e=>{e.pointerType!==`touch`&&(t.x<=10&&t.y<=10?e.preventDefault():s.value?.contains(e.target)||_(!1),document.removeEventListener(`pointermove`,n),v.value=null)};v.value!==null&&(document.addEventListener(`pointermove`,n),document.addEventListener(`pointerup`,r,{capture:!0,once:!0})),e(()=>{document.removeEventListener(`pointermove`,n),document.removeEventListener(`pointerup`,r,{capture:!0})})});function y(e){let t=e.ctrlKey||e.altKey||e.metaKey;if(e.key===`Tab`&&e.preventDefault(),!t&&e.key.length===1&&l(e.key,o()),[`ArrowUp`,`ArrowDown`,`Home`,`End`].includes(e.key)){let t=[...o().map(e=>e.ref)];if([`ArrowUp`,`End`].includes(e.key)&&(t=t.slice().reverse()),[`ArrowUp`,`ArrowDown`].includes(e.key)){let n=e.target,r=t.indexOf(n);t=t.slice(r+1)}setTimeout(()=>Xt(t)),e.preventDefault()}}let x=M(()=>n.position===`popper`?n:{}),S=Ke(x.value);return ki({content:s,viewport:u,onViewportChange:e=>{u.value=e},itemRefCallback:(e,t,n)=>{let r=!m.value&&!n,a=vi(i.modelValue.value,t,i.by);if(i.multiple.value){if(h.value)return;(a||r)&&(d.value=e,a&&(h.value=!0))}else(a||r)&&(d.value=e);r&&(m.value=!0)},selectedItem:d,selectedItemText:f,onItemLeave:()=>{s.value?.focus()},itemTextRefCallback:(e,t,n)=>{let r=!m.value&&!n;(vi(i.modelValue.value,t,i.by)||r)&&(f.value=e)},focusSelectedItem:g,position:n.position,isPositioned:p,searchRef:c}),(e,t)=>(N(),I(b(a),null,{default:B(()=>[L(b(Kt),{"as-child":``,onMountAutoFocus:t[6]||=fe(()=>{},[`prevent`]),onUnmountAutoFocus:t[7]||=e=>{r(`closeAutoFocus`,e),!e.defaultPrevented&&(b(i).triggerElement.value?.focus({preventScroll:!0}),e.preventDefault())}},{default:B(()=>[L(b(Mt),{"as-child":``,"disable-outside-pointer-events":e.disableOutsidePointerEvents,onFocusOutside:t[2]||=fe(()=>{},[`prevent`]),onDismiss:t[3]||=e=>b(i).onOpenChange(!1),onEscapeKeyDown:t[4]||=e=>r(`escapeKeyDown`,e),onPointerDownOutside:t[5]||=e=>r(`pointerDownOutside`,e)},{default:B(()=>[(N(),I(Ye(e.position===`popper`?Ei:Ni),j({...e.$attrs,...b(S)},{id:b(i).contentId,ref:e=>{if(!e)return;let t=b(De)(e);t?.hasAttribute(`data-reka-popper-content-wrapper`)?s.value=t.firstElementChild:s.value=t},role:`listbox`,"data-state":b(i).open.value?`open`:`closed`,dir:b(i).dir.value,style:{display:`flex`,flexDirection:`column`,outline:`none`},onContextmenu:t[0]||=fe(()=>{},[`prevent`]),onPlaced:t[1]||=e=>p.value=!0,onKeydown:y}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`id`,`data-state`,`dir`,`onKeydown`]))]),_:3},8,[`disable-outside-pointer-events`])]),_:3})]),_:3}))}}),[ji,Mi]=oe(`SelectItemAlignedPosition`),Ni=R({inheritAttrs:!1,__name:`SelectItemAlignedPosition`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`placed`],setup(e,{emit:t}){let n=e,r=t,{getItems:a}=Je(),o=Si(),s=Oi(),c=F(!1),l=F(!0),u=F(),{forwardRef:d,currentElement:f}=ie(),{viewport:p,selectedItem:m,selectedItemText:h,focusSelectedItem:g}=s;function _(){if(o.triggerElement.value&&o.valueElement.value&&u.value&&f.value&&p?.value&&m?.value&&h?.value){let e=o.triggerElement.value.getBoundingClientRect(),t=f.value.getBoundingClientRect(),n=o.valueElement.value.getBoundingClientRect(),i=h.value.getBoundingClientRect();if(o.dir.value!==`rtl`){let r=i.left-t.left,a=n.left-r,o=e.left-a,s=e.width+o,c=Math.max(s,t.width),l=window.innerWidth-10,d=Qe(a,10,Math.max(10,l-c));u.value.style.minWidth=`${s}px`,u.value.style.left=`${d}px`}else{let r=t.right-i.right,a=window.innerWidth-n.right-r,o=window.innerWidth-e.right-a,s=e.width+o,c=Math.max(s,t.width),l=window.innerWidth-10,d=Qe(a,10,Math.max(10,l-c));u.value.style.minWidth=`${s}px`,u.value.style.right=`${d}px`}let s=a().map(e=>e.ref),l=window.innerHeight-20,d=p.value.scrollHeight,g=window.getComputedStyle(f.value),_=Number.parseInt(g.borderTopWidth,10),v=Number.parseInt(g.paddingTop,10),y=Number.parseInt(g.borderBottomWidth,10),b=Number.parseInt(g.paddingBottom,10),x=_+v+d+b+y,S=Math.min(m.value.offsetHeight*5,x),C=window.getComputedStyle(p.value),w=Number.parseInt(C.paddingTop,10),T=Number.parseInt(C.paddingBottom,10),E=e.top+e.height/2-10,D=l-E,O=m.value.offsetHeight/2,k=m.value.offsetTop+O,ee=_+v+k,te=x-ee;if(ee<=E){let e=m.value===s.at(-1);u.value.style.bottom=`0px`;let t=f.value.clientHeight-p.value.offsetTop-p.value.offsetHeight,n=ee+Math.max(D,O+(e?T:0)+t+y);u.value.style.height=`${n}px`}else{let e=m.value===s[0];u.value.style.top=`0px`;let t=Math.max(E,_+p.value.offsetTop+(e?w:0)+O)+te;u.value.style.height=`${t}px`,p.value.scrollTop=ee-E+p.value.offsetTop}u.value.style.margin=`10px 0`,u.value.style.minHeight=`${S}px`,u.value.style.maxHeight=`${l}px`,r(`placed`),requestAnimationFrame(()=>c.value=!0)}}let v=F(``);Me(async()=>{await xe(),_(),f.value&&(v.value=window.getComputedStyle(f.value).zIndex)});function y(e){e&&l.value===!0&&(_(),g?.(),l.value=!1)}return x(o.triggerElement,()=>{_()}),Mi({contentWrapper:u,shouldExpandOnScrollRef:c,onScrollButtonChange:y}),(e,t)=>(N(),P(`div`,{ref_key:`contentWrapperElement`,ref:u,style:i({display:`flex`,flexDirection:`column`,position:`fixed`,zIndex:v.value})},[L(b(A),j({ref:b(d),style:{boxSizing:`border-box`,maxHeight:`100%`}},{...e.$attrs,...n}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16)],4))}}),Pi=R({inheritAttrs:!1,__name:`SelectProvider`,props:{context:{type:Object,required:!0}},setup(e){return Ci(e.context),ki(Di),(e,t)=>z(e.$slots,`default`)}}),Fi={key:1},Ii=R({inheritAttrs:!1,__name:`SelectContent`,props:{forceMount:{type:Boolean,required:!1},position:{type:String,required:!1},bodyLock:{type:Boolean,required:!1},memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},disableOutsidePointerEvents:{type:Boolean,required:!1}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(t,{emit:n}){let r=t,i=a(r,n),o=Si(),s=F();Me(()=>{s.value=new DocumentFragment});let c=F(),l=M(()=>r.forceMount||o.open.value),u=F(l.value),d;function f(){d&&=(clearTimeout(d),void 0)}return V(l,(e,t,n)=>{f(),d=setTimeout(()=>{u.value=l.value,d=void 0}),n(f)}),we(f),(t,n)=>l.value||u.value||c.value?.present?(N(),I(b(qe),{key:0,ref_key:`presenceRef`,ref:c,present:l.value},{default:B(()=>[L(Ai,Ze(ve({...b(i),...t.$attrs})),{default:B(()=>[z(t.$slots,`default`)]),_:3},16)]),_:3},8,[`present`])):s.value?(N(),P(`div`,Fi,[(N(),I(e,{to:s.value},[L(Pi,{context:b(o)},{default:B(()=>[z(t.$slots,`default`)]),_:3},8,[`context`])],8,[`to`]))])):ze(`v-if`,!0)}}),Li=R({__name:`SelectIcon`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(N(),I(b(A),{"aria-hidden":`true`,as:e.as,"as-child":e.asChild},{default:B(()=>[z(e.$slots,`default`,{},()=>[t[0]||=ge(`▼`)])]),_:3},8,[`as`,`as-child`]))}}),[Ri,zi]=oe(`SelectItem`),Bi=R({__name:`SelectItem`,props:{value:{type:null,required:!0},disabled:{type:Boolean,required:!1},textValue:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`select`],setup(e,{emit:t}){let n=e,r=t,{disabled:i}=f(n),a=Si(),o=Oi(),{forwardRef:s,currentElement:c}=ie(),{CollectionItem:l}=Je(),u=M(()=>vi(a.modelValue?.value,n.value,a.by)),d=F(!1),p=F(n.textValue??``),h=ne(void 0,`reka-select-item-text`);async function g(e){e.defaultPrevented||$e(`select.select`,_,{originalEvent:e,value:n.value})}async function _(e){await xe(),r(`select`,e),!e.defaultPrevented&&(i.value||(a.onValueChange(n.value),a.multiple.value||a.onOpenChange(!1)))}async function v(e){await xe(),!e.defaultPrevented&&(i.value?o.onItemLeave?.():e.currentTarget?.focus({preventScroll:!0}))}async function y(e){await xe(),!e.defaultPrevented&&e.currentTarget===m()&&o.onItemLeave?.()}async function x(e){await xe(),!e.defaultPrevented&&(o.searchRef?.value===``||e.key!==` `)&&(_i.includes(e.key)&&g(e),e.key===` `&&e.preventDefault())}if(n.value===``)throw Error(`A <SelectItem /> must have a value prop that is not an empty string. This is because the Select value can be set to an empty string to clear the selection and show the placeholder.`);return Me(()=>{c.value&&o.itemRefCallback(c.value,n.value,n.disabled)}),zi({value:n.value,disabled:i,textId:h,isSelected:u,onItemTextChange:e=>{p.value=((p.value||e?.textContent)??``).trim()}}),(e,t)=>(N(),I(b(l),{value:{textValue:p.value}},{default:B(()=>[L(b(A),{ref:b(s),role:`option`,"aria-labelledby":b(h),"data-highlighted":d.value?``:void 0,"aria-selected":u.value,"data-state":u.value?`checked`:`unchecked`,"aria-disabled":b(i)||void 0,"data-disabled":b(i)?``:void 0,tabindex:b(i)?void 0:-1,as:e.as,"as-child":e.asChild,onFocus:t[0]||=e=>d.value=!0,onBlur:t[1]||=e=>d.value=!1,onPointerup:g,onPointerdown:t[2]||=e=>{e.currentTarget.focus({preventScroll:!0})},onTouchend:t[3]||=fe(()=>{},[`prevent`,`stop`]),onPointermove:v,onPointerleave:y,onKeydown:x},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`aria-labelledby`,`data-highlighted`,`aria-selected`,`data-state`,`aria-disabled`,`data-disabled`,`tabindex`,`as`,`as-child`])]),_:3},8,[`value`]))}}),Vi=R({__name:`SelectItemIndicator`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Ri();return(e,r)=>b(n).isSelected.value?(N(),I(b(A),j({key:0,"aria-hidden":`true`},t),{default:B(()=>[z(e.$slots,`default`)]),_:3},16)):ze(`v-if`,!0)}}),Hi=R({inheritAttrs:!1,__name:`SelectItemText`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Si(),r=Oi(),i=Ri(),{forwardRef:a,currentElement:o}=ie(),s=M(()=>({value:i.value,disabled:i.disabled.value,textContent:o.value?.textContent??i.value?.toString()??``}));return Me(()=>{o.value&&(i.onItemTextChange(o.value),r.itemTextRefCallback(o.value,i.value,i.disabled.value),n.onOptionAdd(s.value))}),we(()=>{n.onOptionRemove(s.value)}),(e,n)=>(N(),I(b(A),j({id:b(i).textId,ref:b(a)},{...t,...e.$attrs}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`id`]))}}),Ui=R({__name:`SelectPortal`,props:{to:{type:null,required:!1},disabled:{type:Boolean,required:!1},defer:{type:Boolean,required:!1},forceMount:{type:Boolean,required:!1}},setup(e){let t=e;return(e,n)=>(N(),I(b(Zt),Ze(ve(t)),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Wi=R({__name:`SelectScrollButtonImpl`,emits:[`autoScroll`],setup(e,{emit:t}){let n=t,{getItems:r}=Je(),i=Oi(),a=F(null);function o(){a.value!==null&&(window.clearInterval(a.value),a.value=null)}re(()=>{r().map(e=>e.ref).find(e=>e===m())?.scrollIntoView({block:`nearest`})});function s(){a.value===null&&(a.value=window.setInterval(()=>{n(`autoScroll`)},50))}function c(){i.onItemLeave?.(),a.value===null&&(a.value=window.setInterval(()=>{n(`autoScroll`)},50))}return Ie(()=>o()),(e,t)=>(N(),I(b(A),j({"aria-hidden":`true`,style:{flexShrink:0}},e.$parent?.$props,{onPointerdown:s,onPointermove:c,onPointerleave:t[0]||=()=>{o()}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Gi=R({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Oi(),n=t.position===`item-aligned`?ji():void 0,{forwardRef:r,currentElement:i}=ie(),a=F(!1);return re(e=>{if(t.viewport?.value&&t.isPositioned?.value){let n=t.viewport.value;function r(){let e=n.scrollHeight-n.clientHeight;a.value=Math.ceil(n.scrollTop)<e}r(),n.addEventListener(`scroll`,r),e(()=>n.removeEventListener(`scroll`,r))}}),V(i,()=>{i.value&&n?.onScrollButtonChange(i.value)}),(e,n)=>a.value?(N(),I(Wi,{key:0,ref:b(r),onAutoScroll:n[0]||=()=>{let{viewport:e,selectedItem:n}=b(t);e?.value&&n?.value&&(e.value.scrollTop=e.value.scrollTop+n.value.offsetHeight)}},{default:B(()=>[z(e.$slots,`default`)]),_:3},512)):ze(`v-if`,!0)}}),Ki=R({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Oi(),n=t.position===`item-aligned`?ji():void 0,{forwardRef:r,currentElement:i}=ie(),a=F(!1);return re(e=>{if(t.viewport?.value&&t.isPositioned?.value){let n=t.viewport.value;function r(){a.value=n.scrollTop>0}r(),n.addEventListener(`scroll`,r),e(()=>n.removeEventListener(`scroll`,r))}}),V(i,()=>{i.value&&n?.onScrollButtonChange(i.value)}),(e,n)=>a.value?(N(),I(Wi,{key:0,ref:b(r),onAutoScroll:n[0]||=()=>{let{viewport:e,selectedItem:n}=b(t);e?.value&&n?.value&&(e.value.scrollTop=e.value.scrollTop-n.value.offsetHeight)}},{default:B(()=>[z(e.$slots,`default`)]),_:3},512)):ze(`v-if`,!0)}}),qi=R({__name:`SelectTrigger`,props:{disabled:{type:Boolean,required:!1},reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e,n=Si(),{forwardRef:r,currentElement:i}=ie(),a=M(()=>n.disabled?.value||t.disabled);n.contentId||=ne(void 0,`reka-select-content`),Me(()=>{n.onTriggerChange(i.value)});let{getItems:o}=Je(),{search:s,handleTypeaheadSearch:c,resetTypeahead:l}=wt();function u(){a.value||(n.onOpenChange(!0),l())}function d(e){u(),n.triggerPointerDownPosRef.value={x:Math.round(e.pageX),y:Math.round(e.pageY)}}function f(e){return e.button===0&&e.ctrlKey===!1}let p=!1;function m(e){if(e.pointerType===`touch`)return e.preventDefault();let t=e.target;t.hasPointerCapture(e.pointerId)&&t.releasePointerCapture(e.pointerId),f(e)&&(d(e),p=!0)}function h(e){f(e)&&e.preventDefault()}function g(e){p||e.currentTarget?.focus(),p=!1}return(e,t)=>(N(),I(b(nn),{"as-child":``,reference:e.reference},{default:B(()=>[L(b(A),{ref:b(r),role:`combobox`,type:e.as===`button`?`button`:void 0,"aria-controls":b(n).contentId,"aria-expanded":b(n).open.value||!1,"aria-required":b(n).required?.value,"aria-autocomplete":`none`,disabled:a.value,dir:b(n)?.dir.value,"data-state":b(n)?.open.value?`open`:`closed`,"data-disabled":a.value?``:void 0,"data-placeholder":b(bi)(b(n).modelValue?.value)?``:void 0,"as-child":e.asChild,as:e.as,onClick:g,onPointerdown:m,onMousedown:h,onPointerup:t[0]||=fe(e=>{e.pointerType===`touch`&&d(e)},[`prevent`]),onKeydown:t[1]||=e=>{let t=b(s)!==``;!(e.ctrlKey||e.altKey||e.metaKey)&&e.key.length===1&&t&&e.key===` `||(b(c)(e.key,b(o)()),b(gi).includes(e.key)&&(u(),e.preventDefault()))}},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`type`,`aria-controls`,`aria-expanded`,`aria-required`,`disabled`,`dir`,`data-state`,`data-disabled`,`data-placeholder`,`as-child`,`as`])]),_:3},8,[`reference`]))}}),Ji=R({__name:`SelectValue`,props:{placeholder:{type:String,required:!1,default:``},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,{forwardRef:n,currentElement:r}=ie(),i=Si();Me(()=>{i.valueElement=r});let a=M(()=>{let e=[],t=Array.from(i.optionsSet.value),n=e=>t.find(t=>vi(e,t.value,i.by));return e=Array.isArray(i.modelValue.value)?i.modelValue.value.map(e=>n(e)?.textContent??``):[n(i.modelValue.value)?.textContent??``],e.filter(Boolean)}),o=M(()=>a.value.length?a.value.join(`, `):t.placeholder);return(e,r)=>(N(),I(b(A),{ref:b(n),as:e.as,"as-child":e.asChild,style:{pointerEvents:`none`},"data-placeholder":a.value.length?void 0:t.placeholder},{default:B(()=>[z(e.$slots,`default`,{selectedLabel:a.value,modelValue:b(i).modelValue.value},()=>[ge(ce(o.value),1)])]),_:3},8,[`as`,`as-child`,`data-placeholder`]))}}),Yi=R({__name:`SelectViewport`,props:{nonce:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{nonce:n}=f(t),r=hi(n),i=Oi(),a=i.position===`item-aligned`?ji():void 0,{forwardRef:o,currentElement:s}=ie();Me(()=>{i?.onViewportChange(s.value)});let c=F(0);function l(e){let t=e.currentTarget,{shouldExpandOnScrollRef:n,contentWrapper:r}=a??{};if(n?.value&&r?.value){let e=Math.abs(c.value-t.scrollTop);if(e>0){let n=window.innerHeight-20,i=Number.parseFloat(r.value.style.minHeight),a=Number.parseFloat(r.value.style.height),o=Math.max(i,a);if(o<n){let i=o+e,a=Math.min(n,i),s=i-a;r.value.style.height=`${a}px`,r.value.style.bottom===`0px`&&(t.scrollTop=s>0?s:0,r.value.style.justifyContent=`flex-end`)}}}c.value=t.scrollTop}return(e,n)=>(N(),P(k,null,[L(b(A),j({ref:b(o),"data-reka-select-viewport":``,role:`presentation`},{...e.$attrs,...t},{style:{position:`relative`,flex:1,overflow:`hidden auto`},onScroll:l}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16),L(b(A),{as:`style`,nonce:b(r)},{default:B(()=>n[0]||=[ge(` /* Hide scrollbars cross-browser and enable momentum scroll for touch devices */ [data-reka-select-viewport] { scrollbar-width:none; -ms-overflow-style: none; -webkit-overflow-scrolling: touch; } [data-reka-select-viewport]::-webkit-scrollbar { display: none; } `)]),_:1,__:[0]},8,[`nonce`])],64))}}),Xi=R({__name:`Select`,props:{open:{type:Boolean},defaultOpen:{type:Boolean},defaultValue:{},modelValue:{},nullableValue:{},by:{type:[String,Function]},dir:{},multiple:{type:Boolean},autocomplete:{},disabled:{type:Boolean},name:{},required:{type:Boolean}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=a(e,t);return(e,t)=>(N(),I(b(wi),j({"data-slot":`select`},b(n)),{default:B(t=>[z(e.$slots,`default`,Ze(ve(t)))]),_:3},16))}}),Zi=R({inheritAttrs:!1,__name:`SelectContent`,props:{forceMount:{type:Boolean},position:{default:`item-aligned`},bodyLock:{type:Boolean},memoDependencies:{},side:{},sideOffset:{},sideFlip:{type:Boolean},align:{default:`center`},alignOffset:{},alignFlip:{type:Boolean},avoidCollisions:{type:Boolean},collisionBoundary:{},collisionPadding:{},arrowPadding:{},hideShiftedArrow:{type:Boolean},sticky:{},hideWhenDetached:{type:Boolean},positionStrategy:{},updatePositionStrategy:{},disableUpdateOnLayoutShift:{type:Boolean},prioritizePosition:{type:Boolean},reference:{},dir:{},asChild:{type:Boolean},as:{},disableOutsidePointerEvents:{type:Boolean},class:{type:[Boolean,null,String,Object,Array]}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=ee(n,`class`),o=a(i,r);return(t,r)=>(N(),I(b(Ui),null,{default:B(()=>[L(b(Ii),j({"data-slot":`select-content`,"data-align-trigger":e.position===`item-aligned`},{...t.$attrs,...b(o)},{class:b(p)(`bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 min-w-36 rounded-lg shadow-md ring-1 duration-100 data-[side=inline-start]:slide-in-from-right-2 data-[side=inline-end]:slide-in-from-left-2 cn-menu-translucent relative z-50 max-h-(--reka-select-content-available-height) origin-(--reka-select-content-transform-origin) overflow-x-hidden overflow-y-auto data-[align-trigger=true]:animate-none`,e.position===`popper`&&`data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1`,n.class)}),{default:B(()=>[L(b(ta)),L(b(Yi),{"data-position":e.position,class:te(b(p)(`data-[position=popper]:h-(--reka-select-trigger-height) data-[position=popper]:w-full data-[position=popper]:min-w-(--reka-select-trigger-width)`))},{default:B(()=>[z(t.$slots,`default`)]),_:3},8,[`data-position`,`class`]),L(b(ea))]),_:3},16,[`data-align-trigger`,`class`])]),_:3}))}}),Qi={class:`pointer-events-none absolute right-2 flex size-4 items-center justify-center`},$i=R({__name:`SelectItem`,props:{value:{},disabled:{type:Boolean},textValue:{},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Bi),j({"data-slot":`select-item`},b(r),{class:b(p)(`focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*=size-])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2 relative flex w-full cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0`,t.class)}),{default:B(()=>[He(`span`,Qi,[L(b(Vi),null,{default:B(()=>[z(e.$slots,`indicator-icon`,{},()=>[L(b(ue),{icon:b(v),class:`pointer-events-none size-3.5`},null,8,[`icon`])])]),_:3})]),L(b(Hi),null,{default:B(()=>[z(e.$slots,`default`)]),_:3})]),_:3},16,[`class`]))}}),ea=R({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Gi),j({"data-slot":`select-scroll-down-button`},b(r),{class:b(p)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:B(()=>[z(e.$slots,`default`,{},()=>[L(b(ue),{icon:b(Le),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),ta=R({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Ki),j({"data-slot":`select-scroll-up-button`},b(r),{class:b(p)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:B(()=>[z(e.$slots,`default`,{},()=>[L(b(ue),{icon:b(_),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),na=R({__name:`SelectTrigger`,props:{disabled:{type:Boolean},reference:{},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e,n=ee(t,`class`,`size`),r=Ke(n);return(n,i)=>(N(),I(b(qi),j({"data-slot":`select-trigger`,"data-size":e.size},b(r),{class:b(p)(`border-input data-placeholder:text-muted-foreground dark:bg-input/30 dark:hover:bg-input/50 focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 gap-1.5 rounded-lg border bg-transparent py-2 pr-2 pl-2.5 text-sm transition-colors select-none focus-visible:ring-3 aria-invalid:ring-3 data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:gap-1.5 [&_svg:not([class*=size-])]:size-4 flex w-fit items-center justify-between whitespace-nowrap outline-none disabled:cursor-not-allowed disabled:opacity-50 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center [&_svg]:pointer-events-none [&_svg]:shrink-0`,t.class)}),{default:B(()=>[z(n.$slots,`default`),L(b(Li),{"as-child":``},{default:B(()=>[L(b(ue),{icon:b(Le),class:`text-muted-foreground size-4 pointer-events-none`},null,8,[`icon`])]),_:1})]),_:3},16,[`data-size`,`class`]))}}),ra=R({__name:`SelectValue`,props:{placeholder:{},asChild:{type:Boolean},as:{}},setup(e){let t=e;return(e,n)=>(N(),I(b(Ji),j({"data-slot":`select-value`},t),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}});function ia(e){return e+.5|0}var aa=(e,t,n)=>Math.max(Math.min(e,n),t);function oa(e){return aa(ia(e*2.55),0,255)}function sa(e){return aa(ia(e*255),0,255)}function ca(e){return aa(ia(e/2.55)/100,0,1)}function la(e){return aa(ia(e*100),0,100)}var ua={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,A:10,B:11,C:12,D:13,E:14,F:15,a:10,b:11,c:12,d:13,e:14,f:15},da=[...`0123456789ABCDEF`],fa=e=>da[e&15],pa=e=>da[(e&240)>>4]+da[e&15],ma=e=>(e&240)>>4==(e&15),ha=e=>ma(e.r)&&ma(e.g)&&ma(e.b)&&ma(e.a);function ga(e){var t=e.length,n;return e[0]===`#`&&(t===4||t===5?n={r:255&ua[e[1]]*17,g:255&ua[e[2]]*17,b:255&ua[e[3]]*17,a:t===5?ua[e[4]]*17:255}:(t===7||t===9)&&(n={r:ua[e[1]]<<4|ua[e[2]],g:ua[e[3]]<<4|ua[e[4]],b:ua[e[5]]<<4|ua[e[6]],a:t===9?ua[e[7]]<<4|ua[e[8]]:255})),n}var _a=(e,t)=>e<255?t(e):``;function va(e){var t=ha(e)?fa:pa;return e?`#`+t(e.r)+t(e.g)+t(e.b)+_a(e.a,t):void 0}var ya=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function ba(e,t,n){let r=t*Math.min(n,1-n),i=(t,i=(t+e/30)%12)=>n-r*Math.max(Math.min(i-3,9-i,1),-1);return[i(0),i(8),i(4)]}function xa(e,t,n){let r=(r,i=(r+e/60)%6)=>n-n*t*Math.max(Math.min(i,4-i,1),0);return[r(5),r(3),r(1)]}function Sa(e,t,n){let r=ba(e,1,.5),i;for(t+n>1&&(i=1/(t+n),t*=i,n*=i),i=0;i<3;i++)r[i]*=1-t-n,r[i]+=t;return r}function Ca(e,t,n,r,i){return e===i?(t-n)/r+(t<n?6:0):t===i?(n-e)/r+2:(e-t)/r+4}function wa(e){let t=e.r/255,n=e.g/255,r=e.b/255,i=Math.max(t,n,r),a=Math.min(t,n,r),o=(i+a)/2,s,c,l;return i!==a&&(l=i-a,c=o>.5?l/(2-i-a):l/(i+a),s=Ca(t,n,r,l,i),s=s*60+.5),[s|0,c||0,o]}function Ta(e,t,n,r){return(Array.isArray(t)?e(t[0],t[1],t[2]):e(t,n,r)).map(sa)}function Ea(e,t,n){return Ta(ba,e,t,n)}function Da(e,t,n){return Ta(Sa,e,t,n)}function Oa(e,t,n){return Ta(xa,e,t,n)}function ka(e){return(e%360+360)%360}function Aa(e){let t=ya.exec(e),n=255,r;if(!t)return;t[5]!==r&&(n=t[6]?oa(+t[5]):sa(+t[5]));let i=ka(+t[2]),a=t[3]/100,o=t[4]/100;return r=t[1]===`hwb`?Da(i,a,o):t[1]===`hsv`?Oa(i,a,o):Ea(i,a,o),{r:r[0],g:r[1],b:r[2],a:n}}function ja(e,t){var n=wa(e);n[0]=ka(n[0]+t),n=Ea(n),e.r=n[0],e.g=n[1],e.b=n[2]}function Ma(e){if(!e)return;let t=wa(e),n=t[0],r=la(t[1]),i=la(t[2]);return e.a<255?`hsla(${n}, ${r}%, ${i}%, ${ca(e.a)})`:`hsl(${n}, ${r}%, ${i}%)`}var Na={x:`dark`,Z:`light`,Y:`re`,X:`blu`,W:`gr`,V:`medium`,U:`slate`,A:`ee`,T:`ol`,S:`or`,B:`ra`,C:`lateg`,D:`ights`,R:`in`,Q:`turquois`,E:`hi`,P:`ro`,O:`al`,N:`le`,M:`de`,L:`yello`,F:`en`,K:`ch`,G:`arks`,H:`ea`,I:`ightg`,J:`wh`},Pa={OiceXe:`f0f8ff`,antiquewEte:`faebd7`,aqua:`ffff`,aquamarRe:`7fffd4`,azuY:`f0ffff`,beige:`f5f5dc`,bisque:`ffe4c4`,black:`0`,blanKedOmond:`ffebcd`,Xe:`ff`,XeviTet:`8a2be2`,bPwn:`a52a2a`,burlywood:`deb887`,caMtXe:`5f9ea0`,KartYuse:`7fff00`,KocTate:`d2691e`,cSO:`ff7f50`,cSnflowerXe:`6495ed`,cSnsilk:`fff8dc`,crimson:`dc143c`,cyan:`ffff`,xXe:`8b`,xcyan:`8b8b`,xgTMnPd:`b8860b`,xWay:`a9a9a9`,xgYF:`6400`,xgYy:`a9a9a9`,xkhaki:`bdb76b`,xmagFta:`8b008b`,xTivegYF:`556b2f`,xSange:`ff8c00`,xScEd:`9932cc`,xYd:`8b0000`,xsOmon:`e9967a`,xsHgYF:`8fbc8f`,xUXe:`483d8b`,xUWay:`2f4f4f`,xUgYy:`2f4f4f`,xQe:`ced1`,xviTet:`9400d3`,dAppRk:`ff1493`,dApskyXe:`bfff`,dimWay:`696969`,dimgYy:`696969`,dodgerXe:`1e90ff`,fiYbrick:`b22222`,flSOwEte:`fffaf0`,foYstWAn:`228b22`,fuKsia:`ff00ff`,gaRsbSo:`dcdcdc`,ghostwEte:`f8f8ff`,gTd:`ffd700`,gTMnPd:`daa520`,Way:`808080`,gYF:`8000`,gYFLw:`adff2f`,gYy:`808080`,honeyMw:`f0fff0`,hotpRk:`ff69b4`,RdianYd:`cd5c5c`,Rdigo:`4b0082`,ivSy:`fffff0`,khaki:`f0e68c`,lavFMr:`e6e6fa`,lavFMrXsh:`fff0f5`,lawngYF:`7cfc00`,NmoncEffon:`fffacd`,ZXe:`add8e6`,ZcSO:`f08080`,Zcyan:`e0ffff`,ZgTMnPdLw:`fafad2`,ZWay:`d3d3d3`,ZgYF:`90ee90`,ZgYy:`d3d3d3`,ZpRk:`ffb6c1`,ZsOmon:`ffa07a`,ZsHgYF:`20b2aa`,ZskyXe:`87cefa`,ZUWay:`778899`,ZUgYy:`778899`,ZstAlXe:`b0c4de`,ZLw:`ffffe0`,lime:`ff00`,limegYF:`32cd32`,lRF:`faf0e6`,magFta:`ff00ff`,maPon:`800000`,VaquamarRe:`66cdaa`,VXe:`cd`,VScEd:`ba55d3`,VpurpN:`9370db`,VsHgYF:`3cb371`,VUXe:`7b68ee`,VsprRggYF:`fa9a`,VQe:`48d1cc`,VviTetYd:`c71585`,midnightXe:`191970`,mRtcYam:`f5fffa`,mistyPse:`ffe4e1`,moccasR:`ffe4b5`,navajowEte:`ffdead`,navy:`80`,Tdlace:`fdf5e6`,Tive:`808000`,TivedBb:`6b8e23`,Sange:`ffa500`,SangeYd:`ff4500`,ScEd:`da70d6`,pOegTMnPd:`eee8aa`,pOegYF:`98fb98`,pOeQe:`afeeee`,pOeviTetYd:`db7093`,papayawEp:`ffefd5`,pHKpuff:`ffdab9`,peru:`cd853f`,pRk:`ffc0cb`,plum:`dda0dd`,powMrXe:`b0e0e6`,purpN:`800080`,YbeccapurpN:`663399`,Yd:`ff0000`,Psybrown:`bc8f8f`,PyOXe:`4169e1`,saddNbPwn:`8b4513`,sOmon:`fa8072`,sandybPwn:`f4a460`,sHgYF:`2e8b57`,sHshell:`fff5ee`,siFna:`a0522d`,silver:`c0c0c0`,skyXe:`87ceeb`,UXe:`6a5acd`,UWay:`708090`,UgYy:`708090`,snow:`fffafa`,sprRggYF:`ff7f`,stAlXe:`4682b4`,tan:`d2b48c`,teO:`8080`,tEstN:`d8bfd8`,tomato:`ff6347`,Qe:`40e0d0`,viTet:`ee82ee`,JHt:`f5deb3`,wEte:`ffffff`,wEtesmoke:`f5f5f5`,Lw:`ffff00`,LwgYF:`9acd32`};function Fa(){let e={},t=Object.keys(Pa),n=Object.keys(Na),r,i,a,o,s;for(r=0;r<t.length;r++){for(o=s=t[r],i=0;i<n.length;i++)a=n[i],s=s.replace(a,Na[a]);a=parseInt(Pa[o],16),e[s]=[a>>16&255,a>>8&255,a&255]}return e}var Ia;function La(e){Ia||(Ia=Fa(),Ia.transparent=[0,0,0,0]);let t=Ia[e.toLowerCase()];return t&&{r:t[0],g:t[1],b:t[2],a:t.length===4?t[3]:255}}var Ra=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;function za(e){let t=Ra.exec(e),n=255,r,i,a;if(t){if(t[7]!==r){let e=+t[7];n=t[8]?oa(e):aa(e*255,0,255)}return r=+t[1],i=+t[3],a=+t[5],r=255&(t[2]?oa(r):aa(r,0,255)),i=255&(t[4]?oa(i):aa(i,0,255)),a=255&(t[6]?oa(a):aa(a,0,255)),{r,g:i,b:a,a:n}}}function Ba(e){return e&&(e.a<255?`rgba(${e.r}, ${e.g}, ${e.b}, ${ca(e.a)})`:`rgb(${e.r}, ${e.g}, ${e.b})`)}var Va=e=>e<=.0031308?e*12.92:e**(1/2.4)*1.055-.055,Ha=e=>e<=.04045?e/12.92:((e+.055)/1.055)**2.4;function Ua(e,t,n){let r=Ha(ca(e.r)),i=Ha(ca(e.g)),a=Ha(ca(e.b));return{r:sa(Va(r+n*(Ha(ca(t.r))-r))),g:sa(Va(i+n*(Ha(ca(t.g))-i))),b:sa(Va(a+n*(Ha(ca(t.b))-a))),a:e.a+n*(t.a-e.a)}}function Wa(e,t,n){if(e){let r=wa(e);r[t]=Math.max(0,Math.min(r[t]+r[t]*n,t===0?360:1)),r=Ea(r),e.r=r[0],e.g=r[1],e.b=r[2]}}function Ga(e,t){return e&&Object.assign(t||{},e)}function Ka(e){var t={r:0,g:0,b:0,a:255};return Array.isArray(e)?e.length>=3&&(t={r:e[0],g:e[1],b:e[2],a:255},e.length>3&&(t.a=sa(e[3]))):(t=Ga(e,{r:0,g:0,b:0,a:1}),t.a=sa(t.a)),t}function qa(e){return e.charAt(0)===`r`?za(e):Aa(e)}var Ja=class e{constructor(t){if(t instanceof e)return t;let n=typeof t,r;n===`object`?r=Ka(t):n===`string`&&(r=ga(t)||La(t)||qa(t)),this._rgb=r,this._valid=!!r}get valid(){return this._valid}get rgb(){var e=Ga(this._rgb);return e&&(e.a=ca(e.a)),e}set rgb(e){this._rgb=Ka(e)}rgbString(){return this._valid?Ba(this._rgb):void 0}hexString(){return this._valid?va(this._rgb):void 0}hslString(){return this._valid?Ma(this._rgb):void 0}mix(e,t){if(e){let n=this.rgb,r=e.rgb,i,a=t===i?.5:t,o=2*a-1,s=n.a-r.a,c=((o*s===-1?o:(o+s)/(1+o*s))+1)/2;i=1-c,n.r=255&c*n.r+i*r.r+.5,n.g=255&c*n.g+i*r.g+.5,n.b=255&c*n.b+i*r.b+.5,n.a=a*n.a+(1-a)*r.a,this.rgb=n}return this}interpolate(e,t){return e&&(this._rgb=Ua(this._rgb,e._rgb,t)),this}clone(){return new e(this.rgb)}alpha(e){return this._rgb.a=sa(e),this}clearer(e){let t=this._rgb;return t.a*=1-e,this}greyscale(){let e=this._rgb;return e.r=e.g=e.b=ia(e.r*.3+e.g*.59+e.b*.11),this}opaquer(e){let t=this._rgb;return t.a*=1+e,this}negate(){let e=this._rgb;return e.r=255-e.r,e.g=255-e.g,e.b=255-e.b,this}lighten(e){return Wa(this._rgb,2,e),this}darken(e){return Wa(this._rgb,2,-e),this}saturate(e){return Wa(this._rgb,1,e),this}desaturate(e){return Wa(this._rgb,1,-e),this}rotate(e){return ja(this._rgb,e),this}};function Ya(){}var Xa=(()=>{let e=0;return()=>e++})();function U(e){return e==null}function W(e){if(Array.isArray&&Array.isArray(e))return!0;let t=Object.prototype.toString.call(e);return t.slice(0,7)===`[object`&&t.slice(-6)===`Array]`}function G(e){return e!==null&&Object.prototype.toString.call(e)===`[object Object]`}function K(e){return(typeof e==`number`||e instanceof Number)&&isFinite(+e)}function Za(e,t){return K(e)?e:t}function q(e,t){return e===void 0?t:e}var Qa=(e,t)=>typeof e==`string`&&e.endsWith(`%`)?parseFloat(e)/100*t:+e;function J(e,t,n){if(e&&typeof e.call==`function`)return e.apply(n,t)}function Y(e,t,n,r){let i,a,o;if(W(e)){if(a=e.length,r)for(i=a-1;i>=0;i--)t.call(n,e[i],i);else for(i=0;i<a;i++)t.call(n,e[i],i)}else if(G(e))for(o=Object.keys(e),a=o.length,i=0;i<a;i++)t.call(n,e[o[i]],o[i])}function $a(e,t){let n,r,i,a;if(!e||!t||e.length!==t.length)return!1;for(n=0,r=e.length;n<r;++n)if(i=e[n],a=t[n],i.datasetIndex!==a.datasetIndex||i.index!==a.index)return!1;return!0}function eo(e){if(W(e))return e.map(eo);if(G(e)){let t=Object.create(null),n=Object.keys(e),r=n.length,i=0;for(;i<r;++i)t[n[i]]=eo(e[n[i]]);return t}return e}function to(e){return[`__proto__`,`prototype`,`constructor`].indexOf(e)===-1}function no(e,t,n,r){if(!to(e))return;let i=t[e],a=n[e];G(i)&&G(a)?ro(i,a,r):t[e]=eo(a)}function ro(e,t,n){let r=W(t)?t:[t],i=r.length;if(!G(e))return e;n||={};let a=n.merger||no,o;for(let t=0;t<i;++t){if(o=r[t],!G(o))continue;let i=Object.keys(o);for(let t=0,r=i.length;t<r;++t)a(i[t],e,o,n)}return e}function io(e,t){return ro(e,t,{merger:ao})}function ao(e,t,n){if(!to(e))return;let r=t[e],i=n[e];G(r)&&G(i)?io(r,i):Object.prototype.hasOwnProperty.call(t,e)||(t[e]=eo(i))}var oo={"":e=>e,x:e=>e.x,y:e=>e.y};function so(e){let t=e.split(`.`),n=[],r=``;for(let e of t)r+=e,r.endsWith(`\\`)?r=r.slice(0,-1)+`.`:(n.push(r),r=``);return n}function co(e){let t=so(e);return e=>{for(let n of t){if(n===``)break;e&&=e[n]}return e}}function lo(e,t){return(oo[t]||(oo[t]=co(t)))(e)}function uo(e){return e.charAt(0).toUpperCase()+e.slice(1)}var fo=e=>e!==void 0,po=e=>typeof e==`function`,mo=(e,t)=>{if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0};function ho(e){return e.type===`mouseup`||e.type===`click`||e.type===`contextmenu`}var X=Math.PI,go=2*X;go+X;var _o=1/0,vo=X/180,yo=X/2,bo=X/4,xo=X*2/3,So=Math.log10,Co=Math.sign;function wo(e,t,n){return Math.abs(e-t)<n}function To(e){let t=Math.round(e);e=wo(e,t,e/1e3)?t:e;let n=10**Math.floor(So(e)),r=e/n;return(r<=1?1:r<=2?2:r<=5?5:10)*n}function Eo(e){let t=[],n=Math.sqrt(e),r;for(r=1;r<n;r++)e%r===0&&(t.push(r),t.push(e/r));return n===(n|0)&&t.push(n),t.sort((e,t)=>e-t).pop(),t}function Do(e){return typeof e==`symbol`||typeof e==`object`&&!!e&&!(Symbol.toPrimitive in e||`toString`in e||`valueOf`in e)}function Oo(e){return!Do(e)&&!isNaN(parseFloat(e))&&isFinite(e)}function ko(e,t){let n=Math.round(e);return n-t<=e&&n+t>=e}function Ao(e,t,n){let r,i,a;for(r=0,i=e.length;r<i;r++)a=e[r][n],isNaN(a)||(t.min=Math.min(t.min,a),t.max=Math.max(t.max,a))}function jo(e){return X/180*e}function Mo(e){return 180/X*e}function No(e){if(!K(e))return;let t=1,n=0;for(;Math.round(e*t)/t!==e;)t*=10,n++;return n}function Po(e,t){let n=t.x-e.x,r=t.y-e.y,i=Math.sqrt(n*n+r*r),a=Math.atan2(r,n);return a<-.5*X&&(a+=go),{angle:a,distance:i}}function Fo(e,t){return Math.sqrt((t.x-e.x)**2+(t.y-e.y)**2)}function Io(e){return(e%go+go)%go}function Lo(e,t,n,r){let i=Io(e),a=Io(t),o=Io(n),s=Io(a-i),c=Io(o-i),l=Io(i-a),u=Io(i-o);return i===a||i===o||r&&a===o||s>c&&l<u}function Ro(e,t,n){return Math.max(t,Math.min(n,e))}function zo(e){return Ro(e,-32768,32767)}function Bo(e,t,n,r=1e-6){return e>=Math.min(t,n)-r&&e<=Math.max(t,n)+r}function Vo(e,t,n){n||=(n=>e[n]<t);let r=e.length-1,i=0,a;for(;r-i>1;)a=i+r>>1,n(a)?i=a:r=a;return{lo:i,hi:r}}var Ho=(e,t,n,r)=>Vo(e,n,r?r=>{let i=e[r][t];return i<n||i===n&&e[r+1][t]===n}:r=>e[r][t]<n),Uo=(e,t,n)=>Vo(e,n,r=>e[r][t]>=n);function Wo(e,t,n){let r=0,i=e.length;for(;r<i&&e[r]<t;)r++;for(;i>r&&e[i-1]>n;)i--;return r>0||i<e.length?e.slice(r,i):e}var Go=[`push`,`pop`,`shift`,`splice`,`unshift`];function Ko(e,t){if(e._chartjs){e._chartjs.listeners.push(t);return}Object.defineProperty(e,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[t]}}),Go.forEach(t=>{let n=`_onData`+uo(t),r=e[t];Object.defineProperty(e,t,{configurable:!0,enumerable:!1,value(...t){let i=r.apply(this,t);return e._chartjs.listeners.forEach(e=>{typeof e[n]==`function`&&e[n](...t)}),i}})})}function qo(e,t){let n=e._chartjs;if(!n)return;let r=n.listeners,i=r.indexOf(t);i!==-1&&r.splice(i,1),!(r.length>0)&&(Go.forEach(t=>{delete e[t]}),delete e._chartjs)}function Jo(e){let t=new Set(e);return t.size===e.length?e:Array.from(t)}var Yo=function(){return typeof window>`u`?function(e){return e()}:window.requestAnimationFrame}();function Xo(e,t){let n=[],r=!1;return function(...i){n=i,r||(r=!0,Yo.call(window,()=>{r=!1,e.apply(t,n)}))}}function Zo(e,t){let n;return function(...r){return t?(clearTimeout(n),n=setTimeout(e,t,r)):e.apply(this,r),t}}var Qo=e=>e===`start`?`left`:e===`end`?`right`:`center`,$o=(e,t,n)=>e===`start`?t:e===`end`?n:(t+n)/2,es=(e,t,n,r)=>e===(r?`left`:`right`)?n:e===`center`?(t+n)/2:t,ts=e=>e===0||e===1,ns=(e,t,n)=>-(2**(10*--e)*Math.sin((e-t)*go/n)),rs=(e,t,n)=>2**(-10*e)*Math.sin((e-t)*go/n)+1,is={linear:e=>e,easeInQuad:e=>e*e,easeOutQuad:e=>-e*(e-2),easeInOutQuad:e=>(e/=.5)<1?.5*e*e:-.5*(--e*(e-2)-1),easeInCubic:e=>e*e*e,easeOutCubic:e=>--e*e*e+1,easeInOutCubic:e=>(e/=.5)<1?.5*e*e*e:.5*((e-=2)*e*e+2),easeInQuart:e=>e*e*e*e,easeOutQuart:e=>-(--e*e*e*e-1),easeInOutQuart:e=>(e/=.5)<1?.5*e*e*e*e:-.5*((e-=2)*e*e*e-2),easeInQuint:e=>e*e*e*e*e,easeOutQuint:e=>--e*e*e*e*e+1,easeInOutQuint:e=>(e/=.5)<1?.5*e*e*e*e*e:.5*((e-=2)*e*e*e*e+2),easeInSine:e=>-Math.cos(e*yo)+1,easeOutSine:e=>Math.sin(e*yo),easeInOutSine:e=>-.5*(Math.cos(X*e)-1),easeInExpo:e=>e===0?0:2**(10*(e-1)),easeOutExpo:e=>e===1?1:-(2**(-10*e))+1,easeInOutExpo:e=>ts(e)?e:e<.5?.5*2**(10*(e*2-1)):.5*(-(2**(-10*(e*2-1)))+2),easeInCirc:e=>e>=1?e:-(Math.sqrt(1-e*e)-1),easeOutCirc:e=>Math.sqrt(1- --e*e),easeInOutCirc:e=>(e/=.5)<1?-.5*(Math.sqrt(1-e*e)-1):.5*(Math.sqrt(1-(e-=2)*e)+1),easeInElastic:e=>ts(e)?e:ns(e,.075,.3),easeOutElastic:e=>ts(e)?e:rs(e,.075,.3),easeInOutElastic(e){let t=.1125,n=.45;return ts(e)?e:e<.5?.5*ns(e*2,t,n):.5+.5*rs(e*2-1,t,n)},easeInBack(e){return e*e*(2.70158*e-1.70158)},easeOutBack(e){return--e*e*(2.70158*e+1.70158)+1},easeInOutBack(e){let t=1.70158;return(e/=.5)<1?.5*(e*e*(((t*=1.525)+1)*e-t)):.5*((e-=2)*e*(((t*=1.525)+1)*e+t)+2)},easeInBounce:e=>1-is.easeOutBounce(1-e),easeOutBounce(e){let t=7.5625,n=2.75;return e<1/n?t*e*e:e<2/n?t*(e-=1.5/n)*e+.75:e<2.5/n?t*(e-=2.25/n)*e+.9375:t*(e-=2.625/n)*e+.984375},easeInOutBounce:e=>e<.5?is.easeInBounce(e*2)*.5:is.easeOutBounce(e*2-1)*.5+.5};function as(e){if(e&&typeof e==`object`){let t=e.toString();return t===`[object CanvasPattern]`||t===`[object CanvasGradient]`}return!1}function os(e){return as(e)?e:new Ja(e)}function ss(e){return as(e)?e:new Ja(e).saturate(.5).darken(.1).hexString()}var cs=[`x`,`y`,`borderWidth`,`radius`,`tension`],ls=[`color`,`borderColor`,`backgroundColor`];function us(e){e.set(`animation`,{delay:void 0,duration:1e3,easing:`easeOutQuart`,fn:void 0,from:void 0,loop:void 0,to:void 0,type:void 0}),e.describe(`animation`,{_fallback:!1,_indexable:!1,_scriptable:e=>e!==`onProgress`&&e!==`onComplete`&&e!==`fn`}),e.set(`animations`,{colors:{type:`color`,properties:ls},numbers:{type:`number`,properties:cs}}),e.describe(`animations`,{_fallback:`animation`}),e.set(`transitions`,{active:{animation:{duration:400}},resize:{animation:{duration:0}},show:{animations:{colors:{from:`transparent`},visible:{type:`boolean`,duration:0}}},hide:{animations:{colors:{to:`transparent`},visible:{type:`boolean`,easing:`linear`,fn:e=>e|0}}}})}function ds(e){e.set(`layout`,{autoPadding:!0,padding:{top:0,right:0,bottom:0,left:0}})}var fs=new Map;function ps(e,t){t||={};let n=e+JSON.stringify(t),r=fs.get(n);return r||(r=new Intl.NumberFormat(e,t),fs.set(n,r)),r}function ms(e,t,n){return ps(t,n).format(e)}var hs={values(e){return W(e)?e:``+e},numeric(e,t,n){if(e===0)return`0`;let r=this.chart.options.locale,i,a=e;if(n.length>1){let t=Math.max(Math.abs(n[0].value),Math.abs(n[n.length-1].value));(t<1e-4||t>0x38d7ea4c68000)&&(i=`scientific`),a=gs(e,n)}let o=So(Math.abs(a)),s=isNaN(o)?1:Math.max(Math.min(-1*Math.floor(o),20),0),c={notation:i,minimumFractionDigits:s,maximumFractionDigits:s};return Object.assign(c,this.options.ticks.format),ms(e,r,c)},logarithmic(e,t,n){if(e===0)return`0`;let r=n[t].significand||e/10**Math.floor(So(e));return[1,2,3,5,10,15].includes(r)||t>.8*n.length?hs.numeric.call(this,e,t,n):``}};function gs(e,t){let n=t.length>3?t[2].value-t[1].value:t[1].value-t[0].value;return Math.abs(n)>=1&&e!==Math.floor(e)&&(n=e-Math.floor(e)),n}var _s={formatters:hs};function vs(e){e.set(`scale`,{display:!0,offset:!1,reverse:!1,beginAtZero:!1,bounds:`ticks`,clip:!0,grace:0,grid:{display:!0,lineWidth:1,drawOnChartArea:!0,drawTicks:!0,tickLength:8,tickWidth:(e,t)=>t.lineWidth,tickColor:(e,t)=>t.color,offset:!1},border:{display:!0,dash:[],dashOffset:0,width:1},title:{display:!1,text:``,padding:{top:4,bottom:4}},ticks:{minRotation:0,maxRotation:50,mirror:!1,textStrokeWidth:0,textStrokeColor:``,padding:3,display:!0,autoSkip:!0,autoSkipPadding:3,labelOffset:0,callback:_s.formatters.values,minor:{},major:{},align:`center`,crossAlign:`near`,showLabelBackdrop:!1,backdropColor:`rgba(255, 255, 255, 0.75)`,backdropPadding:2}}),e.route(`scale.ticks`,`color`,``,`color`),e.route(`scale.grid`,`color`,``,`borderColor`),e.route(`scale.border`,`color`,``,`borderColor`),e.route(`scale.title`,`color`,``,`color`),e.describe(`scale`,{_fallback:!1,_scriptable:e=>!e.startsWith(`before`)&&!e.startsWith(`after`)&&e!==`callback`&&e!==`parser`,_indexable:e=>e!==`borderDash`&&e!==`tickBorderDash`&&e!==`dash`}),e.describe(`scales`,{_fallback:`scale`}),e.describe(`scale.ticks`,{_scriptable:e=>e!==`backdropPadding`&&e!==`callback`,_indexable:e=>e!==`backdropPadding`})}var ys=Object.create(null),bs=Object.create(null);function xs(e,t){if(!t)return e;let n=t.split(`.`);for(let t=0,r=n.length;t<r;++t){let r=n[t];e=e[r]||(e[r]=Object.create(null))}return e}function Ss(e,t,n){return typeof t==`string`?ro(xs(e,t),n):ro(xs(e,``),t)}var Z=new class{constructor(e,t){this.animation=void 0,this.backgroundColor=`rgba(0,0,0,0.1)`,this.borderColor=`rgba(0,0,0,0.1)`,this.color=`#666`,this.datasets={},this.devicePixelRatio=e=>e.chart.platform.getDevicePixelRatio(),this.elements={},this.events=[`mousemove`,`mouseout`,`click`,`touchstart`,`touchmove`],this.font={family:`'Helvetica Neue', 'Helvetica', 'Arial', sans-serif`,size:12,style:`normal`,lineHeight:1.2,weight:null},this.hover={},this.hoverBackgroundColor=(e,t)=>ss(t.backgroundColor),this.hoverBorderColor=(e,t)=>ss(t.borderColor),this.hoverColor=(e,t)=>ss(t.color),this.indexAxis=`x`,this.interaction={mode:`nearest`,intersect:!0,includeInvisible:!1},this.maintainAspectRatio=!0,this.onHover=null,this.onClick=null,this.parsing=!0,this.plugins={},this.responsive=!0,this.scale=void 0,this.scales={},this.showLine=!0,this.drawActiveElementsOnTop=!0,this.describe(e),this.apply(t)}set(e,t){return Ss(this,e,t)}get(e){return xs(this,e)}describe(e,t){return Ss(bs,e,t)}override(e,t){return Ss(ys,e,t)}route(e,t,n,r){let i=xs(this,e),a=xs(this,n),o=`_`+t;Object.defineProperties(i,{[o]:{value:i[t],writable:!0},[t]:{enumerable:!0,get(){let e=this[o],t=a[r];return G(e)?Object.assign({},t,e):q(e,t)},set(e){this[o]=e}}})}apply(e){e.forEach(e=>e(this))}}({_scriptable:e=>!e.startsWith(`on`),_indexable:e=>e!==`events`,hover:{_fallback:`interaction`},interaction:{_scriptable:!1,_indexable:!1}},[us,ds,vs]);function Cs(e){return!e||U(e.size)||U(e.family)?null:(e.style?e.style+` `:``)+(e.weight?e.weight+` `:``)+e.size+`px `+e.family}function ws(e,t,n,r,i){let a=t[i];return a||(a=t[i]=e.measureText(i).width,n.push(i)),a>r&&(r=a),r}function Ts(e,t,n,r){r||={};let i=r.data=r.data||{},a=r.garbageCollect=r.garbageCollect||[];r.font!==t&&(i=r.data={},a=r.garbageCollect=[],r.font=t),e.save(),e.font=t;let o=0,s=n.length,c,l,u,d,f;for(c=0;c<s;c++)if(d=n[c],d!=null&&!W(d))o=ws(e,i,a,o,d);else if(W(d))for(l=0,u=d.length;l<u;l++)f=d[l],f!=null&&!W(f)&&(o=ws(e,i,a,o,f));e.restore();let p=a.length/2;if(p>n.length){for(c=0;c<p;c++)delete i[a[c]];a.splice(0,p)}return o}function Es(e,t,n){let r=e.currentDevicePixelRatio,i=n===0?0:Math.max(n/2,.5);return Math.round((t-i)*r)/r+i}function Ds(e,t){!t&&!e||(t||=e.getContext(`2d`),t.save(),t.resetTransform(),t.clearRect(0,0,e.width,e.height),t.restore())}function Os(e,t,n,r){ks(e,t,n,r,null)}function ks(e,t,n,r,i){let a,o,s,c,l,u,d,f,p=t.pointStyle,m=t.rotation,h=t.radius,g=(m||0)*vo;if(p&&typeof p==`object`&&(a=p.toString(),a===`[object HTMLImageElement]`||a===`[object HTMLCanvasElement]`)){e.save(),e.translate(n,r),e.rotate(g),e.drawImage(p,-p.width/2,-p.height/2,p.width,p.height),e.restore();return}if(!(isNaN(h)||h<=0)){switch(e.beginPath(),p){default:i?e.ellipse(n,r,i/2,h,0,0,go):e.arc(n,r,h,0,go),e.closePath();break;case`triangle`:u=i?i/2:h,e.moveTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=xo,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=xo,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),e.closePath();break;case`rectRounded`:l=h*.516,c=h-l,o=Math.cos(g+bo)*c,d=Math.cos(g+bo)*(i?i/2-l:c),s=Math.sin(g+bo)*c,f=Math.sin(g+bo)*(i?i/2-l:c),e.arc(n-d,r-s,l,g-X,g-yo),e.arc(n+f,r-o,l,g-yo,g),e.arc(n+d,r+s,l,g,g+yo),e.arc(n-f,r+o,l,g+yo,g+X),e.closePath();break;case`rect`:if(!m){c=Math.SQRT1_2*h,u=i?i/2:c,e.rect(n-u,r-c,2*u,2*c);break}g+=bo;case`rectRot`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+f,r-o),e.lineTo(n+d,r+s),e.lineTo(n-f,r+o),e.closePath();break;case`crossRot`:g+=bo;case`cross`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o);break;case`star`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o),g+=bo,d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o);break;case`line`:o=i?i/2:Math.cos(g)*h,s=Math.sin(g)*h,e.moveTo(n-o,r-s),e.lineTo(n+o,r+s);break;case`dash`:e.moveTo(n,r),e.lineTo(n+Math.cos(g)*(i?i/2:h),r+Math.sin(g)*h);break;case!1:e.closePath()}e.fill(),t.borderWidth>0&&e.stroke()}}function As(e,t,n){return n||=.5,!t||e&&e.x>t.left-n&&e.x<t.right+n&&e.y>t.top-n&&e.y<t.bottom+n}function js(e,t){e.save(),e.beginPath(),e.rect(t.left,t.top,t.right-t.left,t.bottom-t.top),e.clip()}function Ms(e){e.restore()}function Ns(e,t){t.translation&&e.translate(t.translation[0],t.translation[1]),U(t.rotation)||e.rotate(t.rotation),t.color&&(e.fillStyle=t.color),t.textAlign&&(e.textAlign=t.textAlign),t.textBaseline&&(e.textBaseline=t.textBaseline)}function Ps(e,t,n,r,i){if(i.strikethrough||i.underline){let a=e.measureText(r),o=t-a.actualBoundingBoxLeft,s=t+a.actualBoundingBoxRight,c=n-a.actualBoundingBoxAscent,l=n+a.actualBoundingBoxDescent,u=i.strikethrough?(c+l)/2:l;e.strokeStyle=e.fillStyle,e.beginPath(),e.lineWidth=i.decorationWidth||2,e.moveTo(o,u),e.lineTo(s,u),e.stroke()}}function Fs(e,t){let n=e.fillStyle;e.fillStyle=t.color,e.fillRect(t.left,t.top,t.width,t.height),e.fillStyle=n}function Is(e,t,n,r,i,a={}){let o=W(t)?t:[t],s=a.strokeWidth>0&&a.strokeColor!==``,c,l;for(e.save(),e.font=i.string,Ns(e,a),c=0;c<o.length;++c)l=o[c],a.backdrop&&Fs(e,a.backdrop),s&&(a.strokeColor&&(e.strokeStyle=a.strokeColor),U(a.strokeWidth)||(e.lineWidth=a.strokeWidth),e.strokeText(l,n,r,a.maxWidth)),e.fillText(l,n,r,a.maxWidth),Ps(e,n,r,l,a),r+=Number(i.lineHeight);e.restore()}function Ls(e,t){let{x:n,y:r,w:i,h:a,radius:o}=t;e.arc(n+o.topLeft,r+o.topLeft,o.topLeft,1.5*X,X,!0),e.lineTo(n,r+a-o.bottomLeft),e.arc(n+o.bottomLeft,r+a-o.bottomLeft,o.bottomLeft,X,yo,!0),e.lineTo(n+i-o.bottomRight,r+a),e.arc(n+i-o.bottomRight,r+a-o.bottomRight,o.bottomRight,yo,0,!0),e.lineTo(n+i,r+o.topRight),e.arc(n+i-o.topRight,r+o.topRight,o.topRight,0,-yo,!0),e.lineTo(n+o.topLeft,r)}var Rs=/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/,zs=/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;function Bs(e,t){let n=(``+e).match(Rs);if(!n||n[1]===`normal`)return t*1.2;switch(e=+n[2],n[3]){case`px`:return e;case`%`:e/=100}return t*e}var Vs=e=>+e||0;function Hs(e,t){let n={},r=G(t),i=r?Object.keys(t):t,a=G(e)?r?n=>q(e[n],e[t[n]]):t=>e[t]:()=>e;for(let e of i)n[e]=Vs(a(e));return n}function Us(e){return Hs(e,{top:`y`,right:`x`,bottom:`y`,left:`x`})}function Ws(e){return Hs(e,[`topLeft`,`topRight`,`bottomLeft`,`bottomRight`])}function Q(e){let t=Us(e);return t.width=t.left+t.right,t.height=t.top+t.bottom,t}function $(e,t){e||={},t||=Z.font;let n=q(e.size,t.size);typeof n==`string`&&(n=parseInt(n,10));let r=q(e.style,t.style);r&&!(``+r).match(zs)&&(console.warn(`Invalid font style specified: "`+r+`"`),r=void 0);let i={family:q(e.family,t.family),lineHeight:Bs(q(e.lineHeight,t.lineHeight),n),size:n,style:r,weight:q(e.weight,t.weight),string:``};return i.string=Cs(i),i}function Gs(e,t,n,r){let i=!0,a,o,s;for(a=0,o=e.length;a<o;++a)if(s=e[a],s!==void 0&&(t!==void 0&&typeof s==`function`&&(s=s(t),i=!1),n!==void 0&&W(s)&&(s=s[n%s.length],i=!1),s!==void 0))return r&&!i&&(r.cacheable=!1),s}function Ks(e,t,n){let{min:r,max:i}=e,a=Qa(t,(i-r)/2),o=(e,t)=>n&&e===0?0:e+t;return{min:o(r,-Math.abs(a)),max:o(i,a)}}function qs(e,t){return Object.assign(Object.create(e),t)}function Js(e,t=[``],n,r,i=()=>e[0]){let a=n||e;return r===void 0&&(r=uc(`_fallback`,e)),new Proxy({[Symbol.toStringTag]:`Object`,_cacheable:!0,_scopes:e,_rootScopes:a,_fallback:r,_getTarget:i,override:n=>Js([n,...e],t,a,r)},{deleteProperty(t,n){return delete t[n],delete t._keys,delete e[0][n],!0},get(n,r){return $s(n,r,()=>lc(r,t,e,n))},getOwnPropertyDescriptor(e,t){return Reflect.getOwnPropertyDescriptor(e._scopes[0],t)},getPrototypeOf(){return Reflect.getPrototypeOf(e[0])},has(e,t){return dc(e).includes(t)},ownKeys(e){return dc(e)},set(e,t,n){let r=e._storage||=i();return e[t]=r[t]=n,delete e._keys,!0}})}function Ys(e,t,n,r){let i={_cacheable:!1,_proxy:e,_context:t,_subProxy:n,_stack:new Set,_descriptors:Xs(e,r),setContext:t=>Ys(e,t,n,r),override:i=>Ys(e.override(i),t,n,r)};return new Proxy(i,{deleteProperty(t,n){return delete t[n],delete e[n],!0},get(e,t,n){return $s(e,t,()=>ec(e,t,n))},getOwnPropertyDescriptor(t,n){return t._descriptors.allKeys?Reflect.has(e,n)?{enumerable:!0,configurable:!0}:void 0:Reflect.getOwnPropertyDescriptor(e,n)},getPrototypeOf(){return Reflect.getPrototypeOf(e)},has(t,n){return Reflect.has(e,n)},ownKeys(){return Reflect.ownKeys(e)},set(t,n,r){return e[n]=r,delete t[n],!0}})}function Xs(e,t={scriptable:!0,indexable:!0}){let{_scriptable:n=t.scriptable,_indexable:r=t.indexable,_allKeys:i=t.allKeys}=e;return{allKeys:i,scriptable:n,indexable:r,isScriptable:po(n)?n:()=>n,isIndexable:po(r)?r:()=>r}}var Zs=(e,t)=>e?e+uo(t):t,Qs=(e,t)=>G(t)&&e!==`adapters`&&(Object.getPrototypeOf(t)===null||t.constructor===Object);function $s(e,t,n){if(Object.prototype.hasOwnProperty.call(e,t)||t===`constructor`)return e[t];let r=n();return e[t]=r,r}function ec(e,t,n){let{_proxy:r,_context:i,_subProxy:a,_descriptors:o}=e,s=r[t];return po(s)&&o.isScriptable(t)&&(s=tc(t,s,e,n)),W(s)&&s.length&&(s=nc(t,s,e,o.isIndexable)),Qs(t,s)&&(s=Ys(s,i,a&&a[t],o)),s}function tc(e,t,n,r){let{_proxy:i,_context:a,_subProxy:o,_stack:s}=n;if(s.has(e))throw Error(`Recursion detected: `+Array.from(s).join(`->`)+`->`+e);s.add(e);let c=t(a,o||r);return s.delete(e),Qs(e,c)&&(c=oc(i._scopes,i,e,c)),c}function nc(e,t,n,r){let{_proxy:i,_context:a,_subProxy:o,_descriptors:s}=n;if(a.index!==void 0&&r(e))return t[a.index%t.length];if(G(t[0])){let n=t,r=i._scopes.filter(e=>e!==n);t=[];for(let c of n){let n=oc(r,i,e,c);t.push(Ys(n,a,o&&o[e],s))}}return t}function rc(e,t,n){return po(e)?e(t,n):e}var ic=(e,t)=>e===!0?t:typeof e==`string`?lo(t,e):void 0;function ac(e,t,n,r,i){for(let a of t){let t=ic(n,a);if(t){e.add(t);let a=rc(t._fallback,n,i);if(a!==void 0&&a!==n&&a!==r)return a}else if(t===!1&&r!==void 0&&n!==r)return null}return!1}function oc(e,t,n,r){let i=t._rootScopes,a=rc(t._fallback,n,r),o=[...e,...i],s=new Set;s.add(r);let c=sc(s,o,n,a||n,r);return c===null||a!==void 0&&a!==n&&(c=sc(s,o,a,c,r),c===null)?!1:Js(Array.from(s),[``],i,a,()=>cc(t,n,r))}function sc(e,t,n,r,i){for(;n;)n=ac(e,t,n,r,i);return n}function cc(e,t,n){let r=e._getTarget();t in r||(r[t]={});let i=r[t];return W(i)&&G(n)?n:i||{}}function lc(e,t,n,r){let i;for(let a of t)if(i=uc(Zs(a,e),n),i!==void 0)return Qs(e,i)?oc(n,r,e,i):i}function uc(e,t){for(let n of t){if(!n)continue;let t=n[e];if(t!==void 0)return t}}function dc(e){let t=e._keys;return t||=e._keys=fc(e._scopes),t}function fc(e){let t=new Set;for(let n of e)for(let e of Object.keys(n).filter(e=>!e.startsWith(`_`)))t.add(e);return Array.from(t)}function pc(){return typeof window<`u`&&typeof document<`u`}function mc(e){let t=e.parentNode;return t&&t.toString()===`[object ShadowRoot]`&&(t=t.host),t}function hc(e,t,n){let r;return typeof e==`string`?(r=parseInt(e,10),e.indexOf(`%`)!==-1&&(r=r/100*t.parentNode[n])):r=e,r}var gc=e=>e.ownerDocument.defaultView.getComputedStyle(e,null);function _c(e,t){return gc(e).getPropertyValue(t)}var vc=[`top`,`right`,`bottom`,`left`];function yc(e,t,n){let r={};n=n?`-`+n:``;for(let i=0;i<4;i++){let a=vc[i];r[a]=parseFloat(e[t+`-`+a+n])||0}return r.width=r.left+r.right,r.height=r.top+r.bottom,r}var bc=(e,t,n)=>(e>0||t>0)&&(!n||!n.shadowRoot);function xc(e,t){let n=e.touches,r=n&&n.length?n[0]:e,{offsetX:i,offsetY:a}=r,o=!1,s,c;if(bc(i,a,e.target))s=i,c=a;else{let e=t.getBoundingClientRect();s=r.clientX-e.left,c=r.clientY-e.top,o=!0}return{x:s,y:c,box:o}}function Sc(e,t){if(`native`in e)return e;let{canvas:n,currentDevicePixelRatio:r}=t,i=gc(n),a=i.boxSizing===`border-box`,o=yc(i,`padding`),s=yc(i,`border`,`width`),{x:c,y:l,box:u}=xc(e,n),d=o.left+(u&&s.left),f=o.top+(u&&s.top),{width:p,height:m}=t;return a&&(p-=o.width+s.width,m-=o.height+s.height),{x:Math.round((c-d)/p*n.width/r),y:Math.round((l-f)/m*n.height/r)}}function Cc(e,t,n){let r,i;if(t===void 0||n===void 0){let a=e&&mc(e);if(!a)t=e.clientWidth,n=e.clientHeight;else{let e=a.getBoundingClientRect(),o=gc(a),s=yc(o,`border`,`width`),c=yc(o,`padding`);t=e.width-c.width-s.width,n=e.height-c.height-s.height,r=hc(o.maxWidth,a,`clientWidth`),i=hc(o.maxHeight,a,`clientHeight`)}}return{width:t,height:n,maxWidth:r||_o,maxHeight:i||_o}}var wc=e=>Math.round(e*10)/10;function Tc(e,t,n,r){let i=gc(e),a=yc(i,`margin`),o=hc(i.maxWidth,e,`clientWidth`)||_o,s=hc(i.maxHeight,e,`clientHeight`)||_o,c=Cc(e,t,n),{width:l,height:u}=c;if(i.boxSizing===`content-box`){let e=yc(i,`border`,`width`),t=yc(i,`padding`);l-=t.width+e.width,u-=t.height+e.height}return l=Math.max(0,l-a.width),u=Math.max(0,r?l/r:u-a.height),l=wc(Math.min(l,o,c.maxWidth)),u=wc(Math.min(u,s,c.maxHeight)),l&&!u&&(u=wc(l/2)),(t!==void 0||n!==void 0)&&r&&c.height&&u>c.height&&(u=c.height,l=wc(Math.floor(u*r))),{width:l,height:u}}function Ec(e,t,n){let r=t||1,i=wc(e.height*r),a=wc(e.width*r);e.height=wc(e.height),e.width=wc(e.width);let o=e.canvas;return o.style&&(n||!o.style.height&&!o.style.width)&&(o.style.height=`${e.height}px`,o.style.width=`${e.width}px`),e.currentDevicePixelRatio!==r||o.height!==i||o.width!==a?(e.currentDevicePixelRatio=r,o.height=i,o.width=a,e.ctx.setTransform(r,0,0,r,0,0),!0):!1}var Dc=function(){let e=!1;try{let t={get passive(){return e=!0,!1}};pc()&&(window.addEventListener(`test`,null,t),window.removeEventListener(`test`,null,t))}catch{}return e}();function Oc(e,t){let n=_c(e,t),r=n&&n.match(/^(\d+)(\.\d+)?px$/);return r?+r[1]:void 0}var kc=function(e,t){return{x(n){return e+e+t-n},setWidth(e){t=e},textAlign(e){return e===`center`?e:e===`right`?`left`:`right`},xPlus(e,t){return e-t},leftForLtr(e,t){return e-t}}},Ac=function(){return{x(e){return e},setWidth(e){},textAlign(e){return e},xPlus(e,t){return e+t},leftForLtr(e,t){return e}}};function jc(e,t,n){return e?kc(t,n):Ac()}function Mc(e,t){let n,r;(t===`ltr`||t===`rtl`)&&(n=e.canvas.style,r=[n.getPropertyValue(`direction`),n.getPropertyPriority(`direction`)],n.setProperty(`direction`,t,`important`),e.prevTextDirection=r)}function Nc(e,t){t!==void 0&&(delete e.prevTextDirection,e.canvas.style.setProperty(`direction`,t[0],t[1]))}function Pc(e,t,n){return e.options.clip?e[n]:t[n]}function Fc(e,t){let{xScale:n,yScale:r}=e;return n&&r?{left:Pc(n,t,`left`),right:Pc(n,t,`right`),top:Pc(r,t,`top`),bottom:Pc(r,t,`bottom`)}:t}function Ic(e,t){let n=t._clip;if(n.disabled)return!1;let r=Fc(t,e.chartArea);return{left:n.left===!1?0:r.left-(n.left===!0?0:n.left),right:n.right===!1?e.width:r.right+(n.right===!0?0:n.right),top:n.top===!1?0:r.top-(n.top===!0?0:n.top),bottom:n.bottom===!1?e.height:r.bottom+(n.bottom===!0?0:n.bottom)}}var Lc=new class{constructor(){this._request=null,this._charts=new Map,this._running=!1,this._lastDate=void 0}_notify(e,t,n,r){let i=t.listeners[r],a=t.duration;i.forEach(r=>r({chart:e,initial:t.initial,numSteps:a,currentStep:Math.min(n-t.start,a)}))}_refresh(){this._request||=(this._running=!0,Yo.call(window,()=>{this._update(),this._request=null,this._running&&this._refresh()}))}_update(e=Date.now()){let t=0;this._charts.forEach((n,r)=>{if(!n.running||!n.items.length)return;let i=n.items,a=i.length-1,o=!1,s;for(;a>=0;--a)s=i[a],s._active?(s._total>n.duration&&(n.duration=s._total),s.tick(e),o=!0):(i[a]=i[i.length-1],i.pop());o&&(r.draw(),this._notify(r,n,e,`progress`)),i.length||(n.running=!1,this._notify(r,n,e,`complete`),n.initial=!1),t+=i.length}),this._lastDate=e,t===0&&(this._running=!1)}_getAnims(e){let t=this._charts,n=t.get(e);return n||(n={running:!1,initial:!0,items:[],listeners:{complete:[],progress:[]}},t.set(e,n)),n}listen(e,t,n){this._getAnims(e).listeners[t].push(n)}add(e,t){!t||!t.length||this._getAnims(e).items.push(...t)}has(e){return this._getAnims(e).items.length>0}start(e){let t=this._charts.get(e);t&&(t.running=!0,t.start=Date.now(),t.duration=t.items.reduce((e,t)=>Math.max(e,t._duration),0),this._refresh())}running(e){if(!this._running)return!1;let t=this._charts.get(e);return!(!t||!t.running||!t.items.length)}stop(e){let t=this._charts.get(e);if(!t||!t.items.length)return;let n=t.items,r=n.length-1;for(;r>=0;--r)n[r].cancel();t.items=[],this._notify(e,t,Date.now(),`complete`)}remove(e){return this._charts.delete(e)}},Rc=`transparent`,zc={boolean(e,t,n){return n>.5?t:e},color(e,t,n){let r=os(e||Rc),i=r.valid&&os(t||Rc);return i&&i.valid?i.mix(r,n).hexString():t},number(e,t,n){return e+(t-e)*n}},Bc=class{constructor(e,t,n,r){let i=t[n];r=Gs([e.to,r,i,e.from]);let a=Gs([e.from,i,r]);this._active=!0,this._fn=e.fn||zc[e.type||typeof a],this._easing=is[e.easing]||is.linear,this._start=Math.floor(Date.now()+(e.delay||0)),this._duration=this._total=Math.floor(e.duration),this._loop=!!e.loop,this._target=t,this._prop=n,this._from=a,this._to=r,this._promises=void 0}active(){return this._active}update(e,t,n){if(this._active){this._notify(!1);let r=this._target[this._prop],i=n-this._start,a=this._duration-i;this._start=n,this._duration=Math.floor(Math.max(a,e.duration)),this._total+=i,this._loop=!!e.loop,this._to=Gs([e.to,t,r,e.from]),this._from=Gs([e.from,r,t])}}cancel(){this._active&&(this.tick(Date.now()),this._active=!1,this._notify(!1))}tick(e){let t=e-this._start,n=this._duration,r=this._prop,i=this._from,a=this._loop,o=this._to,s;if(this._active=i!==o&&(a||t<n),!this._active){this._target[r]=o,this._notify(!0);return}if(t<0){this._target[r]=i;return}s=t/n%2,s=a&&s>1?2-s:s,s=this._easing(Math.min(1,Math.max(0,s))),this._target[r]=this._fn(i,o,s)}wait(){let e=this._promises||=[];return new Promise((t,n)=>{e.push({res:t,rej:n})})}_notify(e){let t=e?`res`:`rej`,n=this._promises||[];for(let e=0;e<n.length;e++)n[e][t]()}},Vc=class{constructor(e,t){this._chart=e,this._properties=new Map,this.configure(t)}configure(e){if(!G(e))return;let t=Object.keys(Z.animation),n=this._properties;Object.getOwnPropertyNames(e).forEach(r=>{let i=e[r];if(!G(i))return;let a={};for(let e of t)a[e]=i[e];(W(i.properties)&&i.properties||[r]).forEach(e=>{(e===r||!n.has(e))&&n.set(e,a)})})}_animateOptions(e,t){let n=t.options,r=Uc(e,n);if(!r)return[];let i=this._createAnimations(r,n);return n.$shared&&Hc(e.options.$animations,n).then(()=>{e.options=n},()=>{}),i}_createAnimations(e,t){let n=this._properties,r=[],i=e.$animations||={},a=Object.keys(t),o=Date.now(),s;for(s=a.length-1;s>=0;--s){let c=a[s];if(c.charAt(0)===`$`)continue;if(c===`options`){r.push(...this._animateOptions(e,t));continue}let l=t[c],u=i[c],d=n.get(c);if(u){if(d&&u.active()){u.update(d,l,o);continue}u.cancel()}if(!d||!d.duration){e[c]=l;continue}i[c]=u=new Bc(d,e,c,l),r.push(u)}return r}update(e,t){if(this._properties.size===0){Object.assign(e,t);return}let n=this._createAnimations(e,t);if(n.length)return Lc.add(this._chart,n),!0}};function Hc(e,t){let n=[],r=Object.keys(t);for(let t=0;t<r.length;t++){let i=e[r[t]];i&&i.active()&&n.push(i.wait())}return Promise.all(n)}function Uc(e,t){if(!t)return;let n=e.options;if(!n){e.options=t;return}return n.$shared&&(e.options=n=Object.assign({},n,{$shared:!1,$animations:{}})),n}function Wc(e,t){let n=e&&e.options||{},r=n.reverse,i=n.min===void 0?t:0,a=n.max===void 0?t:0;return{start:r?a:i,end:r?i:a}}function Gc(e,t,n){if(n===!1)return!1;let r=Wc(e,n),i=Wc(t,n);return{top:i.end,right:r.end,bottom:i.start,left:r.start}}function Kc(e){let t,n,r,i;return G(e)?(t=e.top,n=e.right,r=e.bottom,i=e.left):t=n=r=i=e,{top:t,right:n,bottom:r,left:i,disabled:e===!1}}function qc(e,t){let n=[],r=e._getSortedDatasetMetas(t),i,a;for(i=0,a=r.length;i<a;++i)n.push(r[i].index);return n}function Jc(e,t,n,r={}){let i=e.keys,a=r.mode===`single`,o,s,c,l;if(t===null)return;let u=!1;for(o=0,s=i.length;o<s;++o){if(c=+i[o],c===n){if(u=!0,r.all)continue;break}l=e.values[c],K(l)&&(a||t===0||Co(t)===Co(l))&&(t+=l)}return!u&&!r.all?0:t}function Yc(e,t){let{iScale:n,vScale:r}=t,i=n.axis===`x`?`x`:`y`,a=r.axis===`x`?`x`:`y`,o=Object.keys(e),s=Array(o.length),c,l,u;for(c=0,l=o.length;c<l;++c)u=o[c],s[c]={[i]:u,[a]:e[u]};return s}function Xc(e,t){let n=e&&e.options.stacked;return n||n===void 0&&t.stack!==void 0}function Zc(e,t,n){return`${e.id}.${t.id}.${n.stack||n.type}`}function Qc(e){let{min:t,max:n,minDefined:r,maxDefined:i}=e.getUserBounds();return{min:r?t:-1/0,max:i?n:1/0}}function $c(e,t,n){let r=e[t]||(e[t]={});return r[n]||(r[n]={})}function el(e,t,n,r){for(let i of t.getMatchingVisibleMetas(r).reverse()){let t=e[i.index];if(n&&t>0||!n&&t<0)return i.index}return null}function tl(e,t){let{chart:n,_cachedMeta:r}=e,i=n._stacks||={},{iScale:a,vScale:o,index:s}=r,c=a.axis,l=o.axis,u=Zc(a,o,r),d=t.length,f;for(let e=0;e<d;++e){let n=t[e],{[c]:a,[l]:d}=n,p=n._stacks||={};f=p[l]=$c(i,u,a),f[s]=d,f._top=el(f,o,!0,r.type),f._bottom=el(f,o,!1,r.type);let m=f._visualValues||(f._visualValues={});m[s]=d}}function nl(e,t){let n=e.scales;return Object.keys(n).filter(e=>n[e].axis===t).shift()}function rl(e,t){return qs(e,{active:!1,dataset:void 0,datasetIndex:t,index:t,mode:`default`,type:`dataset`})}function il(e,t,n){return qs(e,{active:!1,dataIndex:t,parsed:void 0,raw:void 0,element:n,index:t,mode:`default`,type:`data`})}function al(e,t){let n=e.controller.index,r=e.vScale&&e.vScale.axis;if(r){t||=e._parsed;for(let e of t){let t=e._stacks;if(!t||t[r]===void 0||t[r][n]===void 0)return;delete t[r][n],t[r]._visualValues!==void 0&&t[r]._visualValues[n]!==void 0&&delete t[r]._visualValues[n]}}}var ol=e=>e===`reset`||e===`none`,sl=(e,t)=>t?e:Object.assign({},e),cl=(e,t,n)=>e&&!t.hidden&&t._stacked&&{keys:qc(n,!0),values:null},ll=class{static defaults={};static datasetElementType=null;static dataElementType=null;constructor(e,t){this.chart=e,this._ctx=e.ctx,this.index=t,this._cachedDataOpts={},this._cachedMeta=this.getMeta(),this._type=this._cachedMeta.type,this.options=void 0,this._parsing=!1,this._data=void 0,this._objectData=void 0,this._sharedOptions=void 0,this._drawStart=void 0,this._drawCount=void 0,this.enableOptionSharing=!1,this.supportsDecimation=!1,this.$context=void 0,this._syncList=[],this.datasetElementType=new.target.datasetElementType,this.dataElementType=new.target.dataElementType,this.initialize()}initialize(){let e=this._cachedMeta;this.configure(),this.linkScales(),e._stacked=Xc(e.vScale,e),this.addElements(),this.options.fill&&!this.chart.isPluginEnabled(`filler`)&&console.warn(`Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options`)}updateIndex(e){this.index!==e&&al(this._cachedMeta),this.index=e}linkScales(){let e=this.chart,t=this._cachedMeta,n=this.getDataset(),r=(e,t,n,r)=>e===`x`?t:e===`r`?r:n,i=t.xAxisID=q(n.xAxisID,nl(e,`x`)),a=t.yAxisID=q(n.yAxisID,nl(e,`y`)),o=t.rAxisID=q(n.rAxisID,nl(e,`r`)),s=t.indexAxis,c=t.iAxisID=r(s,i,a,o),l=t.vAxisID=r(s,a,i,o);t.xScale=this.getScaleForId(i),t.yScale=this.getScaleForId(a),t.rScale=this.getScaleForId(o),t.iScale=this.getScaleForId(c),t.vScale=this.getScaleForId(l)}getDataset(){return this.chart.data.datasets[this.index]}getMeta(){return this.chart.getDatasetMeta(this.index)}getScaleForId(e){return this.chart.scales[e]}_getOtherScale(e){let t=this._cachedMeta;return e===t.iScale?t.vScale:t.iScale}reset(){this._update(`reset`)}_destroy(){let e=this._cachedMeta;this._data&&qo(this._data,this),e._stacked&&al(e)}_dataCheck(){let e=this.getDataset(),t=e.data||=[],n=this._data;if(G(t)){let e=this._cachedMeta;this._data=Yc(t,e)}else if(n!==t){if(n){qo(n,this);let e=this._cachedMeta;al(e),e._parsed=[]}t&&Object.isExtensible(t)&&Ko(t,this),this._syncList=[],this._data=t}}addElements(){let e=this._cachedMeta;this._dataCheck(),this.datasetElementType&&(e.dataset=new this.datasetElementType)}buildOrUpdateElements(e){let t=this._cachedMeta,n=this.getDataset(),r=!1;this._dataCheck();let i=t._stacked;t._stacked=Xc(t.vScale,t),t.stack!==n.stack&&(r=!0,al(t),t.stack=n.stack),this._resyncElements(e),(r||i!==t._stacked)&&(tl(this,t._parsed),t._stacked=Xc(t.vScale,t))}configure(){let e=this.chart.config,t=e.datasetScopeKeys(this._type),n=e.getOptionScopes(this.getDataset(),t,!0);this.options=e.createResolver(n,this.getContext()),this._parsing=this.options.parsing,this._cachedDataOpts={}}parse(e,t){let{_cachedMeta:n,_data:r}=this,{iScale:i,_stacked:a}=n,o=i.axis,s=e===0&&t===r.length||n._sorted,c=e>0&&n._parsed[e-1],l,u,d;if(this._parsing===!1)n._parsed=r,n._sorted=!0,d=r;else{d=W(r[e])?this.parseArrayData(n,r,e,t):G(r[e])?this.parseObjectData(n,r,e,t):this.parsePrimitiveData(n,r,e,t);let i=()=>u[o]===null||c&&u[o]<c[o];for(l=0;l<t;++l)n._parsed[l+e]=u=d[l],s&&(i()&&(s=!1),c=u);n._sorted=s}a&&tl(this,d)}parsePrimitiveData(e,t,n,r){let{iScale:i,vScale:a}=e,o=i.axis,s=a.axis,c=i.getLabels(),l=i===a,u=Array(r),d,f,p;for(d=0,f=r;d<f;++d)p=d+n,u[d]={[o]:l||i.parse(c[p],p),[s]:a.parse(t[p],p)};return u}parseArrayData(e,t,n,r){let{xScale:i,yScale:a}=e,o=Array(r),s,c,l,u;for(s=0,c=r;s<c;++s)l=s+n,u=t[l],o[s]={x:i.parse(u[0],l),y:a.parse(u[1],l)};return o}parseObjectData(e,t,n,r){let{xScale:i,yScale:a}=e,{xAxisKey:o=`x`,yAxisKey:s=`y`}=this._parsing,c=Array(r),l,u,d,f;for(l=0,u=r;l<u;++l)d=l+n,f=t[d],c[l]={x:i.parse(lo(f,o),d),y:a.parse(lo(f,s),d)};return c}getParsed(e){return this._cachedMeta._parsed[e]}getDataElement(e){return this._cachedMeta.data[e]}applyStack(e,t,n){let r=this.chart,i=this._cachedMeta,a=t[e.axis];return Jc({keys:qc(r,!0),values:t._stacks[e.axis]._visualValues},a,i.index,{mode:n})}updateRangeFromParsed(e,t,n,r){let i=n[t.axis],a=i===null?NaN:i,o=r&&n._stacks[t.axis];r&&o&&(r.values=o,a=Jc(r,i,this._cachedMeta.index)),e.min=Math.min(e.min,a),e.max=Math.max(e.max,a)}getMinMax(e,t){let n=this._cachedMeta,r=n._parsed,i=n._sorted&&e===n.iScale,a=r.length,o=this._getOtherScale(e),s=cl(t,n,this.chart),c={min:1/0,max:-1/0},{min:l,max:u}=Qc(o),d,f;function p(){f=r[d];let t=f[o.axis];return!K(f[e.axis])||l>t||u<t}for(d=0;d<a&&!(!p()&&(this.updateRangeFromParsed(c,e,f,s),i));++d);if(i){for(d=a-1;d>=0;--d)if(!p()){this.updateRangeFromParsed(c,e,f,s);break}}return c}getAllParsedValues(e){let t=this._cachedMeta._parsed,n=[],r,i,a;for(r=0,i=t.length;r<i;++r)a=t[r][e.axis],K(a)&&n.push(a);return n}getMaxOverflow(){return!1}getLabelAndValue(e){let t=this._cachedMeta,n=t.iScale,r=t.vScale,i=this.getParsed(e);return{label:n?``+n.getLabelForValue(i[n.axis]):``,value:r?``+r.getLabelForValue(i[r.axis]):``}}_update(e){let t=this._cachedMeta;this.update(e||`default`),t._clip=Kc(q(this.options.clip,Gc(t.xScale,t.yScale,this.getMaxOverflow())))}update(e){}draw(){let e=this._ctx,t=this.chart,n=this._cachedMeta,r=n.data||[],i=t.chartArea,a=[],o=this._drawStart||0,s=this._drawCount||r.length-o,c=this.options.drawActiveElementsOnTop,l;for(n.dataset&&n.dataset.draw(e,i,o,s),l=o;l<o+s;++l){let t=r[l];t.hidden||(t.active&&c?a.push(t):t.draw(e,i))}for(l=0;l<a.length;++l)a[l].draw(e,i)}getStyle(e,t){let n=t?`active`:`default`;return e===void 0&&this._cachedMeta.dataset?this.resolveDatasetElementOptions(n):this.resolveDataElementOptions(e||0,n)}getContext(e,t,n){let r=this.getDataset(),i;if(e>=0&&e<this._cachedMeta.data.length){let t=this._cachedMeta.data[e];i=t.$context||=il(this.getContext(),e,t),i.parsed=this.getParsed(e),i.raw=r.data[e],i.index=i.dataIndex=e}else i=this.$context||=rl(this.chart.getContext(),this.index),i.dataset=r,i.index=i.datasetIndex=this.index;return i.active=!!t,i.mode=n,i}resolveDatasetElementOptions(e){return this._resolveElementOptions(this.datasetElementType.id,e)}resolveDataElementOptions(e,t){return this._resolveElementOptions(this.dataElementType.id,t,e)}_resolveElementOptions(e,t=`default`,n){let r=t===`active`,i=this._cachedDataOpts,a=e+`-`+t,o=i[a],s=this.enableOptionSharing&&fo(n);if(o)return sl(o,s);let c=this.chart.config,l=c.datasetElementScopeKeys(this._type,e),u=r?[`${e}Hover`,`hover`,e,``]:[e,``],d=c.getOptionScopes(this.getDataset(),l),f=Object.keys(Z.elements[e]),p=c.resolveNamedOptions(d,f,()=>this.getContext(n,r,t),u);return p.$shared&&(p.$shared=s,i[a]=Object.freeze(sl(p,s))),p}_resolveAnimations(e,t,n){let r=this.chart,i=this._cachedDataOpts,a=`animation-${t}`,o=i[a];if(o)return o;let s;if(r.options.animation!==!1){let r=this.chart.config,i=r.datasetAnimationScopeKeys(this._type,t),a=r.getOptionScopes(this.getDataset(),i);s=r.createResolver(a,this.getContext(e,n,t))}let c=new Vc(r,s&&s.animations);return s&&s._cacheable&&(i[a]=Object.freeze(c)),c}getSharedOptions(e){if(e.$shared)return this._sharedOptions||=Object.assign({},e)}includeOptions(e,t){return!t||ol(e)||this.chart._animationsDisabled}_getSharedOptions(e,t){let n=this.resolveDataElementOptions(e,t),r=this._sharedOptions,i=this.getSharedOptions(n),a=this.includeOptions(t,i)||i!==r;return this.updateSharedOptions(i,t,n),{sharedOptions:i,includeOptions:a}}updateElement(e,t,n,r){ol(r)?Object.assign(e,n):this._resolveAnimations(t,r).update(e,n)}updateSharedOptions(e,t,n){e&&!ol(t)&&this._resolveAnimations(void 0,t).update(e,n)}_setStyle(e,t,n,r){e.active=r;let i=this.getStyle(t,r);this._resolveAnimations(t,n,r).update(e,{options:!r&&this.getSharedOptions(i)||i})}removeHoverStyle(e,t,n){this._setStyle(e,n,`active`,!1)}setHoverStyle(e,t,n){this._setStyle(e,n,`active`,!0)}_removeDatasetHoverStyle(){let e=this._cachedMeta.dataset;e&&this._setStyle(e,void 0,`active`,!1)}_setDatasetHoverStyle(){let e=this._cachedMeta.dataset;e&&this._setStyle(e,void 0,`active`,!0)}_resyncElements(e){let t=this._data,n=this._cachedMeta.data;for(let[e,t,n]of this._syncList)this[e](t,n);this._syncList=[];let r=n.length,i=t.length,a=Math.min(i,r);a&&this.parse(0,a),i>r?this._insertElements(r,i-r,e):i<r&&this._removeElements(i,r-i)}_insertElements(e,t,n=!0){let r=this._cachedMeta,i=r.data,a=e+t,o,s=e=>{for(e.length+=t,o=e.length-1;o>=a;o--)e[o]=e[o-t]};for(s(i),o=e;o<a;++o)i[o]=new this.dataElementType;this._parsing&&s(r._parsed),this.parse(e,t),n&&this.updateElements(i,e,t,`reset`)}updateElements(e,t,n,r){}_removeElements(e,t){let n=this._cachedMeta;if(this._parsing){let r=n._parsed.splice(e,t);n._stacked&&al(n,r)}n.data.splice(e,t)}_sync(e){if(this._parsing)this._syncList.push(e);else{let[t,n,r]=e;this[t](n,r)}this.chart._dataChanges.push([this.index,...e])}_onDataPush(){let e=arguments.length;this._sync([`_insertElements`,this.getDataset().data.length-e,e])}_onDataPop(){this._sync([`_removeElements`,this._cachedMeta.data.length-1,1])}_onDataShift(){this._sync([`_removeElements`,0,1])}_onDataSplice(e,t){t&&this._sync([`_removeElements`,e,t]);let n=arguments.length-2;n&&this._sync([`_insertElements`,e,n])}_onDataUnshift(){this._sync([`_insertElements`,0,arguments.length])}};function ul(e,t){if(!e._cache.$bar){let n=e.getMatchingVisibleMetas(t),r=[];for(let t=0,i=n.length;t<i;t++)r=r.concat(n[t].controller.getAllParsedValues(e));e._cache.$bar=Jo(r.sort((e,t)=>e-t))}return e._cache.$bar}function dl(e){let t=e.iScale,n=ul(t,e.type),r=t._length,i,a,o,s,c=()=>{o!==32767&&o!==-32768&&(fo(s)&&(r=Math.min(r,Math.abs(o-s)||r)),s=o)};for(i=0,a=n.length;i<a;++i)o=t.getPixelForValue(n[i]),c();for(s=void 0,i=0,a=t.ticks.length;i<a;++i)o=t.getPixelForTick(i),c();return r}function fl(e,t,n,r){let i=n.barThickness,a,o;return U(i)?(a=t.min*n.categoryPercentage,o=n.barPercentage):(a=i*r,o=1),{chunk:a/r,ratio:o,start:t.pixels[e]-a/2}}function pl(e,t,n,r){let i=t.pixels,a=i[e],o=e>0?i[e-1]:null,s=e<i.length-1?i[e+1]:null,c=n.categoryPercentage;o===null&&(o=a-(s===null?t.end-t.start:s-a)),s===null&&(s=a+a-o);let l=a-(a-Math.min(o,s))/2*c;return{chunk:Math.abs(s-o)/2*c/r,ratio:n.barPercentage,start:l}}function ml(e,t,n,r){let i=n.parse(e[0],r),a=n.parse(e[1],r),o=Math.min(i,a),s=Math.max(i,a),c=o,l=s;Math.abs(o)>Math.abs(s)&&(c=s,l=o),t[n.axis]=l,t._custom={barStart:c,barEnd:l,start:i,end:a,min:o,max:s}}function hl(e,t,n,r){return W(e)?ml(e,t,n,r):t[n.axis]=n.parse(e,r),t}function gl(e,t,n,r){let i=e.iScale,a=e.vScale,o=i.getLabels(),s=i===a,c=[],l,u,d,f;for(l=n,u=n+r;l<u;++l)f=t[l],d={},d[i.axis]=s||i.parse(o[l],l),c.push(hl(f,d,a,l));return c}function _l(e){return e&&e.barStart!==void 0&&e.barEnd!==void 0}function vl(e,t,n){return e===0?(t.isHorizontal()?1:-1)*(t.min>=n?1:-1):Co(e)}function yl(e){let t,n,r,i,a;return e.horizontal?(t=e.base>e.x,n=`left`,r=`right`):(t=e.base<e.y,n=`bottom`,r=`top`),t?(i=`end`,a=`start`):(i=`start`,a=`end`),{start:n,end:r,reverse:t,top:i,bottom:a}}function bl(e,t,n,r){let i=t.borderSkipped,a={};if(!i){e.borderSkipped=a;return}if(i===!0){e.borderSkipped={top:!0,right:!0,bottom:!0,left:!0};return}let{start:o,end:s,reverse:c,top:l,bottom:u}=yl(e);i===`middle`&&n&&(e.enableBorderRadius=!0,(n._top||0)===r?i=l:(n._bottom||0)===r?i=u:(a[xl(u,o,s,c)]=!0,i=l)),a[xl(i,o,s,c)]=!0,e.borderSkipped=a}function xl(e,t,n,r){return r?(e=Sl(e,t,n),e=Cl(e,n,t)):e=Cl(e,t,n),e}function Sl(e,t,n){return e===t?n:e===n?t:e}function Cl(e,t,n){return e===`start`?t:e===`end`?n:e}function wl(e,{inflateAmount:t},n){e.inflateAmount=t===`auto`?n===1?.33:0:t}var Tl=class extends ll{static id=`bar`;static defaults={datasetElementType:!1,dataElementType:`bar`,categoryPercentage:.8,barPercentage:.9,grouped:!0,animations:{numbers:{type:`number`,properties:[`x`,`y`,`base`,`width`,`height`]}}};static overrides={scales:{_index_:{type:`category`,offset:!0,grid:{offset:!0}},_value_:{type:`linear`,beginAtZero:!0}}};parsePrimitiveData(e,t,n,r){return gl(e,t,n,r)}parseArrayData(e,t,n,r){return gl(e,t,n,r)}parseObjectData(e,t,n,r){let{iScale:i,vScale:a}=e,{xAxisKey:o=`x`,yAxisKey:s=`y`}=this._parsing,c=i.axis===`x`?o:s,l=a.axis===`x`?o:s,u=[],d,f,p,m;for(d=n,f=n+r;d<f;++d)m=t[d],p={},p[i.axis]=i.parse(lo(m,c),d),u.push(hl(lo(m,l),p,a,d));return u}updateRangeFromParsed(e,t,n,r){super.updateRangeFromParsed(e,t,n,r);let i=n._custom;i&&t===this._cachedMeta.vScale&&(e.min=Math.min(e.min,i.min),e.max=Math.max(e.max,i.max))}getMaxOverflow(){return 0}getLabelAndValue(e){let{iScale:t,vScale:n}=this._cachedMeta,r=this.getParsed(e),i=r._custom,a=_l(i)?`[`+i.start+`, `+i.end+`]`:``+n.getLabelForValue(r[n.axis]);return{label:``+t.getLabelForValue(r[t.axis]),value:a}}initialize(){this.enableOptionSharing=!0,super.initialize();let e=this._cachedMeta;e.stack=this.getDataset().stack}update(e){let t=this._cachedMeta;this.updateElements(t.data,0,t.data.length,e)}updateElements(e,t,n,r){let i=r===`reset`,{index:a,_cachedMeta:{vScale:o}}=this,s=o.getBasePixel(),c=o.isHorizontal(),l=this._getRuler(),{sharedOptions:u,includeOptions:d}=this._getSharedOptions(t,r);for(let f=t;f<t+n;f++){let t=this.getParsed(f),n=i||U(t[o.axis])?{base:s,head:s}:this._calculateBarValuePixels(f),p=this._calculateBarIndexPixels(f,l),m=(t._stacks||{})[o.axis],h={horizontal:c,base:n.base,enableBorderRadius:!m||_l(t._custom)||a===m._top||a===m._bottom,x:c?n.head:p.center,y:c?p.center:n.head,height:c?p.size:Math.abs(n.size),width:c?Math.abs(n.size):p.size};d&&(h.options=u||this.resolveDataElementOptions(f,e[f].active?`active`:r));let g=h.options||e[f].options;bl(h,g,m,a),wl(h,g,l.ratio),this.updateElement(e[f],f,h,r)}}_getStacks(e,t){let{iScale:n}=this._cachedMeta,r=n.getMatchingVisibleMetas(this._type).filter(e=>e.controller.options.grouped),i=n.options.stacked,a=[],o=this._cachedMeta.controller.getParsed(t),s=o&&o[n.axis],c=e=>{let t=e._parsed.find(e=>e[n.axis]===s),r=t&&t[e.vScale.axis];if(U(r)||isNaN(r))return!0};for(let n of r)if(!(t!==void 0&&c(n))&&((i===!1||a.indexOf(n.stack)===-1||i===void 0&&n.stack===void 0)&&a.push(n.stack),n.index===e))break;return a.length||a.push(void 0),a}_getStackCount(e){return this._getStacks(void 0,e).length}_getAxisCount(){return this._getAxis().length}getFirstScaleIdForIndexAxis(){let e=this.chart.scales,t=this.chart.options.indexAxis;return Object.keys(e).filter(n=>e[n].axis===t).shift()}_getAxis(){let e={},t=this.getFirstScaleIdForIndexAxis();for(let n of this.chart.data.datasets)e[q(this.chart.options.indexAxis===`x`?n.xAxisID:n.yAxisID,t)]=!0;return Object.keys(e)}_getStackIndex(e,t,n){let r=this._getStacks(e,n),i=t===void 0?-1:r.indexOf(t);return i===-1?r.length-1:i}_getRuler(){let e=this.options,t=this._cachedMeta,n=t.iScale,r=[],i,a;for(i=0,a=t.data.length;i<a;++i)r.push(n.getPixelForValue(this.getParsed(i)[n.axis],i));let o=e.barThickness;return{min:o||dl(t),pixels:r,start:n._startPixel,end:n._endPixel,stackCount:this._getStackCount(),scale:n,grouped:e.grouped,ratio:o?1:e.categoryPercentage*e.barPercentage}}_calculateBarValuePixels(e){let{_cachedMeta:{vScale:t,_stacked:n,index:r},options:{base:i,minBarLength:a}}=this,o=i||0,s=this.getParsed(e),c=s._custom,l=_l(c),u=s[t.axis],d=0,f=n?this.applyStack(t,s,n):u,p,m;f!==u&&(d=f-u,f=u),l&&(u=c.barStart,f=c.barEnd-c.barStart,u!==0&&Co(u)!==Co(c.barEnd)&&(d=0),d+=u);let h=!U(i)&&!l?i:d,g=t.getPixelForValue(h);if(p=this.chart.getDataVisibility(e)?t.getPixelForValue(d+f):g,m=p-g,Math.abs(m)<a){m=vl(m,t,o)*a,u===o&&(g-=m/2);let e=t.getPixelForDecimal(0),i=t.getPixelForDecimal(1);g=Math.max(Math.min(g,Math.max(e,i)),Math.min(e,i)),p=g+m,n&&!l&&(s._stacks[t.axis]._visualValues[r]=t.getValueForPixel(p)-t.getValueForPixel(g))}if(g===t.getPixelForValue(o)){let e=Co(m)*t.getLineWidthForValue(o)/2;g+=e,m-=e}return{size:m,base:g,head:p,center:p+m/2}}_calculateBarIndexPixels(e,t){let n=t.scale,r=this.options,i=r.skipNull,a=q(r.maxBarThickness,1/0),o,s,c=this._getAxisCount();if(t.grouped){let n=i?this._getStackCount(e):t.stackCount,l=r.barThickness===`flex`?pl(e,t,r,n*c):fl(e,t,r,n*c),u=this.chart.options.indexAxis===`x`?this.getDataset().xAxisID:this.getDataset().yAxisID,d=this._getAxis().indexOf(q(u,this.getFirstScaleIdForIndexAxis())),f=this._getStackIndex(this.index,this._cachedMeta.stack,i?e:void 0)+d;o=l.start+l.chunk*f+l.chunk/2,s=Math.min(a,l.chunk*l.ratio)}else o=n.getPixelForValue(this.getParsed(e)[n.axis],e),s=Math.min(a,t.min*t.ratio);return{base:o-s/2,head:o+s/2,center:o,size:s}}draw(){let e=this._cachedMeta,t=e.vScale,n=e.data,r=n.length,i=0;for(;i<r;++i)this.getParsed(i)[t.axis]!==null&&!n[i].hidden&&n[i].draw(this._ctx)}};function El(){throw Error(`This method is not implemented: Check that a complete date adapter is provided.`)}var Dl={_date:class e{static override(t){Object.assign(e.prototype,t)}options;constructor(e){this.options=e||{}}init(){}formats(){return El()}parse(){return El()}format(){return El()}add(){return El()}diff(){return El()}startOf(){return El()}endOf(){return El()}}};function Ol(e,t,n,r){let{controller:i,data:a,_sorted:o}=e,s=i._cachedMeta.iScale,c=e.dataset&&e.dataset.options?e.dataset.options.spanGaps:null;if(s&&t===s.axis&&t!==`r`&&o&&a.length){let o=s._reversePixels?Uo:Ho;if(!r){let r=o(a,t,n);if(c){let{vScale:t}=i._cachedMeta,{_parsed:n}=e,a=n.slice(0,r.lo+1).reverse().findIndex(e=>!U(e[t.axis]));r.lo-=Math.max(0,a);let o=n.slice(r.hi).findIndex(e=>!U(e[t.axis]));r.hi+=Math.max(0,o)}return r}if(i._sharedOptions){let e=a[0],r=typeof e.getRange==`function`&&e.getRange(t);if(r){let e=o(a,t,n-r),i=o(a,t,n+r);return{lo:e.lo,hi:i.hi}}}}return{lo:0,hi:a.length-1}}function kl(e,t,n,r,i){let a=e.getSortedVisibleDatasetMetas(),o=n[t];for(let e=0,n=a.length;e<n;++e){let{index:n,data:s}=a[e],{lo:c,hi:l}=Ol(a[e],t,o,i);for(let e=c;e<=l;++e){let t=s[e];t.skip||r(t,n,e)}}}function Al(e){let t=e.indexOf(`x`)!==-1,n=e.indexOf(`y`)!==-1;return function(e,r){let i=t?Math.abs(e.x-r.x):0,a=n?Math.abs(e.y-r.y):0;return Math.sqrt(i**2+a**2)}}function jl(e,t,n,r,i){let a=[];return!i&&!e.isPointInArea(t)||kl(e,n,t,function(n,o,s){!i&&!As(n,e.chartArea,0)||n.inRange(t.x,t.y,r)&&a.push({element:n,datasetIndex:o,index:s})},!0),a}function Ml(e,t,n,r){let i=[];function a(e,n,a){let{startAngle:o,endAngle:s}=e.getProps([`startAngle`,`endAngle`],r),{angle:c}=Po(e,{x:t.x,y:t.y});Lo(c,o,s)&&i.push({element:e,datasetIndex:n,index:a})}return kl(e,n,t,a),i}function Nl(e,t,n,r,i,a){let o=[],s=Al(n),c=1/0;function l(n,l,u){let d=n.inRange(t.x,t.y,i);if(r&&!d)return;let f=n.getCenterPoint(i);if(!(a||e.isPointInArea(f))&&!d)return;let p=s(t,f);p<c?(o=[{element:n,datasetIndex:l,index:u}],c=p):p===c&&o.push({element:n,datasetIndex:l,index:u})}return kl(e,n,t,l),o}function Pl(e,t,n,r,i,a){return!a&&!e.isPointInArea(t)?[]:n===`r`&&!r?Ml(e,t,n,i):Nl(e,t,n,r,i,a)}function Fl(e,t,n,r,i){let a=[],o=n===`x`?`inXRange`:`inYRange`,s=!1;return kl(e,n,t,(e,r,c)=>{e[o]&&e[o](t[n],i)&&(a.push({element:e,datasetIndex:r,index:c}),s||=e.inRange(t.x,t.y,i))}),r&&!s?[]:a}var Il={evaluateInteractionItems:kl,modes:{index(e,t,n,r){let i=Sc(t,e),a=n.axis||`x`,o=n.includeInvisible||!1,s=n.intersect?jl(e,i,a,r,o):Pl(e,i,a,!1,r,o),c=[];return s.length?(e.getSortedVisibleDatasetMetas().forEach(e=>{let t=s[0].index,n=e.data[t];n&&!n.skip&&c.push({element:n,datasetIndex:e.index,index:t})}),c):[]},dataset(e,t,n,r){let i=Sc(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1,s=n.intersect?jl(e,i,a,r,o):Pl(e,i,a,!1,r,o);if(s.length>0){let t=s[0].datasetIndex,n=e.getDatasetMeta(t).data;s=[];for(let e=0;e<n.length;++e)s.push({element:n[e],datasetIndex:t,index:e})}return s},point(e,t,n,r){return jl(e,Sc(t,e),n.axis||`xy`,r,n.includeInvisible||!1)},nearest(e,t,n,r){let i=Sc(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1;return Pl(e,i,a,n.intersect,r,o)},x(e,t,n,r){return Fl(e,Sc(t,e),`x`,n.intersect,r)},y(e,t,n,r){return Fl(e,Sc(t,e),`y`,n.intersect,r)}}},Ll=[`left`,`top`,`right`,`bottom`];function Rl(e,t){return e.filter(e=>e.pos===t)}function zl(e,t){return e.filter(e=>Ll.indexOf(e.pos)===-1&&e.box.axis===t)}function Bl(e,t){return e.sort((e,n)=>{let r=t?n:e,i=t?e:n;return r.weight===i.weight?r.index-i.index:r.weight-i.weight})}function Vl(e){let t=[],n,r,i,a,o,s;for(n=0,r=(e||[]).length;n<r;++n)i=e[n],{position:a,options:{stack:o,stackWeight:s=1}}=i,t.push({index:n,box:i,pos:a,horizontal:i.isHorizontal(),weight:i.weight,stack:o&&a+o,stackWeight:s});return t}function Hl(e){let t={};for(let n of e){let{stack:e,pos:r,stackWeight:i}=n;if(!e||!Ll.includes(r))continue;let a=t[e]||(t[e]={count:0,placed:0,weight:0,size:0});a.count++,a.weight+=i}return t}function Ul(e,t){let n=Hl(e),{vBoxMaxWidth:r,hBoxMaxHeight:i}=t,a,o,s;for(a=0,o=e.length;a<o;++a){s=e[a];let{fullSize:o}=s.box,c=n[s.stack],l=c&&s.stackWeight/c.weight;s.horizontal?(s.width=l?l*r:o&&t.availableWidth,s.height=i):(s.width=r,s.height=l?l*i:o&&t.availableHeight)}return n}function Wl(e){let t=Vl(e),n=Bl(t.filter(e=>e.box.fullSize),!0),r=Bl(Rl(t,`left`),!0),i=Bl(Rl(t,`right`)),a=Bl(Rl(t,`top`),!0),o=Bl(Rl(t,`bottom`)),s=zl(t,`x`),c=zl(t,`y`);return{fullSize:n,leftAndTop:r.concat(a),rightAndBottom:i.concat(c).concat(o).concat(s),chartArea:Rl(t,`chartArea`),vertical:r.concat(i).concat(c),horizontal:a.concat(o).concat(s)}}function Gl(e,t,n,r){return Math.max(e[n],t[n])+Math.max(e[r],t[r])}function Kl(e,t){e.top=Math.max(e.top,t.top),e.left=Math.max(e.left,t.left),e.bottom=Math.max(e.bottom,t.bottom),e.right=Math.max(e.right,t.right)}function ql(e,t,n,r){let{pos:i,box:a}=n,o=e.maxPadding;if(!G(i)){n.size&&(e[i]-=n.size);let t=r[n.stack]||{size:0,count:1};t.size=Math.max(t.size,n.horizontal?a.height:a.width),n.size=t.size/t.count,e[i]+=n.size}a.getPadding&&Kl(o,a.getPadding());let s=Math.max(0,t.outerWidth-Gl(o,e,`left`,`right`)),c=Math.max(0,t.outerHeight-Gl(o,e,`top`,`bottom`)),l=s!==e.w,u=c!==e.h;return e.w=s,e.h=c,n.horizontal?{same:l,other:u}:{same:u,other:l}}function Jl(e){let t=e.maxPadding;function n(n){let r=Math.max(t[n]-e[n],0);return e[n]+=r,r}e.y+=n(`top`),e.x+=n(`left`),n(`right`),n(`bottom`)}function Yl(e,t){let n=t.maxPadding;function r(e){let r={left:0,top:0,right:0,bottom:0};return e.forEach(e=>{r[e]=Math.max(t[e],n[e])}),r}return r(e?[`left`,`right`]:[`top`,`bottom`])}function Xl(e,t,n,r){let i=[],a,o,s,c,l,u;for(a=0,o=e.length,l=0;a<o;++a){s=e[a],c=s.box,c.update(s.width||t.w,s.height||t.h,Yl(s.horizontal,t));let{same:o,other:d}=ql(t,n,s,r);l|=o&&i.length,u||=d,c.fullSize||i.push(s)}return l&&Xl(i,t,n,r)||u}function Zl(e,t,n,r,i){e.top=n,e.left=t,e.right=t+r,e.bottom=n+i,e.width=r,e.height=i}function Ql(e,t,n,r){let i=n.padding,{x:a,y:o}=t;for(let s of e){let e=s.box,c=r[s.stack]||{count:1,placed:0,weight:1},l=s.stackWeight/c.weight||1;if(s.horizontal){let r=t.w*l,a=c.size||e.height;fo(c.start)&&(o=c.start),e.fullSize?Zl(e,i.left,o,n.outerWidth-i.right-i.left,a):Zl(e,t.left+c.placed,o,r,a),c.start=o,c.placed+=r,o=e.bottom}else{let r=t.h*l,o=c.size||e.width;fo(c.start)&&(a=c.start),e.fullSize?Zl(e,a,i.top,o,n.outerHeight-i.bottom-i.top):Zl(e,a,t.top+c.placed,o,r),c.start=a,c.placed+=r,a=e.right}}t.x=a,t.y=o}var $l={addBox(e,t){e.boxes||=[],t.fullSize=t.fullSize||!1,t.position=t.position||`top`,t.weight=t.weight||0,t._layers=t._layers||function(){return[{z:0,draw(e){t.draw(e)}}]},e.boxes.push(t)},removeBox(e,t){let n=e.boxes?e.boxes.indexOf(t):-1;n!==-1&&e.boxes.splice(n,1)},configure(e,t,n){t.fullSize=n.fullSize,t.position=n.position,t.weight=n.weight},update(e,t,n,r){if(!e)return;let i=Q(e.options.layout.padding),a=Math.max(t-i.width,0),o=Math.max(n-i.height,0),s=Wl(e.boxes),c=s.vertical,l=s.horizontal;Y(e.boxes,e=>{typeof e.beforeLayout==`function`&&e.beforeLayout()});let u=c.reduce((e,t)=>t.box.options&&t.box.options.display===!1?e:e+1,0)||1,d=Object.freeze({outerWidth:t,outerHeight:n,padding:i,availableWidth:a,availableHeight:o,vBoxMaxWidth:a/2/u,hBoxMaxHeight:o/2}),f=Object.assign({},i);Kl(f,Q(r));let p=Object.assign({maxPadding:f,w:a,h:o,x:i.left,y:i.top},i),m=Ul(c.concat(l),d);Xl(s.fullSize,p,d,m),Xl(c,p,d,m),Xl(l,p,d,m)&&Xl(c,p,d,m),Jl(p),Ql(s.leftAndTop,p,d,m),p.x+=p.w,p.y+=p.h,Ql(s.rightAndBottom,p,d,m),e.chartArea={left:p.left,top:p.top,right:p.left+p.w,bottom:p.top+p.h,height:p.h,width:p.w},Y(s.chartArea,t=>{let n=t.box;Object.assign(n,e.chartArea),n.update(p.w,p.h,{left:0,top:0,right:0,bottom:0})})}},eu=class{acquireContext(e,t){}releaseContext(e){return!1}addEventListener(e,t,n){}removeEventListener(e,t,n){}getDevicePixelRatio(){return 1}getMaximumSize(e,t,n,r){return t=Math.max(0,t||e.width),n||=e.height,{width:t,height:Math.max(0,r?Math.floor(t/r):n)}}isAttached(e){return!0}updateConfig(e){}},tu=class extends eu{acquireContext(e){return e&&e.getContext&&e.getContext(`2d`)||null}updateConfig(e){e.options.animation=!1}},nu=`$chartjs`,ru={touchstart:`mousedown`,touchmove:`mousemove`,touchend:`mouseup`,pointerenter:`mouseenter`,pointerdown:`mousedown`,pointermove:`mousemove`,pointerup:`mouseup`,pointerleave:`mouseout`,pointerout:`mouseout`},iu=e=>e===null||e===``;function au(e,t){let n=e.style,r=e.getAttribute(`height`),i=e.getAttribute(`width`);if(e[nu]={initial:{height:r,width:i,style:{display:n.display,height:n.height,width:n.width}}},n.display=n.display||`block`,n.boxSizing=n.boxSizing||`border-box`,iu(i)){let t=Oc(e,`width`);t!==void 0&&(e.width=t)}if(iu(r)){if(e.style.height===``)e.height=e.width/(t||2);else{let t=Oc(e,`height`);t!==void 0&&(e.height=t)}}return e}var ou=Dc?{passive:!0}:!1;function su(e,t,n){e&&e.addEventListener(t,n,ou)}function cu(e,t,n){e&&e.canvas&&e.canvas.removeEventListener(t,n,ou)}function lu(e,t){let n=ru[e.type]||e.type,{x:r,y:i}=Sc(e,t);return{type:n,chart:t,native:e,x:r===void 0?null:r,y:i===void 0?null:i}}function uu(e,t){for(let n of e)if(n===t||n.contains(t))return!0}function du(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=uu(n.addedNodes,r),t&&=!uu(n.removedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}function fu(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=uu(n.removedNodes,r),t&&=!uu(n.addedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}var pu=new Map,mu=0;function hu(){let e=window.devicePixelRatio;e!==mu&&(mu=e,pu.forEach((t,n)=>{n.currentDevicePixelRatio!==e&&t()}))}function gu(e,t){pu.size||window.addEventListener(`resize`,hu),pu.set(e,t)}function _u(e){pu.delete(e),pu.size||window.removeEventListener(`resize`,hu)}function vu(e,t,n){let r=e.canvas,i=r&&mc(r);if(!i)return;let a=Xo((e,t)=>{let r=i.clientWidth;n(e,t),r<i.clientWidth&&n()},window),o=new ResizeObserver(e=>{let t=e[0],n=t.contentRect.width,r=t.contentRect.height;(n!==0||r!==0)&&a(n,r)});return o.observe(i),gu(e,a),o}function yu(e,t,n){n&&n.disconnect(),t===`resize`&&_u(e)}function bu(e,t,n){let r=e.canvas,i=Xo(t=>{e.ctx!==null&&n(lu(t,e))},e);return su(r,t,i),i}var xu=class extends eu{acquireContext(e,t){let n=e&&e.getContext&&e.getContext(`2d`);return n&&n.canvas===e?(au(e,t),n):null}releaseContext(e){let t=e.canvas;if(!t[nu])return!1;let n=t[nu].initial;[`height`,`width`].forEach(e=>{let r=n[e];U(r)?t.removeAttribute(e):t.setAttribute(e,r)});let r=n.style||{};return Object.keys(r).forEach(e=>{t.style[e]=r[e]}),t.width=t.width,delete t[nu],!0}addEventListener(e,t,n){this.removeEventListener(e,t);let r=e.$proxies||={};r[t]=({attach:du,detach:fu,resize:vu}[t]||bu)(e,t,n)}removeEventListener(e,t){let n=e.$proxies||={},r=n[t];r&&(({attach:yu,detach:yu,resize:yu}[t]||cu)(e,t,r),n[t]=void 0)}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(e,t,n,r){return Tc(e,t,n,r)}isAttached(e){let t=e&&mc(e);return!!(t&&t.isConnected)}};function Su(e){return!pc()||typeof OffscreenCanvas<`u`&&e instanceof OffscreenCanvas?tu:xu}var Cu=class{static defaults={};static defaultRoutes=void 0;x;y;active=!1;options;$animations;tooltipPosition(e){let{x:t,y:n}=this.getProps([`x`,`y`],e);return{x:t,y:n}}hasValue(){return Oo(this.x)&&Oo(this.y)}getProps(e,t){let n=this.$animations;if(!t||!n)return this;let r={};return e.forEach(e=>{r[e]=n[e]&&n[e].active()?n[e]._to:this[e]}),r}};function wu(e,t){let n=e.options.ticks,r=Tu(e),i=Math.min(n.maxTicksLimit||r,r),a=n.major.enabled?Du(t):[],o=a.length,s=a[0],c=a[o-1],l=[];if(o>i)return Ou(t,l,a,o/i),l;let u=Eu(a,t,i);if(o>0){let e,n,r=o>1?Math.round((c-s)/(o-1)):null;for(ku(t,l,u,U(r)?0:s-r,s),e=0,n=o-1;e<n;e++)ku(t,l,u,a[e],a[e+1]);return ku(t,l,u,c,U(r)?t.length:c+r),l}return ku(t,l,u),l}function Tu(e){let t=e.options.offset,n=e._tickSize(),r=e._length/n+ +!t,i=e._maxLength/n;return Math.floor(Math.min(r,i))}function Eu(e,t,n){let r=Au(e),i=t.length/n;if(!r)return Math.max(i,1);let a=Eo(r);for(let e=0,t=a.length-1;e<t;e++){let t=a[e];if(t>i)return t}return Math.max(i,1)}function Du(e){let t=[],n,r;for(n=0,r=e.length;n<r;n++)e[n].major&&t.push(n);return t}function Ou(e,t,n,r){let i=0,a=n[0],o;for(r=Math.ceil(r),o=0;o<e.length;o++)o===a&&(t.push(e[o]),i++,a=n[i*r])}function ku(e,t,n,r,i){let a=q(r,0),o=Math.min(q(i,e.length),e.length),s=0,c,l,u;for(n=Math.ceil(n),i&&(c=i-r,n=c/Math.floor(c/n)),u=a;u<0;)s++,u=Math.round(a+s*n);for(l=Math.max(a,0);l<o;l++)l===u&&(t.push(e[l]),s++,u=Math.round(a+s*n))}function Au(e){let t=e.length,n,r;if(t<2)return!1;for(r=e[0],n=1;n<t;++n)if(e[n]-e[n-1]!==r)return!1;return r}var ju=e=>e===`left`?`right`:e===`right`?`left`:e,Mu=(e,t,n)=>t===`top`||t===`left`?e[t]+n:e[t]-n,Nu=(e,t)=>Math.min(t||e,e);function Pu(e,t){let n=[],r=e.length/t,i=e.length,a=0;for(;a<i;a+=r)n.push(e[Math.floor(a)]);return n}function Fu(e,t,n){let r=e.ticks.length,i=Math.min(t,r-1),a=e._startPixel,o=e._endPixel,s=1e-6,c=e.getPixelForTick(i),l;if(!(n&&(l=r===1?Math.max(c-a,o-c):t===0?(e.getPixelForTick(1)-c)/2:(c-e.getPixelForTick(i-1))/2,c+=i<t?l:-l,c<a-s||c>o+s)))return c}function Iu(e,t){Y(e,e=>{let n=e.gc,r=n.length/2,i;if(r>t){for(i=0;i<r;++i)delete e.data[n[i]];n.splice(0,r)}})}function Lu(e){return e.drawTicks?e.tickLength:0}function Ru(e,t){if(!e.display)return 0;let n=$(e.font,t),r=Q(e.padding);return(W(e.text)?e.text.length:1)*n.lineHeight+r.height}function zu(e,t){return qs(e,{scale:t,type:`scale`})}function Bu(e,t,n){return qs(e,{tick:n,index:t,type:`tick`})}function Vu(e,t,n){let r=Qo(e);return(n&&t!==`right`||!n&&t===`right`)&&(r=ju(r)),r}function Hu(e,t,n,r){let{top:i,left:a,bottom:o,right:s,chart:c}=e,{chartArea:l,scales:u}=c,d=0,f,p,m,h=o-i,g=s-a;if(e.isHorizontal()){if(p=$o(r,a,s),G(n)){let e=Object.keys(n)[0],r=n[e];m=u[e].getPixelForValue(r)+h-t}else m=n===`center`?(l.bottom+l.top)/2+h-t:Mu(e,n,t);f=s-a}else{if(G(n)){let e=Object.keys(n)[0],r=n[e];p=u[e].getPixelForValue(r)-g+t}else p=n===`center`?(l.left+l.right)/2-g+t:Mu(e,n,t);m=$o(r,o,i),d=n===`left`?-yo:yo}return{titleX:p,titleY:m,maxWidth:f,rotation:d}}var Uu=class e extends Cu{constructor(e){super(),this.id=e.id,this.type=e.type,this.options=void 0,this.ctx=e.ctx,this.chart=e.chart,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this._margins={left:0,right:0,top:0,bottom:0},this.maxWidth=void 0,this.maxHeight=void 0,this.paddingTop=void 0,this.paddingBottom=void 0,this.paddingLeft=void 0,this.paddingRight=void 0,this.axis=void 0,this.labelRotation=void 0,this.min=void 0,this.max=void 0,this._range=void 0,this.ticks=[],this._gridLineItems=null,this._labelItems=null,this._labelSizes=null,this._length=0,this._maxLength=0,this._longestTextCache={},this._startPixel=void 0,this._endPixel=void 0,this._reversePixels=!1,this._userMax=void 0,this._userMin=void 0,this._suggestedMax=void 0,this._suggestedMin=void 0,this._ticksLength=0,this._borderValue=0,this._cache={},this._dataLimitsCached=!1,this.$context=void 0}init(e){this.options=e.setContext(this.getContext()),this.axis=e.axis,this._userMin=this.parse(e.min),this._userMax=this.parse(e.max),this._suggestedMin=this.parse(e.suggestedMin),this._suggestedMax=this.parse(e.suggestedMax)}parse(e,t){return e}getUserBounds(){let{_userMin:e,_userMax:t,_suggestedMin:n,_suggestedMax:r}=this;return e=Za(e,1/0),t=Za(t,-1/0),n=Za(n,1/0),r=Za(r,-1/0),{min:Za(e,n),max:Za(t,r),minDefined:K(e),maxDefined:K(t)}}getMinMax(e){let{min:t,max:n,minDefined:r,maxDefined:i}=this.getUserBounds(),a;if(r&&i)return{min:t,max:n};let o=this.getMatchingVisibleMetas();for(let s=0,c=o.length;s<c;++s)a=o[s].controller.getMinMax(this,e),r||(t=Math.min(t,a.min)),i||(n=Math.max(n,a.max));return t=i&&t>n?n:t,n=r&&t>n?t:n,{min:Za(t,Za(n,t)),max:Za(n,Za(t,n))}}getPadding(){return{left:this.paddingLeft||0,top:this.paddingTop||0,right:this.paddingRight||0,bottom:this.paddingBottom||0}}getTicks(){return this.ticks}getLabels(){let e=this.chart.data;return this.options.labels||(this.isHorizontal()?e.xLabels:e.yLabels)||e.labels||[]}getLabelItems(e=this.chart.chartArea){return this._labelItems||=this._computeLabelItems(e)}beforeLayout(){this._cache={},this._dataLimitsCached=!1}beforeUpdate(){J(this.options.beforeUpdate,[this])}update(e,t,n){let{beginAtZero:r,grace:i,ticks:a}=this.options,o=a.sampleSize;this.beforeUpdate(),this.maxWidth=e,this.maxHeight=t,this._margins=n=Object.assign({left:0,right:0,top:0,bottom:0},n),this.ticks=null,this._labelSizes=null,this._gridLineItems=null,this._labelItems=null,this.beforeSetDimensions(),this.setDimensions(),this.afterSetDimensions(),this._maxLength=this.isHorizontal()?this.width+n.left+n.right:this.height+n.top+n.bottom,this._dataLimitsCached||=(this.beforeDataLimits(),this.determineDataLimits(),this.afterDataLimits(),this._range=Ks(this,i,r),!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();let s=o<this.ticks.length;this._convertTicksToLabels(s?Pu(this.ticks,o):this.ticks),this.configure(),this.beforeCalculateLabelRotation(),this.calculateLabelRotation(),this.afterCalculateLabelRotation(),a.display&&(a.autoSkip||a.source===`auto`)&&(this.ticks=wu(this,this.ticks),this._labelSizes=null,this.afterAutoSkip()),s&&this._convertTicksToLabels(this.ticks),this.beforeFit(),this.fit(),this.afterFit(),this.afterUpdate()}configure(){let e=this.options.reverse,t,n;this.isHorizontal()?(t=this.left,n=this.right):(t=this.top,n=this.bottom,e=!e),this._startPixel=t,this._endPixel=n,this._reversePixels=e,this._length=n-t,this._alignToPixels=this.options.alignToPixels}afterUpdate(){J(this.options.afterUpdate,[this])}beforeSetDimensions(){J(this.options.beforeSetDimensions,[this])}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=0,this.right=this.width):(this.height=this.maxHeight,this.top=0,this.bottom=this.height),this.paddingLeft=0,this.paddingTop=0,this.paddingRight=0,this.paddingBottom=0}afterSetDimensions(){J(this.options.afterSetDimensions,[this])}_callHooks(e){this.chart.notifyPlugins(e,this.getContext()),J(this.options[e],[this])}beforeDataLimits(){this._callHooks(`beforeDataLimits`)}determineDataLimits(){}afterDataLimits(){this._callHooks(`afterDataLimits`)}beforeBuildTicks(){this._callHooks(`beforeBuildTicks`)}buildTicks(){return[]}afterBuildTicks(){this._callHooks(`afterBuildTicks`)}beforeTickToLabelConversion(){J(this.options.beforeTickToLabelConversion,[this])}generateTickLabels(e){let t=this.options.ticks,n,r,i;for(n=0,r=e.length;n<r;n++)i=e[n],i.label=J(t.callback,[i.value,n,e],this)}afterTickToLabelConversion(){J(this.options.afterTickToLabelConversion,[this])}beforeCalculateLabelRotation(){J(this.options.beforeCalculateLabelRotation,[this])}calculateLabelRotation(){let e=this.options,t=e.ticks,n=Nu(this.ticks.length,e.ticks.maxTicksLimit),r=t.minRotation||0,i=t.maxRotation,a=r,o,s,c;if(!this._isVisible()||!t.display||r>=i||n<=1||!this.isHorizontal()){this.labelRotation=r;return}let l=this._getLabelSizes(),u=l.widest.width,d=l.highest.height,f=Ro(this.chart.width-u,0,this.maxWidth);o=e.offset?this.maxWidth/n:f/(n-1),u+6>o&&(o=f/(n-(e.offset?.5:1)),s=this.maxHeight-Lu(e.grid)-t.padding-Ru(e.title,this.chart.options.font),c=Math.sqrt(u*u+d*d),a=Mo(Math.min(Math.asin(Ro((l.highest.height+6)/o,-1,1)),Math.asin(Ro(s/c,-1,1))-Math.asin(Ro(d/c,-1,1)))),a=Math.max(r,Math.min(i,a))),this.labelRotation=a}afterCalculateLabelRotation(){J(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){J(this.options.beforeFit,[this])}fit(){let e={width:0,height:0},{chart:t,options:{ticks:n,title:r,grid:i}}=this,a=this._isVisible(),o=this.isHorizontal();if(a){let a=Ru(r,t.options.font);if(o?(e.width=this.maxWidth,e.height=Lu(i)+a):(e.height=this.maxHeight,e.width=Lu(i)+a),n.display&&this.ticks.length){let{first:t,last:r,widest:i,highest:a}=this._getLabelSizes(),s=n.padding*2,c=jo(this.labelRotation),l=Math.cos(c),u=Math.sin(c);if(o){let t=n.mirror?0:u*i.width+l*a.height;e.height=Math.min(this.maxHeight,e.height+t+s)}else{let t=n.mirror?0:l*i.width+u*a.height;e.width=Math.min(this.maxWidth,e.width+t+s)}this._calculatePadding(t,r,u,l)}}this._handleMargins(),o?(this.width=this._length=t.width-this._margins.left-this._margins.right,this.height=e.height):(this.width=e.width,this.height=this._length=t.height-this._margins.top-this._margins.bottom)}_calculatePadding(e,t,n,r){let{ticks:{align:i,padding:a},position:o}=this.options,s=this.labelRotation!==0,c=o!==`top`&&this.axis===`x`;if(this.isHorizontal()){let o=this.getPixelForTick(0)-this.left,l=this.right-this.getPixelForTick(this.ticks.length-1),u=0,d=0;s?c?(u=r*e.width,d=n*t.height):(u=n*e.height,d=r*t.width):i===`start`?d=t.width:i===`end`?u=e.width:i!==`inner`&&(u=e.width/2,d=t.width/2),this.paddingLeft=Math.max((u-o+a)*this.width/(this.width-o),0),this.paddingRight=Math.max((d-l+a)*this.width/(this.width-l),0)}else{let n=t.height/2,r=e.height/2;i===`start`?(n=0,r=e.height):i===`end`&&(n=t.height,r=0),this.paddingTop=n+a,this.paddingBottom=r+a}}_handleMargins(){this._margins&&(this._margins.left=Math.max(this.paddingLeft,this._margins.left),this._margins.top=Math.max(this.paddingTop,this._margins.top),this._margins.right=Math.max(this.paddingRight,this._margins.right),this._margins.bottom=Math.max(this.paddingBottom,this._margins.bottom))}afterFit(){J(this.options.afterFit,[this])}isHorizontal(){let{axis:e,position:t}=this.options;return t===`top`||t===`bottom`||e===`x`}isFullSize(){return this.options.fullSize}_convertTicksToLabels(e){this.beforeTickToLabelConversion(),this.generateTickLabels(e);let t,n;for(t=0,n=e.length;t<n;t++)U(e[t].label)&&(e.splice(t,1),n--,t--);this.afterTickToLabelConversion()}_getLabelSizes(){let e=this._labelSizes;if(!e){let t=this.options.ticks.sampleSize,n=this.ticks;t<n.length&&(n=Pu(n,t)),this._labelSizes=e=this._computeLabelSizes(n,n.length,this.options.ticks.maxTicksLimit)}return e}_computeLabelSizes(e,t,n){let{ctx:r,_longestTextCache:i}=this,a=[],o=[],s=Math.floor(t/Nu(t,n)),c=0,l=0,u,d,f,p,m,h,g,_,v,y,b;for(u=0;u<t;u+=s){if(p=e[u].label,m=this._resolveTickFontOptions(u),r.font=h=m.string,g=i[h]=i[h]||{data:{},gc:[]},_=m.lineHeight,v=y=0,!U(p)&&!W(p))v=ws(r,g.data,g.gc,v,p),y=_;else if(W(p))for(d=0,f=p.length;d<f;++d)b=p[d],!U(b)&&!W(b)&&(v=ws(r,g.data,g.gc,v,b),y+=_);a.push(v),o.push(y),c=Math.max(v,c),l=Math.max(y,l)}Iu(i,t);let x=a.indexOf(c),S=o.indexOf(l),C=e=>({width:a[e]||0,height:o[e]||0});return{first:C(0),last:C(t-1),widest:C(x),highest:C(S),widths:a,heights:o}}getLabelForValue(e){return e}getPixelForValue(e,t){return NaN}getValueForPixel(e){}getPixelForTick(e){let t=this.ticks;return e<0||e>t.length-1?null:this.getPixelForValue(t[e].value)}getPixelForDecimal(e){this._reversePixels&&(e=1-e);let t=this._startPixel+e*this._length;return zo(this._alignToPixels?Es(this.chart,t,0):t)}getDecimalForPixel(e){let t=(e-this._startPixel)/this._length;return this._reversePixels?1-t:t}getBasePixel(){return this.getPixelForValue(this.getBaseValue())}getBaseValue(){let{min:e,max:t}=this;return e<0&&t<0?t:e>0&&t>0?e:0}getContext(e){let t=this.ticks||[];if(e>=0&&e<t.length){let n=t[e];return n.$context||=Bu(this.getContext(),e,n)}return this.$context||=zu(this.chart.getContext(),this)}_tickSize(){let e=this.options.ticks,t=jo(this.labelRotation),n=Math.abs(Math.cos(t)),r=Math.abs(Math.sin(t)),i=this._getLabelSizes(),a=e.autoSkipPadding||0,o=i?i.widest.width+a:0,s=i?i.highest.height+a:0;return this.isHorizontal()?s*n>o*r?o/n:s/r:s*r<o*n?s/n:o/r}_isVisible(){let e=this.options.display;return e===`auto`?this.getMatchingVisibleMetas().length>0:!!e}_computeGridLineItems(e){let t=this.axis,n=this.chart,r=this.options,{grid:i,position:a,border:o}=r,s=i.offset,c=this.isHorizontal(),l=this.ticks.length+ +!!s,u=Lu(i),d=[],f=o.setContext(this.getContext()),p=f.display?f.width:0,m=p/2,h=function(e){return Es(n,e,p)},g,_,v,y,b,x,S,C,w,T,E,D;if(a===`top`)g=h(this.bottom),x=this.bottom-u,C=g-m,T=h(e.top)+m,D=e.bottom;else if(a===`bottom`)g=h(this.top),T=e.top,D=h(e.bottom)-m,x=g+m,C=this.top+u;else if(a===`left`)g=h(this.right),b=this.right-u,S=g-m,w=h(e.left)+m,E=e.right;else if(a===`right`)g=h(this.left),w=e.left,E=h(e.right)-m,b=g+m,S=this.left+u;else if(t===`x`){if(a===`center`)g=h((e.top+e.bottom)/2+.5);else if(G(a)){let e=Object.keys(a)[0],t=a[e];g=h(this.chart.scales[e].getPixelForValue(t))}T=e.top,D=e.bottom,x=g+m,C=x+u}else if(t===`y`){if(a===`center`)g=h((e.left+e.right)/2);else if(G(a)){let e=Object.keys(a)[0],t=a[e];g=h(this.chart.scales[e].getPixelForValue(t))}b=g-m,S=b-u,w=e.left,E=e.right}let O=q(r.ticks.maxTicksLimit,l),k=Math.max(1,Math.ceil(l/O));for(_=0;_<l;_+=k){let e=this.getContext(_),t=i.setContext(e),r=o.setContext(e),a=t.lineWidth,l=t.color,u=r.dash||[],f=r.dashOffset,p=t.tickWidth,m=t.tickColor,h=t.tickBorderDash||[],g=t.tickBorderDashOffset;v=Fu(this,_,s),v!==void 0&&(y=Es(n,v,a),c?b=S=w=E=y:x=C=T=D=y,d.push({tx1:b,ty1:x,tx2:S,ty2:C,x1:w,y1:T,x2:E,y2:D,width:a,color:l,borderDash:u,borderDashOffset:f,tickWidth:p,tickColor:m,tickBorderDash:h,tickBorderDashOffset:g}))}return this._ticksLength=l,this._borderValue=g,d}_computeLabelItems(e){let t=this.axis,n=this.options,{position:r,ticks:i}=n,a=this.isHorizontal(),o=this.ticks,{align:s,crossAlign:c,padding:l,mirror:u}=i,d=Lu(n.grid),f=d+l,p=u?-l:f,m=-jo(this.labelRotation),h=[],g,_,v,y,b,x,S,C,w,T,E,D,O=`middle`;if(r===`top`)x=this.bottom-p,S=this._getXAxisLabelAlignment();else if(r===`bottom`)x=this.top+p,S=this._getXAxisLabelAlignment();else if(r===`left`){let e=this._getYAxisLabelAlignment(d);S=e.textAlign,b=e.x}else if(r===`right`){let e=this._getYAxisLabelAlignment(d);S=e.textAlign,b=e.x}else if(t===`x`){if(r===`center`)x=(e.top+e.bottom)/2+f;else if(G(r)){let e=Object.keys(r)[0],t=r[e];x=this.chart.scales[e].getPixelForValue(t)+f}S=this._getXAxisLabelAlignment()}else if(t===`y`){if(r===`center`)b=(e.left+e.right)/2-f;else if(G(r)){let e=Object.keys(r)[0],t=r[e];b=this.chart.scales[e].getPixelForValue(t)}S=this._getYAxisLabelAlignment(d).textAlign}t===`y`&&(s===`start`?O=`top`:s===`end`&&(O=`bottom`));let k=this._getLabelSizes();for(g=0,_=o.length;g<_;++g){v=o[g],y=v.label;let e=i.setContext(this.getContext(g));C=this.getPixelForTick(g)+i.labelOffset,w=this._resolveTickFontOptions(g),T=w.lineHeight,E=W(y)?y.length:1;let t=E/2,n=e.color,s=e.textStrokeColor,l=e.textStrokeWidth,d=S;a?(b=C,S===`inner`&&(d=g===_-1?this.options.reverse?`left`:`right`:g===0?this.options.reverse?`right`:`left`:`center`),D=r===`top`?c===`near`||m!==0?-E*T+T/2:c===`center`?-k.highest.height/2-t*T+T:-k.highest.height+T/2:c===`near`||m!==0?T/2:c===`center`?k.highest.height/2-t*T:k.highest.height-E*T,u&&(D*=-1),m!==0&&!e.showLabelBackdrop&&(b+=T/2*Math.sin(m))):(x=C,D=(1-E)*T/2);let f;if(e.showLabelBackdrop){let t=Q(e.backdropPadding),n=k.heights[g],r=k.widths[g],i=D-t.top,a=0-t.left;switch(O){case`middle`:i-=n/2;break;case`bottom`:i-=n}switch(S){case`center`:a-=r/2;break;case`right`:a-=r;break;case`inner`:g===_-1?a-=r:g>0&&(a-=r/2)}f={left:a,top:i,width:r+t.width,height:n+t.height,color:e.backdropColor}}h.push({label:y,font:w,textOffset:D,options:{rotation:m,color:n,strokeColor:s,strokeWidth:l,textAlign:d,textBaseline:O,translation:[b,x],backdrop:f}})}return h}_getXAxisLabelAlignment(){let{position:e,ticks:t}=this.options;if(-jo(this.labelRotation))return e===`top`?`left`:`right`;let n=`center`;return t.align===`start`?n=`left`:t.align===`end`?n=`right`:t.align===`inner`&&(n=`inner`),n}_getYAxisLabelAlignment(e){let{position:t,ticks:{crossAlign:n,mirror:r,padding:i}}=this.options,a=this._getLabelSizes(),o=e+i,s=a.widest.width,c,l;return t===`left`?r?(l=this.right+i,n===`near`?c=`left`:n===`center`?(c=`center`,l+=s/2):(c=`right`,l+=s)):(l=this.right-o,n===`near`?c=`right`:n===`center`?(c=`center`,l-=s/2):(c=`left`,l=this.left)):t===`right`?r?(l=this.left+i,n===`near`?c=`right`:n===`center`?(c=`center`,l-=s/2):(c=`left`,l-=s)):(l=this.left+o,n===`near`?c=`left`:n===`center`?(c=`center`,l+=s/2):(c=`right`,l=this.right)):c=`right`,{textAlign:c,x:l}}_computeLabelArea(){if(this.options.ticks.mirror)return;let e=this.chart,t=this.options.position;if(t===`left`||t===`right`)return{top:0,left:this.left,bottom:e.height,right:this.right};if(t===`top`||t===`bottom`)return{top:this.top,left:0,bottom:this.bottom,right:e.width}}drawBackground(){let{ctx:e,options:{backgroundColor:t},left:n,top:r,width:i,height:a}=this;t&&(e.save(),e.fillStyle=t,e.fillRect(n,r,i,a),e.restore())}getLineWidthForValue(e){let t=this.options.grid;if(!this._isVisible()||!t.display)return 0;let n=this.ticks.findIndex(t=>t.value===e);return n>=0?t.setContext(this.getContext(n)).lineWidth:0}drawGrid(e){let t=this.options.grid,n=this.ctx,r=this._gridLineItems||=this._computeGridLineItems(e),i,a,o=(e,t,r)=>{!r.width||!r.color||(n.save(),n.lineWidth=r.width,n.strokeStyle=r.color,n.setLineDash(r.borderDash||[]),n.lineDashOffset=r.borderDashOffset,n.beginPath(),n.moveTo(e.x,e.y),n.lineTo(t.x,t.y),n.stroke(),n.restore())};if(t.display)for(i=0,a=r.length;i<a;++i){let e=r[i];t.drawOnChartArea&&o({x:e.x1,y:e.y1},{x:e.x2,y:e.y2},e),t.drawTicks&&o({x:e.tx1,y:e.ty1},{x:e.tx2,y:e.ty2},{color:e.tickColor,width:e.tickWidth,borderDash:e.tickBorderDash,borderDashOffset:e.tickBorderDashOffset})}}drawBorder(){let{chart:e,ctx:t,options:{border:n,grid:r}}=this,i=n.setContext(this.getContext()),a=n.display?i.width:0;if(!a)return;let o=r.setContext(this.getContext(0)).lineWidth,s=this._borderValue,c,l,u,d;this.isHorizontal()?(c=Es(e,this.left,a)-a/2,l=Es(e,this.right,o)+o/2,u=d=s):(u=Es(e,this.top,a)-a/2,d=Es(e,this.bottom,o)+o/2,c=l=s),t.save(),t.lineWidth=i.width,t.strokeStyle=i.color,t.beginPath(),t.moveTo(c,u),t.lineTo(l,d),t.stroke(),t.restore()}drawLabels(e){if(!this.options.ticks.display)return;let t=this.ctx,n=this._computeLabelArea();n&&js(t,n);let r=this.getLabelItems(e);for(let e of r){let n=e.options,r=e.font,i=e.label,a=e.textOffset;Is(t,i,0,a,r,n)}n&&Ms(t)}drawTitle(){let{ctx:e,options:{position:t,title:n,reverse:r}}=this;if(!n.display)return;let i=$(n.font),a=Q(n.padding),o=n.align,s=i.lineHeight/2;t===`bottom`||t===`center`||G(t)?(s+=a.bottom,W(n.text)&&(s+=i.lineHeight*(n.text.length-1))):s+=a.top;let{titleX:c,titleY:l,maxWidth:u,rotation:d}=Hu(this,s,t,o);Is(e,n.text,0,0,i,{color:n.color,maxWidth:u,rotation:d,textAlign:Vu(o,t,r),textBaseline:`middle`,translation:[c,l]})}draw(e){this._isVisible()&&(this.drawBackground(),this.drawGrid(e),this.drawBorder(),this.drawTitle(),this.drawLabels(e))}_layers(){let t=this.options,n=t.ticks&&t.ticks.z||0,r=q(t.grid&&t.grid.z,-1),i=q(t.border&&t.border.z,0);return!this._isVisible()||this.draw!==e.prototype.draw?[{z:n,draw:e=>{this.draw(e)}}]:[{z:r,draw:e=>{this.drawBackground(),this.drawGrid(e),this.drawTitle()}},{z:i,draw:()=>{this.drawBorder()}},{z:n,draw:e=>{this.drawLabels(e)}}]}getMatchingVisibleMetas(e){let t=this.chart.getSortedVisibleDatasetMetas(),n=this.axis+`AxisID`,r=[],i,a;for(i=0,a=t.length;i<a;++i){let a=t[i];a[n]===this.id&&(!e||a.type===e)&&r.push(a)}return r}_resolveTickFontOptions(e){return $(this.options.ticks.setContext(this.getContext(e)).font)}_maxDigits(){let e=this._resolveTickFontOptions(0).lineHeight;return(this.isHorizontal()?this.width:this.height)/e}},Wu=class{constructor(e,t,n){this.type=e,this.scope=t,this.override=n,this.items=Object.create(null)}isForType(e){return Object.prototype.isPrototypeOf.call(this.type.prototype,e.prototype)}register(e){let t=Object.getPrototypeOf(e),n;qu(t)&&(n=this.register(t));let r=this.items,i=e.id,a=this.scope+`.`+i;if(!i)throw Error(`class does not have id: `+e);return i in r?a:(r[i]=e,Gu(e,a,n),this.override&&Z.override(e.id,e.overrides),a)}get(e){return this.items[e]}unregister(e){let t=this.items,n=e.id,r=this.scope;n in t&&delete t[n],r&&n in Z[r]&&(delete Z[r][n],this.override&&delete ys[n])}};function Gu(e,t,n){let r=ro(Object.create(null),[n?Z.get(n):{},Z.get(t),e.defaults]);Z.set(t,r),e.defaultRoutes&&Ku(t,e.defaultRoutes),e.descriptors&&Z.describe(t,e.descriptors)}function Ku(e,t){Object.keys(t).forEach(n=>{let r=n.split(`.`),i=r.pop(),a=[e].concat(r).join(`.`),o=t[n].split(`.`),s=o.pop(),c=o.join(`.`);Z.route(a,i,c,s)})}function qu(e){return`id`in e&&`defaults`in e}var Ju=new class{constructor(){this.controllers=new Wu(ll,`datasets`,!0),this.elements=new Wu(Cu,`elements`),this.plugins=new Wu(Object,`plugins`),this.scales=new Wu(Uu,`scales`),this._typedRegistries=[this.controllers,this.scales,this.elements]}add(...e){this._each(`register`,e)}remove(...e){this._each(`unregister`,e)}addControllers(...e){this._each(`register`,e,this.controllers)}addElements(...e){this._each(`register`,e,this.elements)}addPlugins(...e){this._each(`register`,e,this.plugins)}addScales(...e){this._each(`register`,e,this.scales)}getController(e){return this._get(e,this.controllers,`controller`)}getElement(e){return this._get(e,this.elements,`element`)}getPlugin(e){return this._get(e,this.plugins,`plugin`)}getScale(e){return this._get(e,this.scales,`scale`)}removeControllers(...e){this._each(`unregister`,e,this.controllers)}removeElements(...e){this._each(`unregister`,e,this.elements)}removePlugins(...e){this._each(`unregister`,e,this.plugins)}removeScales(...e){this._each(`unregister`,e,this.scales)}_each(e,t,n){[...t].forEach(t=>{let r=n||this._getRegistryForType(t);n||r.isForType(t)||r===this.plugins&&t.id?this._exec(e,r,t):Y(t,t=>{let r=n||this._getRegistryForType(t);this._exec(e,r,t)})})}_exec(e,t,n){let r=uo(e);J(n[`before`+r],[],n),t[e](n),J(n[`after`+r],[],n)}_getRegistryForType(e){for(let t=0;t<this._typedRegistries.length;t++){let n=this._typedRegistries[t];if(n.isForType(e))return n}return this.plugins}_get(e,t,n){let r=t.get(e);if(r===void 0)throw Error(`"`+e+`" is not a registered `+n+`.`);return r}},Yu=class{constructor(){this._init=void 0}notify(e,t,n,r){if(t===`beforeInit`&&(this._init=this._createDescriptors(e,!0),this._notify(this._init,e,`install`)),this._init===void 0)return;let i=r?this._descriptors(e).filter(r):this._descriptors(e),a=this._notify(i,e,t,n);return t===`afterDestroy`&&(this._notify(i,e,`stop`),this._notify(this._init,e,`uninstall`),this._init=void 0),a}_notify(e,t,n,r){r||={};for(let i of e){let e=i.plugin,a=e[n];if(J(a,[t,r,i.options],e)===!1&&r.cancelable)return!1}return!0}invalidate(){U(this._cache)||(this._oldCache=this._cache,this._cache=void 0)}_descriptors(e){if(this._cache)return this._cache;let t=this._cache=this._createDescriptors(e);return this._notifyStateChanges(e),t}_createDescriptors(e,t){let n=e&&e.config,r=q(n.options&&n.options.plugins,{}),i=Xu(n);return r===!1&&!t?[]:Qu(e,i,r,t)}_notifyStateChanges(e){let t=this._oldCache||[],n=this._cache,r=(e,t)=>e.filter(e=>!t.some(t=>e.plugin.id===t.plugin.id));this._notify(r(t,n),e,`stop`),this._notify(r(n,t),e,`start`)}};function Xu(e){let t={},n=[],r=Object.keys(Ju.plugins.items);for(let e=0;e<r.length;e++)n.push(Ju.getPlugin(r[e]));let i=e.plugins||[];for(let e=0;e<i.length;e++){let r=i[e];n.indexOf(r)===-1&&(n.push(r),t[r.id]=!0)}return{plugins:n,localIds:t}}function Zu(e,t){return!t&&e===!1?null:e===!0?{}:e}function Qu(e,{plugins:t,localIds:n},r,i){let a=[],o=e.getContext();for(let s of t){let t=s.id,c=Zu(r[t],i);c!==null&&a.push({plugin:s,options:$u(e.config,{plugin:s,local:n[t]},c,o)})}return a}function $u(e,{plugin:t,local:n},r,i){let a=e.pluginScopeKeys(t),o=e.getOptionScopes(r,a);return n&&t.defaults&&o.push(t.defaults),e.createResolver(o,i,[``],{scriptable:!1,indexable:!1,allKeys:!0})}function ed(e,t){let n=Z.datasets[e]||{};return((t.datasets||{})[e]||{}).indexAxis||t.indexAxis||n.indexAxis||`x`}function td(e,t){let n=e;return e===`_index_`?n=t:e===`_value_`&&(n=t===`x`?`y`:`x`),n}function nd(e,t){return e===t?`_index_`:`_value_`}function rd(e){if(e===`x`||e===`y`||e===`r`)return e}function id(e){if(e===`top`||e===`bottom`)return`x`;if(e===`left`||e===`right`)return`y`}function ad(e,...t){if(rd(e))return e;for(let n of t){let t=n.axis||id(n.position)||e.length>1&&rd(e[0].toLowerCase());if(t)return t}throw Error(`Cannot determine type of '${e}' axis. Please provide 'axis' or 'position' option.`)}function od(e,t,n){if(n[t+`AxisID`]===e)return{axis:t}}function sd(e,t){if(t.data&&t.data.datasets){let n=t.data.datasets.filter(t=>t.xAxisID===e||t.yAxisID===e);if(n.length)return od(e,`x`,n[0])||od(e,`y`,n[0])}return{}}function cd(e,t){let n=ys[e.type]||{scales:{}},r=t.scales||{},i=ed(e.type,t),a=Object.create(null);return Object.keys(r).forEach(t=>{let o=r[t];if(!G(o))return console.error(`Invalid scale configuration for scale: ${t}`);if(o._proxy)return console.warn(`Ignoring resolver passed as options for scale: ${t}`);let s=ad(t,o,sd(t,e),Z.scales[o.type]),c=nd(s,i),l=n.scales||{};a[t]=io(Object.create(null),[{axis:s},o,l[s],l[c]])}),e.data.datasets.forEach(n=>{let i=n.type||e.type,o=n.indexAxis||ed(i,t),s=(ys[i]||{}).scales||{};Object.keys(s).forEach(e=>{let t=td(e,o),i=n[t+`AxisID`]||t;a[i]=a[i]||Object.create(null),io(a[i],[{axis:t},r[i],s[e]])})}),Object.keys(a).forEach(e=>{let t=a[e];io(t,[Z.scales[t.type],Z.scale])}),a}function ld(e){let t=e.options||={};t.plugins=q(t.plugins,{}),t.scales=cd(e,t)}function ud(e){return e||={},e.datasets=e.datasets||[],e.labels=e.labels||[],e}function dd(e){return e||={},e.data=ud(e.data),ld(e),e}var fd=new Map,pd=new Set;function md(e,t){let n=fd.get(e);return n||(n=t(),fd.set(e,n),pd.add(n)),n}var hd=(e,t,n)=>{let r=lo(t,n);r!==void 0&&e.add(r)},gd=class{constructor(e){this._config=dd(e),this._scopeCache=new Map,this._resolverCache=new Map}get platform(){return this._config.platform}get type(){return this._config.type}set type(e){this._config.type=e}get data(){return this._config.data}set data(e){this._config.data=ud(e)}get options(){return this._config.options}set options(e){this._config.options=e}get plugins(){return this._config.plugins}update(){let e=this._config;this.clearCache(),ld(e)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(e){return md(e,()=>[[`datasets.${e}`,``]])}datasetAnimationScopeKeys(e,t){return md(`${e}.transition.${t}`,()=>[[`datasets.${e}.transitions.${t}`,`transitions.${t}`],[`datasets.${e}`,``]])}datasetElementScopeKeys(e,t){return md(`${e}-${t}`,()=>[[`datasets.${e}.elements.${t}`,`datasets.${e}`,`elements.${t}`,``]])}pluginScopeKeys(e){let t=e.id,n=this.type;return md(`${n}-plugin-${t}`,()=>[[`plugins.${t}`,...e.additionalOptionScopes||[]]])}_cachedScopes(e,t){let n=this._scopeCache,r=n.get(e);return(!r||t)&&(r=new Map,n.set(e,r)),r}getOptionScopes(e,t,n){let{options:r,type:i}=this,a=this._cachedScopes(e,n),o=a.get(t);if(o)return o;let s=new Set;t.forEach(t=>{e&&(s.add(e),t.forEach(t=>hd(s,e,t))),t.forEach(e=>hd(s,r,e)),t.forEach(e=>hd(s,ys[i]||{},e)),t.forEach(e=>hd(s,Z,e)),t.forEach(e=>hd(s,bs,e))});let c=Array.from(s);return c.length===0&&c.push(Object.create(null)),pd.has(t)&&a.set(t,c),c}chartOptionScopes(){let{options:e,type:t}=this;return[e,ys[t]||{},Z.datasets[t]||{},{type:t},Z,bs]}resolveNamedOptions(e,t,n,r=[``]){let i={$shared:!0},{resolver:a,subPrefixes:o}=_d(this._resolverCache,e,r),s=a;if(yd(a,t)){i.$shared=!1,n=po(n)?n():n;let t=this.createResolver(e,n,o);s=Ys(a,n,t)}for(let e of t)i[e]=s[e];return i}createResolver(e,t,n=[``],r){let{resolver:i}=_d(this._resolverCache,e,n);return G(t)?Ys(i,t,void 0,r):i}};function _d(e,t,n){let r=e.get(t);r||(r=new Map,e.set(t,r));let i=n.join(),a=r.get(i);return a||(a={resolver:Js(t,n),subPrefixes:n.filter(e=>!e.toLowerCase().includes(`hover`))},r.set(i,a)),a}var vd=e=>G(e)&&Object.getOwnPropertyNames(e).some(t=>po(e[t]));function yd(e,t){let{isScriptable:n,isIndexable:r}=Xs(e);for(let i of t){let t=n(i),a=r(i),o=(a||t)&&e[i];if(t&&(po(o)||vd(o))||a&&W(o))return!0}return!1}var bd=`4.5.1`,xd=[`top`,`bottom`,`left`,`right`,`chartArea`];function Sd(e,t){return e===`top`||e===`bottom`||xd.indexOf(e)===-1&&t===`x`}function Cd(e,t){return function(n,r){return n[e]===r[e]?n[t]-r[t]:n[e]-r[e]}}function wd(e){let t=e.chart,n=t.options.animation;t.notifyPlugins(`afterRender`),J(n&&n.onComplete,[e],t)}function Td(e){let t=e.chart,n=t.options.animation;J(n&&n.onProgress,[e],t)}function Ed(e){return pc()&&typeof e==`string`?e=document.getElementById(e):e&&e.length&&(e=e[0]),e&&e.canvas&&(e=e.canvas),e}var Dd={},Od=e=>{let t=Ed(e);return Object.values(Dd).filter(e=>e.canvas===t).pop()};function kd(e,t,n){let r=Object.keys(e);for(let i of r){let r=+i;if(r>=t){let a=e[i];delete e[i],(n>0||r>t)&&(e[r+n]=a)}}}function Ad(e,t,n,r){return!n||e.type===`mouseout`?null:r?t:e}var jd=class{static defaults=Z;static instances=Dd;static overrides=ys;static registry=Ju;static version=bd;static getChart=Od;static register(...e){Ju.add(...e),Md()}static unregister(...e){Ju.remove(...e),Md()}constructor(e,t){let n=this.config=new gd(t),r=Ed(e),i=Od(r);if(i)throw Error(`Canvas is already in use. Chart with ID '`+i.id+`' must be destroyed before the canvas with ID '`+i.canvas.id+`' can be reused.`);let a=n.createResolver(n.chartOptionScopes(),this.getContext());this.platform=new(n.platform||(Su(r))),this.platform.updateConfig(n);let o=this.platform.acquireContext(r,a.aspectRatio),s=o&&o.canvas,c=s&&s.height,l=s&&s.width;if(this.id=Xa(),this.ctx=o,this.canvas=s,this.width=l,this.height=c,this._options=a,this._aspectRatio=this.aspectRatio,this._layers=[],this._metasets=[],this._stacks=void 0,this.boxes=[],this.currentDevicePixelRatio=void 0,this.chartArea=void 0,this._active=[],this._lastEvent=void 0,this._listeners={},this._responsiveListeners=void 0,this._sortedMetasets=[],this.scales={},this._plugins=new Yu,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=Zo(e=>this.update(e),a.resizeDelay||0),this._dataChanges=[],Dd[this.id]=this,!o||!s){console.error(`Failed to create chart: can't acquire context from the given item`);return}Lc.listen(this,`complete`,wd),Lc.listen(this,`progress`,Td),this._initialize(),this.attached&&this.update()}get aspectRatio(){let{options:{aspectRatio:e,maintainAspectRatio:t},width:n,height:r,_aspectRatio:i}=this;return U(e)?t&&i?i:r?n/r:null:e}get data(){return this.config.data}set data(e){this.config.data=e}get options(){return this._options}set options(e){this.config.options=e}get registry(){return Ju}_initialize(){return this.notifyPlugins(`beforeInit`),this.options.responsive?this.resize():Ec(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins(`afterInit`),this}clear(){return Ds(this.canvas,this.ctx),this}stop(){return Lc.stop(this),this}resize(e,t){Lc.running(this)?this._resizeBeforeDraw={width:e,height:t}:this._resize(e,t)}_resize(e,t){let n=this.options,r=this.canvas,i=n.maintainAspectRatio&&this.aspectRatio,a=this.platform.getMaximumSize(r,e,t,i),o=n.devicePixelRatio||this.platform.getDevicePixelRatio(),s=this.width?`resize`:`attach`;this.width=a.width,this.height=a.height,this._aspectRatio=this.aspectRatio,Ec(this,o,!0)&&(this.notifyPlugins(`resize`,{size:a}),J(n.onResize,[this,a],this),this.attached&&this._doResize(s)&&this.render())}ensureScalesHaveIDs(){Y(this.options.scales||{},(e,t)=>{e.id=t})}buildOrUpdateScales(){let e=this.options,t=e.scales,n=this.scales,r=Object.keys(n).reduce((e,t)=>(e[t]=!1,e),{}),i=[];t&&(i=i.concat(Object.keys(t).map(e=>{let n=t[e],r=ad(e,n),i=r===`r`,a=r===`x`;return{options:n,dposition:i?`chartArea`:a?`bottom`:`left`,dtype:i?`radialLinear`:a?`category`:`linear`}}))),Y(i,t=>{let i=t.options,a=i.id,o=ad(a,i),s=q(i.type,t.dtype);(i.position===void 0||Sd(i.position,o)!==Sd(t.dposition))&&(i.position=t.dposition),r[a]=!0;let c=null;a in n&&n[a].type===s?c=n[a]:(c=new(Ju.getScale(s))({id:a,type:s,ctx:this.ctx,chart:this}),n[c.id]=c),c.init(i,e)}),Y(r,(e,t)=>{e||delete n[t]}),Y(n,e=>{$l.configure(this,e,e.options),$l.addBox(this,e)})}_updateMetasets(){let e=this._metasets,t=this.data.datasets.length,n=e.length;if(e.sort((e,t)=>e.index-t.index),n>t){for(let e=t;e<n;++e)this._destroyDatasetMeta(e);e.splice(t,n-t)}this._sortedMetasets=e.slice(0).sort(Cd(`order`,`index`))}_removeUnreferencedMetasets(){let{_metasets:e,data:{datasets:t}}=this;e.length>t.length&&delete this._stacks,e.forEach((e,n)=>{t.filter(t=>t===e._dataset).length===0&&this._destroyDatasetMeta(n)})}buildOrUpdateControllers(){let e=[],t=this.data.datasets,n,r;for(this._removeUnreferencedMetasets(),n=0,r=t.length;n<r;n++){let r=t[n],i=this.getDatasetMeta(n),a=r.type||this.config.type;if(i.type&&i.type!==a&&(this._destroyDatasetMeta(n),i=this.getDatasetMeta(n)),i.type=a,i.indexAxis=r.indexAxis||ed(a,this.options),i.order=r.order||0,i.index=n,i.label=``+r.label,i.visible=this.isDatasetVisible(n),i.controller)i.controller.updateIndex(n),i.controller.linkScales();else{let t=Ju.getController(a),{datasetElementType:r,dataElementType:o}=Z.datasets[a];Object.assign(t,{dataElementType:Ju.getElement(o),datasetElementType:r&&Ju.getElement(r)}),i.controller=new t(this,n),e.push(i.controller)}}return this._updateMetasets(),e}_resetElements(){Y(this.data.datasets,(e,t)=>{this.getDatasetMeta(t).controller.reset()},this)}reset(){this._resetElements(),this.notifyPlugins(`reset`)}update(e){let t=this.config;t.update();let n=this._options=t.createResolver(t.chartOptionScopes(),this.getContext()),r=this._animationsDisabled=!n.animation;if(this._updateScales(),this._checkEventBindings(),this._updateHiddenIndices(),this._plugins.invalidate(),this.notifyPlugins(`beforeUpdate`,{mode:e,cancelable:!0})===!1)return;let i=this.buildOrUpdateControllers();this.notifyPlugins(`beforeElementsUpdate`);let a=0;for(let e=0,t=this.data.datasets.length;e<t;e++){let{controller:t}=this.getDatasetMeta(e),n=!r&&i.indexOf(t)===-1;t.buildOrUpdateElements(n),a=Math.max(+t.getMaxOverflow(),a)}a=this._minPadding=n.layout.autoPadding?a:0,this._updateLayout(a),r||Y(i,e=>{e.reset()}),this._updateDatasets(e),this.notifyPlugins(`afterUpdate`,{mode:e}),this._layers.sort(Cd(`z`,`_idx`));let{_active:o,_lastEvent:s}=this;s?this._eventHandler(s,!0):o.length&&this._updateHoverStyles(o,o,!0),this.render()}_updateScales(){Y(this.scales,e=>{$l.removeBox(this,e)}),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){let e=this.options;(!mo(new Set(Object.keys(this._listeners)),new Set(e.events))||!!this._responsiveListeners!==e.responsive)&&(this.unbindEvents(),this.bindEvents())}_updateHiddenIndices(){let{_hiddenIndices:e}=this,t=this._getUniformDataChanges()||[];for(let{method:n,start:r,count:i}of t)kd(e,r,n===`_removeElements`?-i:i)}_getUniformDataChanges(){let e=this._dataChanges;if(!e||!e.length)return;this._dataChanges=[];let t=this.data.datasets.length,n=t=>new Set(e.filter(e=>e[0]===t).map((e,t)=>t+`,`+e.splice(1).join(`,`))),r=n(0);for(let e=1;e<t;e++)if(!mo(r,n(e)))return;return Array.from(r).map(e=>e.split(`,`)).map(e=>({method:e[1],start:+e[2],count:+e[3]}))}_updateLayout(e){if(this.notifyPlugins(`beforeLayout`,{cancelable:!0})===!1)return;$l.update(this,this.width,this.height,e);let t=this.chartArea,n=t.width<=0||t.height<=0;this._layers=[],Y(this.boxes,e=>{n&&e.position===`chartArea`||(e.configure&&e.configure(),this._layers.push(...e._layers()))},this),this._layers.forEach((e,t)=>{e._idx=t}),this.notifyPlugins(`afterLayout`)}_updateDatasets(e){if(this.notifyPlugins(`beforeDatasetsUpdate`,{mode:e,cancelable:!0})!==!1){for(let e=0,t=this.data.datasets.length;e<t;++e)this.getDatasetMeta(e).controller.configure();for(let t=0,n=this.data.datasets.length;t<n;++t)this._updateDataset(t,po(e)?e({datasetIndex:t}):e);this.notifyPlugins(`afterDatasetsUpdate`,{mode:e})}}_updateDataset(e,t){let n=this.getDatasetMeta(e),r={meta:n,index:e,mode:t,cancelable:!0};this.notifyPlugins(`beforeDatasetUpdate`,r)!==!1&&(n.controller._update(t),r.cancelable=!1,this.notifyPlugins(`afterDatasetUpdate`,r))}render(){this.notifyPlugins(`beforeRender`,{cancelable:!0})!==!1&&(Lc.has(this)?this.attached&&!Lc.running(this)&&Lc.start(this):(this.draw(),wd({chart:this})))}draw(){let e;if(this._resizeBeforeDraw){let{width:e,height:t}=this._resizeBeforeDraw;this._resizeBeforeDraw=null,this._resize(e,t)}if(this.clear(),this.width<=0||this.height<=0||this.notifyPlugins(`beforeDraw`,{cancelable:!0})===!1)return;let t=this._layers;for(e=0;e<t.length&&t[e].z<=0;++e)t[e].draw(this.chartArea);for(this._drawDatasets();e<t.length;++e)t[e].draw(this.chartArea);this.notifyPlugins(`afterDraw`)}_getSortedDatasetMetas(e){let t=this._sortedMetasets,n=[],r,i;for(r=0,i=t.length;r<i;++r){let i=t[r];(!e||i.visible)&&n.push(i)}return n}getSortedVisibleDatasetMetas(){return this._getSortedDatasetMetas(!0)}_drawDatasets(){if(this.notifyPlugins(`beforeDatasetsDraw`,{cancelable:!0})===!1)return;let e=this.getSortedVisibleDatasetMetas();for(let t=e.length-1;t>=0;--t)this._drawDataset(e[t]);this.notifyPlugins(`afterDatasetsDraw`)}_drawDataset(e){let t=this.ctx,n={meta:e,index:e.index,cancelable:!0},r=Ic(this,e);this.notifyPlugins(`beforeDatasetDraw`,n)!==!1&&(r&&js(t,r),e.controller.draw(),r&&Ms(t),n.cancelable=!1,this.notifyPlugins(`afterDatasetDraw`,n))}isPointInArea(e){return As(e,this.chartArea,this._minPadding)}getElementsAtEventForMode(e,t,n,r){let i=Il.modes[t];return typeof i==`function`?i(this,e,n,r):[]}getDatasetMeta(e){let t=this.data.datasets[e],n=this._metasets,r=n.filter(e=>e&&e._dataset===t).pop();return r||(r={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:t&&t.order||0,index:e,_dataset:t,_parsed:[],_sorted:!1},n.push(r)),r}getContext(){return this.$context||=qs(null,{chart:this,type:`chart`})}getVisibleDatasetCount(){return this.getSortedVisibleDatasetMetas().length}isDatasetVisible(e){let t=this.data.datasets[e];if(!t)return!1;let n=this.getDatasetMeta(e);return typeof n.hidden==`boolean`?!n.hidden:!t.hidden}setDatasetVisibility(e,t){let n=this.getDatasetMeta(e);n.hidden=!t}toggleDataVisibility(e){this._hiddenIndices[e]=!this._hiddenIndices[e]}getDataVisibility(e){return!this._hiddenIndices[e]}_updateVisibility(e,t,n){let r=n?`show`:`hide`,i=this.getDatasetMeta(e),a=i.controller._resolveAnimations(void 0,r);fo(t)?(i.data[t].hidden=!n,this.update()):(this.setDatasetVisibility(e,n),a.update(i,{visible:n}),this.update(t=>t.datasetIndex===e?r:void 0))}hide(e,t){this._updateVisibility(e,t,!1)}show(e,t){this._updateVisibility(e,t,!0)}_destroyDatasetMeta(e){let t=this._metasets[e];t&&t.controller&&t.controller._destroy(),delete this._metasets[e]}_stop(){let e,t;for(this.stop(),Lc.remove(this),e=0,t=this.data.datasets.length;e<t;++e)this._destroyDatasetMeta(e)}destroy(){this.notifyPlugins(`beforeDestroy`);let{canvas:e,ctx:t}=this;this._stop(),this.config.clearCache(),e&&(this.unbindEvents(),Ds(e,t),this.platform.releaseContext(t),this.canvas=null,this.ctx=null),delete Dd[this.id],this.notifyPlugins(`afterDestroy`)}toBase64Image(...e){return this.canvas.toDataURL(...e)}bindEvents(){this.bindUserEvents(),this.options.responsive?this.bindResponsiveEvents():this.attached=!0}bindUserEvents(){let e=this._listeners,t=this.platform,n=(n,r)=>{t.addEventListener(this,n,r),e[n]=r},r=(e,t,n)=>{e.offsetX=t,e.offsetY=n,this._eventHandler(e)};Y(this.options.events,e=>n(e,r))}bindResponsiveEvents(){this._responsiveListeners||={};let e=this._responsiveListeners,t=this.platform,n=(n,r)=>{t.addEventListener(this,n,r),e[n]=r},r=(n,r)=>{e[n]&&(t.removeEventListener(this,n,r),delete e[n])},i=(e,t)=>{this.canvas&&this.resize(e,t)},a,o=()=>{r(`attach`,o),this.attached=!0,this.resize(),n(`resize`,i),n(`detach`,a)};a=()=>{this.attached=!1,r(`resize`,i),this._stop(),this._resize(0,0),n(`attach`,o)},t.isAttached(this.canvas)?o():a()}unbindEvents(){Y(this._listeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._listeners={},Y(this._responsiveListeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._responsiveListeners=void 0}updateHoverStyle(e,t,n){let r=n?`set`:`remove`,i,a,o,s;for(t===`dataset`&&(i=this.getDatasetMeta(e[0].datasetIndex),i.controller[`_`+r+`DatasetHoverStyle`]()),o=0,s=e.length;o<s;++o){a=e[o];let t=a&&this.getDatasetMeta(a.datasetIndex).controller;t&&t[r+`HoverStyle`](a.element,a.datasetIndex,a.index)}}getActiveElements(){return this._active||[]}setActiveElements(e){let t=this._active||[],n=e.map(({datasetIndex:e,index:t})=>{let n=this.getDatasetMeta(e);if(!n)throw Error(`No dataset found at index `+e);return{datasetIndex:e,element:n.data[t],index:t}});$a(n,t)||(this._active=n,this._lastEvent=null,this._updateHoverStyles(n,t))}notifyPlugins(e,t,n){return this._plugins.notify(this,e,t,n)}isPluginEnabled(e){return this._plugins._cache.filter(t=>t.plugin.id===e).length===1}_updateHoverStyles(e,t,n){let r=this.options.hover,i=(e,t)=>e.filter(e=>!t.some(t=>e.datasetIndex===t.datasetIndex&&e.index===t.index)),a=i(t,e),o=n?e:i(e,t);a.length&&this.updateHoverStyle(a,r.mode,!1),o.length&&r.mode&&this.updateHoverStyle(o,r.mode,!0)}_eventHandler(e,t){let n={event:e,replay:t,cancelable:!0,inChartArea:this.isPointInArea(e)},r=t=>(t.options.events||this.options.events).includes(e.native.type);if(this.notifyPlugins(`beforeEvent`,n,r)===!1)return;let i=this._handleEvent(e,t,n.inChartArea);return n.cancelable=!1,this.notifyPlugins(`afterEvent`,n,r),(i||n.changed)&&this.render(),this}_handleEvent(e,t,n){let{_active:r=[],options:i}=this,a=t,o=this._getActiveElements(e,r,n,a),s=ho(e),c=Ad(e,this._lastEvent,n,s);n&&(this._lastEvent=null,J(i.onHover,[e,o,this],this),s&&J(i.onClick,[e,o,this],this));let l=!$a(o,r);return(l||t)&&(this._active=o,this._updateHoverStyles(o,r,t)),this._lastEvent=c,l}_getActiveElements(e,t,n,r){if(e.type===`mouseout`)return[];if(!n)return t;let i=this.options.hover;return this.getElementsAtEventForMode(e,i.mode,i,r)}};function Md(){return Y(jd.instances,e=>e._plugins.invalidate())}function Nd(e,t){let{x:n,y:r,base:i,width:a,height:o}=e.getProps([`x`,`y`,`base`,`width`,`height`],t),s,c,l,u,d;return e.horizontal?(d=o/2,s=Math.min(n,i),c=Math.max(n,i),l=r-d,u=r+d):(d=a/2,s=n-d,c=n+d,l=Math.min(r,i),u=Math.max(r,i)),{left:s,top:l,right:c,bottom:u}}function Pd(e,t,n,r){return e?0:Ro(t,n,r)}function Fd(e,t,n){let r=e.options.borderWidth,i=e.borderSkipped,a=Us(r);return{t:Pd(i.top,a.top,0,n),r:Pd(i.right,a.right,0,t),b:Pd(i.bottom,a.bottom,0,n),l:Pd(i.left,a.left,0,t)}}function Id(e,t,n){let{enableBorderRadius:r}=e.getProps([`enableBorderRadius`]),i=e.options.borderRadius,a=Ws(i),o=Math.min(t,n),s=e.borderSkipped,c=r||G(i);return{topLeft:Pd(!c||s.top||s.left,a.topLeft,0,o),topRight:Pd(!c||s.top||s.right,a.topRight,0,o),bottomLeft:Pd(!c||s.bottom||s.left,a.bottomLeft,0,o),bottomRight:Pd(!c||s.bottom||s.right,a.bottomRight,0,o)}}function Ld(e){let t=Nd(e),n=t.right-t.left,r=t.bottom-t.top,i=Fd(e,n/2,r/2),a=Id(e,n/2,r/2);return{outer:{x:t.left,y:t.top,w:n,h:r,radius:a},inner:{x:t.left+i.l,y:t.top+i.t,w:n-i.l-i.r,h:r-i.t-i.b,radius:{topLeft:Math.max(0,a.topLeft-Math.max(i.t,i.l)),topRight:Math.max(0,a.topRight-Math.max(i.t,i.r)),bottomLeft:Math.max(0,a.bottomLeft-Math.max(i.b,i.l)),bottomRight:Math.max(0,a.bottomRight-Math.max(i.b,i.r))}}}}function Rd(e,t,n,r){let i=t===null,a=n===null,o=e&&!(i&&a)&&Nd(e,r);return o&&(i||Bo(t,o.left,o.right))&&(a||Bo(n,o.top,o.bottom))}function zd(e){return e.topLeft||e.topRight||e.bottomLeft||e.bottomRight}function Bd(e,t){e.rect(t.x,t.y,t.w,t.h)}function Vd(e,t,n={}){let r=e.x===n.x?0:-t,i=e.y===n.y?0:-t,a=(e.x+e.w===n.x+n.w?0:t)-r,o=(e.y+e.h===n.y+n.h?0:t)-i;return{x:e.x+r,y:e.y+i,w:e.w+a,h:e.h+o,radius:e.radius}}var Hd=class extends Cu{static id=`bar`;static defaults={borderSkipped:`start`,borderWidth:0,borderRadius:0,inflateAmount:`auto`,pointStyle:void 0};static defaultRoutes={backgroundColor:`backgroundColor`,borderColor:`borderColor`};constructor(e){super(),this.options=void 0,this.horizontal=void 0,this.base=void 0,this.width=void 0,this.height=void 0,this.inflateAmount=void 0,e&&Object.assign(this,e)}draw(e){let{inflateAmount:t,options:{borderColor:n,backgroundColor:r}}=this,{inner:i,outer:a}=Ld(this),o=zd(a.radius)?Ls:Bd;e.save(),(a.w!==i.w||a.h!==i.h)&&(e.beginPath(),o(e,Vd(a,t,i)),e.clip(),o(e,Vd(i,-t,a)),e.fillStyle=n,e.fill(`evenodd`)),e.beginPath(),o(e,Vd(i,t)),e.fillStyle=r,e.fill(),e.restore()}inRange(e,t,n){return Rd(this,e,t,n)}inXRange(e,t){return Rd(this,e,null,t)}inYRange(e,t){return Rd(this,null,e,t)}getCenterPoint(e){let{x:t,y:n,base:r,horizontal:i}=this.getProps([`x`,`y`,`base`,`horizontal`],e);return{x:i?(t+r)/2:t,y:i?n:(n+r)/2}}getRange(e){return e===`x`?this.width/2:this.height/2}},Ud=(e,t)=>{let{boxHeight:n=t,boxWidth:r=t}=e;return e.usePointStyle&&(n=Math.min(n,t),r=e.pointStyleWidth||Math.min(r,t)),{boxWidth:r,boxHeight:n,itemHeight:Math.max(t,n)}},Wd=(e,t)=>e!==null&&t!==null&&e.datasetIndex===t.datasetIndex&&e.index===t.index,Gd=class extends Cu{constructor(e){super(),this._added=!1,this.legendHitBoxes=[],this._hoveredItem=null,this.doughnutMode=!1,this.chart=e.chart,this.options=e.options,this.ctx=e.ctx,this.legendItems=void 0,this.columnSizes=void 0,this.lineWidths=void 0,this.maxHeight=void 0,this.maxWidth=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.height=void 0,this.width=void 0,this._margins=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(e,t,n){this.maxWidth=e,this.maxHeight=t,this._margins=n,this.setDimensions(),this.buildLabels(),this.fit()}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=this._margins.left,this.right=this.width):(this.height=this.maxHeight,this.top=this._margins.top,this.bottom=this.height)}buildLabels(){let e=this.options.labels||{},t=J(e.generateLabels,[this.chart],this)||[];e.filter&&(t=t.filter(t=>e.filter(t,this.chart.data))),e.sort&&(t=t.sort((t,n)=>e.sort(t,n,this.chart.data))),this.options.reverse&&t.reverse(),this.legendItems=t}fit(){let{options:e,ctx:t}=this;if(!e.display){this.width=this.height=0;return}let n=e.labels,r=$(n.font),i=r.size,a=this._computeTitleHeight(),{boxWidth:o,itemHeight:s}=Ud(n,i),c,l;t.font=r.string,this.isHorizontal()?(c=this.maxWidth,l=this._fitRows(a,i,o,s)+10):(l=this.maxHeight,c=this._fitCols(a,r,o,s)+10),this.width=Math.min(c,e.maxWidth||this.maxWidth),this.height=Math.min(l,e.maxHeight||this.maxHeight)}_fitRows(e,t,n,r){let{ctx:i,maxWidth:a,options:{labels:{padding:o}}}=this,s=this.legendHitBoxes=[],c=this.lineWidths=[0],l=r+o,u=e;i.textAlign=`left`,i.textBaseline=`middle`;let d=-1,f=-l;return this.legendItems.forEach((e,p)=>{let m=n+t/2+i.measureText(e.text).width;(p===0||c[c.length-1]+m+2*o>a)&&(u+=l,c[c.length-(p>0?0:1)]=0,f+=l,d++),s[p]={left:0,top:f,row:d,width:m,height:r},c[c.length-1]+=m+o}),u}_fitCols(e,t,n,r){let{ctx:i,maxHeight:a,options:{labels:{padding:o}}}=this,s=this.legendHitBoxes=[],c=this.columnSizes=[],l=a-e,u=o,d=0,f=0,p=0,m=0;return this.legendItems.forEach((e,a)=>{let{itemWidth:h,itemHeight:g}=Kd(n,t,i,e,r);a>0&&f+g+2*o>l&&(u+=d+o,c.push({width:d,height:f}),p+=d+o,m++,d=f=0),s[a]={left:p,top:f,col:m,width:h,height:g},d=Math.max(d,h),f+=g+o}),u+=d,c.push({width:d,height:f}),u}adjustHitBoxes(){if(!this.options.display)return;let e=this._computeTitleHeight(),{legendHitBoxes:t,options:{align:n,labels:{padding:r},rtl:i}}=this,a=jc(i,this.left,this.width);if(this.isHorizontal()){let i=0,o=$o(n,this.left+r,this.right-this.lineWidths[i]);for(let s of t)i!==s.row&&(i=s.row,o=$o(n,this.left+r,this.right-this.lineWidths[i])),s.top+=this.top+e+r,s.left=a.leftForLtr(a.x(o),s.width),o+=s.width+r}else{let i=0,o=$o(n,this.top+e+r,this.bottom-this.columnSizes[i].height);for(let s of t)s.col!==i&&(i=s.col,o=$o(n,this.top+e+r,this.bottom-this.columnSizes[i].height)),s.top=o,s.left+=this.left+r,s.left=a.leftForLtr(a.x(s.left),s.width),o+=s.height+r}}isHorizontal(){return this.options.position===`top`||this.options.position===`bottom`}draw(){if(this.options.display){let e=this.ctx;js(e,this),this._draw(),Ms(e)}}_draw(){let{options:e,columnSizes:t,lineWidths:n,ctx:r}=this,{align:i,labels:a}=e,o=Z.color,s=jc(e.rtl,this.left,this.width),c=$(a.font),{padding:l}=a,u=c.size,d=u/2,f;this.drawTitle(),r.textAlign=s.textAlign(`left`),r.textBaseline=`middle`,r.lineWidth=.5,r.font=c.string;let{boxWidth:p,boxHeight:m,itemHeight:h}=Ud(a,u),g=function(e,t,n){if(isNaN(p)||p<=0||isNaN(m)||m<0)return;r.save();let i=q(n.lineWidth,1);if(r.fillStyle=q(n.fillStyle,o),r.lineCap=q(n.lineCap,`butt`),r.lineDashOffset=q(n.lineDashOffset,0),r.lineJoin=q(n.lineJoin,`miter`),r.lineWidth=i,r.strokeStyle=q(n.strokeStyle,o),r.setLineDash(q(n.lineDash,[])),a.usePointStyle){let o={radius:m*Math.SQRT2/2,pointStyle:n.pointStyle,rotation:n.rotation,borderWidth:i},c=s.xPlus(e,p/2),l=t+d;ks(r,o,c,l,a.pointStyleWidth&&p)}else{let a=t+Math.max((u-m)/2,0),o=s.leftForLtr(e,p),c=Ws(n.borderRadius);r.beginPath(),Object.values(c).some(e=>e!==0)?Ls(r,{x:o,y:a,w:p,h:m,radius:c}):r.rect(o,a,p,m),r.fill(),i!==0&&r.stroke()}r.restore()},_=function(e,t,n){Is(r,n.text,e,t+h/2,c,{strikethrough:n.hidden,textAlign:s.textAlign(n.textAlign)})},v=this.isHorizontal(),y=this._computeTitleHeight();f=v?{x:$o(i,this.left+l,this.right-n[0]),y:this.top+l+y,line:0}:{x:this.left+l,y:$o(i,this.top+y+l,this.bottom-t[0].height),line:0},Mc(this.ctx,e.textDirection);let b=h+l;this.legendItems.forEach((o,u)=>{r.strokeStyle=o.fontColor,r.fillStyle=o.fontColor;let m=r.measureText(o.text).width,h=s.textAlign(o.textAlign||=a.textAlign),x=p+d+m,S=f.x,C=f.y;s.setWidth(this.width),v?u>0&&S+x+l>this.right&&(C=f.y+=b,f.line++,S=f.x=$o(i,this.left+l,this.right-n[f.line])):u>0&&C+b>this.bottom&&(S=f.x=S+t[f.line].width+l,f.line++,C=f.y=$o(i,this.top+y+l,this.bottom-t[f.line].height));let w=s.x(S);if(g(w,C,o),S=es(h,S+p+d,v?S+x:this.right,e.rtl),_(s.x(S),C,o),v)f.x+=x+l;else if(typeof o.text!=`string`){let e=c.lineHeight;f.y+=Yd(o,e)+l}else f.y+=b}),Nc(this.ctx,e.textDirection)}drawTitle(){let e=this.options,t=e.title,n=$(t.font),r=Q(t.padding);if(!t.display)return;let i=jc(e.rtl,this.left,this.width),a=this.ctx,o=t.position,s=n.size/2,c=r.top+s,l,u=this.left,d=this.width;if(this.isHorizontal())d=Math.max(...this.lineWidths),l=this.top+c,u=$o(e.align,u,this.right-d);else{let t=this.columnSizes.reduce((e,t)=>Math.max(e,t.height),0);l=c+$o(e.align,this.top,this.bottom-t-e.labels.padding-this._computeTitleHeight())}let f=$o(o,u,u+d);a.textAlign=i.textAlign(Qo(o)),a.textBaseline=`middle`,a.strokeStyle=t.color,a.fillStyle=t.color,a.font=n.string,Is(a,t.text,f,l,n)}_computeTitleHeight(){let e=this.options.title,t=$(e.font),n=Q(e.padding);return e.display?t.lineHeight+n.height:0}_getLegendItemAt(e,t){let n,r,i;if(Bo(e,this.left,this.right)&&Bo(t,this.top,this.bottom)){for(i=this.legendHitBoxes,n=0;n<i.length;++n)if(r=i[n],Bo(e,r.left,r.left+r.width)&&Bo(t,r.top,r.top+r.height))return this.legendItems[n]}return null}handleEvent(e){let t=this.options;if(!Xd(e.type,t))return;let n=this._getLegendItemAt(e.x,e.y);if(e.type===`mousemove`||e.type===`mouseout`){let r=this._hoveredItem,i=Wd(r,n);r&&!i&&J(t.onLeave,[e,r,this],this),this._hoveredItem=n,n&&!i&&J(t.onHover,[e,n,this],this)}else n&&J(t.onClick,[e,n,this],this)}};function Kd(e,t,n,r,i){return{itemWidth:qd(r,e,t,n),itemHeight:Jd(i,r,t.lineHeight)}}function qd(e,t,n,r){let i=e.text;return i&&typeof i!=`string`&&(i=i.reduce((e,t)=>e.length>t.length?e:t)),t+n.size/2+r.measureText(i).width}function Jd(e,t,n){let r=e;return typeof t.text!=`string`&&(r=Yd(t,n)),r}function Yd(e,t){return t*(e.text?e.text.length:0)}function Xd(e,t){return!!((e===`mousemove`||e===`mouseout`)&&(t.onHover||t.onLeave)||t.onClick&&(e===`click`||e===`mouseup`))}var Zd={id:`legend`,_element:Gd,start(e,t,n){let r=e.legend=new Gd({ctx:e.ctx,options:n,chart:e});$l.configure(e,r,n),$l.addBox(e,r)},stop(e){$l.removeBox(e,e.legend),delete e.legend},beforeUpdate(e,t,n){let r=e.legend;$l.configure(e,r,n),r.options=n},afterUpdate(e){let t=e.legend;t.buildLabels(),t.adjustHitBoxes()},afterEvent(e,t){t.replay||e.legend.handleEvent(t.event)},defaults:{display:!0,position:`top`,align:`center`,fullSize:!0,reverse:!1,weight:1e3,onClick(e,t,n){let r=t.datasetIndex,i=n.chart;i.isDatasetVisible(r)?(i.hide(r),t.hidden=!0):(i.show(r),t.hidden=!1)},onHover:null,onLeave:null,labels:{color:e=>e.chart.options.color,boxWidth:40,padding:10,generateLabels(e){let t=e.data.datasets,{labels:{usePointStyle:n,pointStyle:r,textAlign:i,color:a,useBorderRadius:o,borderRadius:s}}=e.legend.options;return e._getSortedDatasetMetas().map(e=>{let c=e.controller.getStyle(n?0:void 0),l=Q(c.borderWidth);return{text:t[e.index].label,fillStyle:c.backgroundColor,fontColor:a,hidden:!e.visible,lineCap:c.borderCapStyle,lineDash:c.borderDash,lineDashOffset:c.borderDashOffset,lineJoin:c.borderJoinStyle,lineWidth:(l.width+l.height)/4,strokeStyle:c.borderColor,pointStyle:r||c.pointStyle,rotation:c.rotation,textAlign:i||c.textAlign,borderRadius:o&&(s||c.borderRadius),datasetIndex:e.index}},this)}},title:{color:e=>e.chart.options.color,display:!1,position:`center`,text:``}},descriptors:{_scriptable:e=>!e.startsWith(`on`),labels:{_scriptable:e=>![`generateLabels`,`filter`,`sort`].includes(e)}}},Qd={average(e){if(!e.length)return!1;let t,n,r=new Set,i=0,a=0;for(t=0,n=e.length;t<n;++t){let n=e[t].element;if(n&&n.hasValue()){let e=n.tooltipPosition();r.add(e.x),i+=e.y,++a}}return a===0||r.size===0?!1:{x:[...r].reduce((e,t)=>e+t)/r.size,y:i/a}},nearest(e,t){if(!e.length)return!1;let n=t.x,r=t.y,i=1/0,a,o,s;for(a=0,o=e.length;a<o;++a){let n=e[a].element;if(n&&n.hasValue()){let e=Fo(t,n.getCenterPoint());e<i&&(i=e,s=n)}}if(s){let e=s.tooltipPosition();n=e.x,r=e.y}return{x:n,y:r}}};function $d(e,t){return t&&(W(t)?Array.prototype.push.apply(e,t):e.push(t)),e}function ef(e){return(typeof e==`string`||e instanceof String)&&e.indexOf(`
`)>-1?e.split(`
`):e}function tf(e,t){let{element:n,datasetIndex:r,index:i}=t,a=e.getDatasetMeta(r).controller,{label:o,value:s}=a.getLabelAndValue(i);return{chart:e,label:o,parsed:a.getParsed(i),raw:e.data.datasets[r].data[i],formattedValue:s,dataset:a.getDataset(),dataIndex:i,datasetIndex:r,element:n}}function nf(e,t){let n=e.chart.ctx,{body:r,footer:i,title:a}=e,{boxWidth:o,boxHeight:s}=t,c=$(t.bodyFont),l=$(t.titleFont),u=$(t.footerFont),d=a.length,f=i.length,p=r.length,m=Q(t.padding),h=m.height,g=0,_=r.reduce((e,t)=>e+t.before.length+t.lines.length+t.after.length,0);if(_+=e.beforeBody.length+e.afterBody.length,d&&(h+=d*l.lineHeight+(d-1)*t.titleSpacing+t.titleMarginBottom),_){let e=t.displayColors?Math.max(s,c.lineHeight):c.lineHeight;h+=p*e+(_-p)*c.lineHeight+(_-1)*t.bodySpacing}f&&(h+=t.footerMarginTop+f*u.lineHeight+(f-1)*t.footerSpacing);let v=0,y=function(e){g=Math.max(g,n.measureText(e).width+v)};return n.save(),n.font=l.string,Y(e.title,y),n.font=c.string,Y(e.beforeBody.concat(e.afterBody),y),v=t.displayColors?o+2+t.boxPadding:0,Y(r,e=>{Y(e.before,y),Y(e.lines,y),Y(e.after,y)}),v=0,n.font=u.string,Y(e.footer,y),n.restore(),g+=m.width,{width:g,height:h}}function rf(e,t){let{y:n,height:r}=t;return n<r/2?`top`:n>e.height-r/2?`bottom`:`center`}function af(e,t,n,r){let{x:i,width:a}=r,o=n.caretSize+n.caretPadding;if(e===`left`&&i+a+o>t.width||e===`right`&&i-a-o<0)return!0}function of(e,t,n,r){let{x:i,width:a}=n,{width:o,chartArea:{left:s,right:c}}=e,l=`center`;return r===`center`?l=i<=(s+c)/2?`left`:`right`:i<=a/2?l=`left`:i>=o-a/2&&(l=`right`),af(l,e,t,n)&&(l=`center`),l}function sf(e,t,n){let r=n.yAlign||t.yAlign||rf(e,n);return{xAlign:n.xAlign||t.xAlign||of(e,t,n,r),yAlign:r}}function cf(e,t){let{x:n,width:r}=e;return t===`right`?n-=r:t===`center`&&(n-=r/2),n}function lf(e,t,n){let{y:r,height:i}=e;return t===`top`?r+=n:r-=t===`bottom`?i+n:i/2,r}function uf(e,t,n,r){let{caretSize:i,caretPadding:a,cornerRadius:o}=e,{xAlign:s,yAlign:c}=n,l=i+a,{topLeft:u,topRight:d,bottomLeft:f,bottomRight:p}=Ws(o),m=cf(t,s),h=lf(t,c,l);return c===`center`?s===`left`?m+=l:s===`right`&&(m-=l):s===`left`?m-=Math.max(u,f)+i:s===`right`&&(m+=Math.max(d,p)+i),{x:Ro(m,0,r.width-t.width),y:Ro(h,0,r.height-t.height)}}function df(e,t,n){let r=Q(n.padding);return t===`center`?e.x+e.width/2:t===`right`?e.x+e.width-r.right:e.x+r.left}function ff(e){return $d([],ef(e))}function pf(e,t,n){return qs(e,{tooltip:t,tooltipItems:n,type:`tooltip`})}function mf(e,t){let n=t&&t.dataset&&t.dataset.tooltip&&t.dataset.tooltip.callbacks;return n?e.override(n):e}var hf={beforeTitle:Ya,title(e){if(e.length>0){let t=e[0],n=t.chart.data.labels,r=n?n.length:0;if(this&&this.options&&this.options.mode===`dataset`)return t.dataset.label||``;if(t.label)return t.label;if(r>0&&t.dataIndex<r)return n[t.dataIndex]}return``},afterTitle:Ya,beforeBody:Ya,beforeLabel:Ya,label(e){if(this&&this.options&&this.options.mode===`dataset`)return e.label+`: `+e.formattedValue||e.formattedValue;let t=e.dataset.label||``;t&&(t+=`: `);let n=e.formattedValue;return U(n)||(t+=n),t},labelColor(e){let t=e.chart.getDatasetMeta(e.datasetIndex).controller.getStyle(e.dataIndex);return{borderColor:t.borderColor,backgroundColor:t.backgroundColor,borderWidth:t.borderWidth,borderDash:t.borderDash,borderDashOffset:t.borderDashOffset,borderRadius:0}},labelTextColor(){return this.options.bodyColor},labelPointStyle(e){let t=e.chart.getDatasetMeta(e.datasetIndex).controller.getStyle(e.dataIndex);return{pointStyle:t.pointStyle,rotation:t.rotation}},afterLabel:Ya,afterBody:Ya,beforeFooter:Ya,footer:Ya,afterFooter:Ya};function gf(e,t,n,r){let i=e[t].call(n,r);return i===void 0?hf[t].call(n,r):i}var _f=class extends Cu{static positioners=Qd;constructor(e){super(),this.opacity=0,this._active=[],this._eventPosition=void 0,this._size=void 0,this._cachedAnimations=void 0,this._tooltipItems=[],this.$animations=void 0,this.$context=void 0,this.chart=e.chart,this.options=e.options,this.dataPoints=void 0,this.title=void 0,this.beforeBody=void 0,this.body=void 0,this.afterBody=void 0,this.footer=void 0,this.xAlign=void 0,this.yAlign=void 0,this.x=void 0,this.y=void 0,this.height=void 0,this.width=void 0,this.caretX=void 0,this.caretY=void 0,this.labelColors=void 0,this.labelPointStyles=void 0,this.labelTextColors=void 0}initialize(e){this.options=e,this._cachedAnimations=void 0,this.$context=void 0}_resolveAnimations(){let e=this._cachedAnimations;if(e)return e;let t=this.chart,n=this.options.setContext(this.getContext()),r=n.enabled&&t.options.animation&&n.animations,i=new Vc(this.chart,r);return r._cacheable&&(this._cachedAnimations=Object.freeze(i)),i}getContext(){return this.$context||=pf(this.chart.getContext(),this,this._tooltipItems)}getTitle(e,t){let{callbacks:n}=t,r=gf(n,`beforeTitle`,this,e),i=gf(n,`title`,this,e),a=gf(n,`afterTitle`,this,e),o=[];return o=$d(o,ef(r)),o=$d(o,ef(i)),o=$d(o,ef(a)),o}getBeforeBody(e,t){return ff(gf(t.callbacks,`beforeBody`,this,e))}getBody(e,t){let{callbacks:n}=t,r=[];return Y(e,e=>{let t={before:[],lines:[],after:[]},i=mf(n,e);$d(t.before,ef(gf(i,`beforeLabel`,this,e))),$d(t.lines,gf(i,`label`,this,e)),$d(t.after,ef(gf(i,`afterLabel`,this,e))),r.push(t)}),r}getAfterBody(e,t){return ff(gf(t.callbacks,`afterBody`,this,e))}getFooter(e,t){let{callbacks:n}=t,r=gf(n,`beforeFooter`,this,e),i=gf(n,`footer`,this,e),a=gf(n,`afterFooter`,this,e),o=[];return o=$d(o,ef(r)),o=$d(o,ef(i)),o=$d(o,ef(a)),o}_createItems(e){let t=this._active,n=this.chart.data,r=[],i=[],a=[],o=[],s,c;for(s=0,c=t.length;s<c;++s)o.push(tf(this.chart,t[s]));return e.filter&&(o=o.filter((t,r,i)=>e.filter(t,r,i,n))),e.itemSort&&(o=o.sort((t,r)=>e.itemSort(t,r,n))),Y(o,t=>{let n=mf(e.callbacks,t);r.push(gf(n,`labelColor`,this,t)),i.push(gf(n,`labelPointStyle`,this,t)),a.push(gf(n,`labelTextColor`,this,t))}),this.labelColors=r,this.labelPointStyles=i,this.labelTextColors=a,this.dataPoints=o,o}update(e,t){let n=this.options.setContext(this.getContext()),r=this._active,i,a=[];if(!r.length)this.opacity!==0&&(i={opacity:0});else{let e=Qd[n.position].call(this,r,this._eventPosition);a=this._createItems(n),this.title=this.getTitle(a,n),this.beforeBody=this.getBeforeBody(a,n),this.body=this.getBody(a,n),this.afterBody=this.getAfterBody(a,n),this.footer=this.getFooter(a,n);let t=this._size=nf(this,n),o=Object.assign({},e,t),s=sf(this.chart,n,o),c=uf(n,o,s,this.chart);this.xAlign=s.xAlign,this.yAlign=s.yAlign,i={opacity:1,x:c.x,y:c.y,width:t.width,height:t.height,caretX:e.x,caretY:e.y}}this._tooltipItems=a,this.$context=void 0,i&&this._resolveAnimations().update(this,i),e&&n.external&&n.external.call(this,{chart:this.chart,tooltip:this,replay:t})}drawCaret(e,t,n,r){let i=this.getCaretPosition(e,n,r);t.lineTo(i.x1,i.y1),t.lineTo(i.x2,i.y2),t.lineTo(i.x3,i.y3)}getCaretPosition(e,t,n){let{xAlign:r,yAlign:i}=this,{caretSize:a,cornerRadius:o}=n,{topLeft:s,topRight:c,bottomLeft:l,bottomRight:u}=Ws(o),{x:d,y:f}=e,{width:p,height:m}=t,h,g,_,v,y,b;return i===`center`?(y=f+m/2,r===`left`?(h=d,g=h-a,v=y+a,b=y-a):(h=d+p,g=h+a,v=y-a,b=y+a),_=h):(g=r===`left`?d+Math.max(s,l)+a:r===`right`?d+p-Math.max(c,u)-a:this.caretX,i===`top`?(v=f,y=v-a,h=g-a,_=g+a):(v=f+m,y=v+a,h=g+a,_=g-a),b=v),{x1:h,x2:g,x3:_,y1:v,y2:y,y3:b}}drawTitle(e,t,n){let r=this.title,i=r.length,a,o,s;if(i){let c=jc(n.rtl,this.x,this.width);for(e.x=df(this,n.titleAlign,n),t.textAlign=c.textAlign(n.titleAlign),t.textBaseline=`middle`,a=$(n.titleFont),o=n.titleSpacing,t.fillStyle=n.titleColor,t.font=a.string,s=0;s<i;++s)t.fillText(r[s],c.x(e.x),e.y+a.lineHeight/2),e.y+=a.lineHeight+o,s+1===i&&(e.y+=n.titleMarginBottom-o)}}_drawColorBox(e,t,n,r,i){let a=this.labelColors[n],o=this.labelPointStyles[n],{boxHeight:s,boxWidth:c}=i,l=$(i.bodyFont),u=df(this,`left`,i),d=r.x(u),f=s<l.lineHeight?(l.lineHeight-s)/2:0,p=t.y+f;if(i.usePointStyle){let t={radius:Math.min(c,s)/2,pointStyle:o.pointStyle,rotation:o.rotation,borderWidth:1},n=r.leftForLtr(d,c)+c/2,l=p+s/2;e.strokeStyle=i.multiKeyBackground,e.fillStyle=i.multiKeyBackground,Os(e,t,n,l),e.strokeStyle=a.borderColor,e.fillStyle=a.backgroundColor,Os(e,t,n,l)}else{e.lineWidth=G(a.borderWidth)?Math.max(...Object.values(a.borderWidth)):a.borderWidth||1,e.strokeStyle=a.borderColor,e.setLineDash(a.borderDash||[]),e.lineDashOffset=a.borderDashOffset||0;let t=r.leftForLtr(d,c),n=r.leftForLtr(r.xPlus(d,1),c-2),o=Ws(a.borderRadius);Object.values(o).some(e=>e!==0)?(e.beginPath(),e.fillStyle=i.multiKeyBackground,Ls(e,{x:t,y:p,w:c,h:s,radius:o}),e.fill(),e.stroke(),e.fillStyle=a.backgroundColor,e.beginPath(),Ls(e,{x:n,y:p+1,w:c-2,h:s-2,radius:o}),e.fill()):(e.fillStyle=i.multiKeyBackground,e.fillRect(t,p,c,s),e.strokeRect(t,p,c,s),e.fillStyle=a.backgroundColor,e.fillRect(n,p+1,c-2,s-2))}e.fillStyle=this.labelTextColors[n]}drawBody(e,t,n){let{body:r}=this,{bodySpacing:i,bodyAlign:a,displayColors:o,boxHeight:s,boxWidth:c,boxPadding:l}=n,u=$(n.bodyFont),d=u.lineHeight,f=0,p=jc(n.rtl,this.x,this.width),m=function(n){t.fillText(n,p.x(e.x+f),e.y+d/2),e.y+=d+i},h=p.textAlign(a),g,_,v,y,b,x,S;for(t.textAlign=a,t.textBaseline=`middle`,t.font=u.string,e.x=df(this,h,n),t.fillStyle=n.bodyColor,Y(this.beforeBody,m),f=o&&h!==`right`?a===`center`?c/2+l:c+2+l:0,y=0,x=r.length;y<x;++y){for(g=r[y],_=this.labelTextColors[y],t.fillStyle=_,Y(g.before,m),v=g.lines,o&&v.length&&(this._drawColorBox(t,e,y,p,n),d=Math.max(u.lineHeight,s)),b=0,S=v.length;b<S;++b)m(v[b]),d=u.lineHeight;Y(g.after,m)}f=0,d=u.lineHeight,Y(this.afterBody,m),e.y-=i}drawFooter(e,t,n){let r=this.footer,i=r.length,a,o;if(i){let s=jc(n.rtl,this.x,this.width);for(e.x=df(this,n.footerAlign,n),e.y+=n.footerMarginTop,t.textAlign=s.textAlign(n.footerAlign),t.textBaseline=`middle`,a=$(n.footerFont),t.fillStyle=n.footerColor,t.font=a.string,o=0;o<i;++o)t.fillText(r[o],s.x(e.x),e.y+a.lineHeight/2),e.y+=a.lineHeight+n.footerSpacing}}drawBackground(e,t,n,r){let{xAlign:i,yAlign:a}=this,{x:o,y:s}=e,{width:c,height:l}=n,{topLeft:u,topRight:d,bottomLeft:f,bottomRight:p}=Ws(r.cornerRadius);t.fillStyle=r.backgroundColor,t.strokeStyle=r.borderColor,t.lineWidth=r.borderWidth,t.beginPath(),t.moveTo(o+u,s),a===`top`&&this.drawCaret(e,t,n,r),t.lineTo(o+c-d,s),t.quadraticCurveTo(o+c,s,o+c,s+d),a===`center`&&i===`right`&&this.drawCaret(e,t,n,r),t.lineTo(o+c,s+l-p),t.quadraticCurveTo(o+c,s+l,o+c-p,s+l),a===`bottom`&&this.drawCaret(e,t,n,r),t.lineTo(o+f,s+l),t.quadraticCurveTo(o,s+l,o,s+l-f),a===`center`&&i===`left`&&this.drawCaret(e,t,n,r),t.lineTo(o,s+u),t.quadraticCurveTo(o,s,o+u,s),t.closePath(),t.fill(),r.borderWidth>0&&t.stroke()}_updateAnimationTarget(e){let t=this.chart,n=this.$animations,r=n&&n.x,i=n&&n.y;if(r||i){let n=Qd[e.position].call(this,this._active,this._eventPosition);if(!n)return;let a=this._size=nf(this,e),o=Object.assign({},n,this._size),s=sf(t,e,o),c=uf(e,o,s,t);(r._to!==c.x||i._to!==c.y)&&(this.xAlign=s.xAlign,this.yAlign=s.yAlign,this.width=a.width,this.height=a.height,this.caretX=n.x,this.caretY=n.y,this._resolveAnimations().update(this,c))}}_willRender(){return!!this.opacity}draw(e){let t=this.options.setContext(this.getContext()),n=this.opacity;if(!n)return;this._updateAnimationTarget(t);let r={width:this.width,height:this.height},i={x:this.x,y:this.y};n=Math.abs(n)<.001?0:n;let a=Q(t.padding),o=this.title.length||this.beforeBody.length||this.body.length||this.afterBody.length||this.footer.length;t.enabled&&o&&(e.save(),e.globalAlpha=n,this.drawBackground(i,e,r,t),Mc(e,t.textDirection),i.y+=a.top,this.drawTitle(i,e,t),this.drawBody(i,e,t),this.drawFooter(i,e,t),Nc(e,t.textDirection),e.restore())}getActiveElements(){return this._active||[]}setActiveElements(e,t){let n=this._active,r=e.map(({datasetIndex:e,index:t})=>{let n=this.chart.getDatasetMeta(e);if(!n)throw Error(`Cannot find a dataset at index `+e);return{datasetIndex:e,element:n.data[t],index:t}}),i=!$a(n,r),a=this._positionChanged(r,t);(i||a)&&(this._active=r,this._eventPosition=t,this._ignoreReplayEvents=!0,this.update(!0))}handleEvent(e,t,n=!0){if(t&&this._ignoreReplayEvents)return!1;this._ignoreReplayEvents=!1;let r=this.options,i=this._active||[],a=this._getActiveElements(e,i,t,n),o=this._positionChanged(a,e),s=t||!$a(a,i)||o;return s&&(this._active=a,(r.enabled||r.external)&&(this._eventPosition={x:e.x,y:e.y},this.update(!0,t))),s}_getActiveElements(e,t,n,r){let i=this.options;if(e.type===`mouseout`)return[];if(!r)return t.filter(e=>this.chart.data.datasets[e.datasetIndex]&&this.chart.getDatasetMeta(e.datasetIndex).controller.getParsed(e.index)!==void 0);let a=this.chart.getElementsAtEventForMode(e,i.mode,i,n);return i.reverse&&a.reverse(),a}_positionChanged(e,t){let{caretX:n,caretY:r,options:i}=this,a=Qd[i.position].call(this,e,t);return a!==!1&&(n!==a.x||r!==a.y)}},vf={id:`tooltip`,_element:_f,positioners:Qd,afterInit(e,t,n){n&&(e.tooltip=new _f({chart:e,options:n}))},beforeUpdate(e,t,n){e.tooltip&&e.tooltip.initialize(n)},reset(e,t,n){e.tooltip&&e.tooltip.initialize(n)},afterDraw(e){let t=e.tooltip;if(t&&t._willRender()){let n={tooltip:t};if(e.notifyPlugins(`beforeTooltipDraw`,{...n,cancelable:!0})===!1)return;t.draw(e.ctx),e.notifyPlugins(`afterTooltipDraw`,n)}},afterEvent(e,t){if(e.tooltip){let n=t.replay;e.tooltip.handleEvent(t.event,n,t.inChartArea)&&(t.changed=!0)}},defaults:{enabled:!0,external:null,position:`average`,backgroundColor:`rgba(0,0,0,0.8)`,titleColor:`#fff`,titleFont:{weight:`bold`},titleSpacing:2,titleMarginBottom:6,titleAlign:`left`,bodyColor:`#fff`,bodySpacing:2,bodyFont:{},bodyAlign:`left`,footerColor:`#fff`,footerSpacing:2,footerMarginTop:6,footerFont:{weight:`bold`},footerAlign:`left`,padding:6,caretPadding:2,caretSize:5,cornerRadius:6,boxHeight:(e,t)=>t.bodyFont.size,boxWidth:(e,t)=>t.bodyFont.size,multiKeyBackground:`#fff`,displayColors:!0,boxPadding:0,borderColor:`rgba(0,0,0,0)`,borderWidth:0,animation:{duration:400,easing:`easeOutQuart`},animations:{numbers:{type:`number`,properties:[`x`,`y`,`width`,`height`,`caretX`,`caretY`]},opacity:{easing:`linear`,duration:200}},callbacks:hf},defaultRoutes:{bodyFont:`font`,footerFont:`font`,titleFont:`font`},descriptors:{_scriptable:e=>e!==`filter`&&e!==`itemSort`&&e!==`external`,_indexable:!1,callbacks:{_scriptable:!1,_indexable:!1},animation:{_fallback:!1},animations:{_fallback:`animation`}},additionalOptionScopes:[`interaction`]},yf=(e,t,n,r)=>(typeof t==`string`?(n=e.push(t)-1,r.unshift({index:n,label:t})):isNaN(t)&&(n=null),n);function bf(e,t,n,r){let i=e.indexOf(t);return i===-1?yf(e,t,n,r):i===e.lastIndexOf(t)?i:n}var xf=(e,t)=>e===null?null:Ro(Math.round(e),0,t);function Sf(e){let t=this.getLabels();return e>=0&&e<t.length?t[e]:e}var Cf=class extends Uu{static id=`category`;static defaults={ticks:{callback:Sf}};constructor(e){super(e),this._startValue=void 0,this._valueRange=0,this._addedLabels=[]}init(e){let t=this._addedLabels;if(t.length){let e=this.getLabels();for(let{index:n,label:r}of t)e[n]===r&&e.splice(n,1);this._addedLabels=[]}super.init(e)}parse(e,t){if(U(e))return null;let n=this.getLabels();return t=isFinite(t)&&n[t]===e?t:bf(n,e,q(t,e),this._addedLabels),xf(t,n.length-1)}determineDataLimits(){let{minDefined:e,maxDefined:t}=this.getUserBounds(),{min:n,max:r}=this.getMinMax(!0);this.options.bounds===`ticks`&&(e||(n=0),t||(r=this.getLabels().length-1)),this.min=n,this.max=r}buildTicks(){let e=this.min,t=this.max,n=this.options.offset,r=[],i=this.getLabels();i=e===0&&t===i.length-1?i:i.slice(e,t+1),this._valueRange=Math.max(i.length-+!n,1),this._startValue=this.min-(n?.5:0);for(let n=e;n<=t;n++)r.push({value:n});return r}getLabelForValue(e){return Sf.call(this,e)}configure(){super.configure(),this.isHorizontal()||(this._reversePixels=!this._reversePixels)}getPixelForValue(e){return typeof e!=`number`&&(e=this.parse(e)),e===null?NaN:this.getPixelForDecimal((e-this._startValue)/this._valueRange)}getPixelForTick(e){let t=this.ticks;return e<0||e>t.length-1?null:this.getPixelForValue(t[e].value)}getValueForPixel(e){return Math.round(this._startValue+this.getDecimalForPixel(e)*this._valueRange)}getBasePixel(){return this.bottom}};function wf(e,t){let n=[],{bounds:r,step:i,min:a,max:o,precision:s,count:c,maxTicks:l,maxDigits:u,includeBounds:d}=e,f=i||1,p=l-1,{min:m,max:h}=t,g=!U(a),_=!U(o),v=!U(c),y=(h-m)/(u+1),b=To((h-m)/p/f)*f,x,S,C,w;if(b<1e-14&&!g&&!_)return[{value:m},{value:h}];w=Math.ceil(h/b)-Math.floor(m/b),w>p&&(b=To(w*b/p/f)*f),U(s)||(x=10**s,b=Math.ceil(b*x)/x),r===`ticks`?(S=Math.floor(m/b)*b,C=Math.ceil(h/b)*b):(S=m,C=h),g&&_&&i&&ko((o-a)/i,b/1e3)?(w=Math.round(Math.min((o-a)/b,l)),b=(o-a)/w,S=a,C=o):v?(S=g?a:S,C=_?o:C,w=c-1,b=(C-S)/w):(w=(C-S)/b,w=wo(w,Math.round(w),b/1e3)?Math.round(w):Math.ceil(w));let T=Math.max(No(b),No(S));x=10**(U(s)?T:s),S=Math.round(S*x)/x,C=Math.round(C*x)/x;let E=0;for(g&&(d&&S!==a?(n.push({value:a}),S<a&&E++,wo(Math.round((S+E*b)*x)/x,a,Tf(a,y,e))&&E++):S<a&&E++);E<w;++E){let e=Math.round((S+E*b)*x)/x;if(_&&e>o)break;n.push({value:e})}return _&&d&&C!==o?n.length&&wo(n[n.length-1].value,o,Tf(o,y,e))?n[n.length-1].value=o:n.push({value:o}):(!_||C===o)&&n.push({value:C}),n}function Tf(e,t,{horizontal:n,minRotation:r}){let i=jo(r),a=(n?Math.sin(i):Math.cos(i))||.001,o=.75*t*(``+e).length;return Math.min(t/a,o)}var Ef=class extends Uu{constructor(e){super(e),this.start=void 0,this.end=void 0,this._startValue=void 0,this._endValue=void 0,this._valueRange=0}parse(e,t){return U(e)||(typeof e==`number`||e instanceof Number)&&!isFinite(+e)?null:+e}handleTickRangeOptions(){let{beginAtZero:e}=this.options,{minDefined:t,maxDefined:n}=this.getUserBounds(),{min:r,max:i}=this,a=e=>r=t?r:e,o=e=>i=n?i:e;if(e){let e=Co(r),t=Co(i);e<0&&t<0?o(0):e>0&&t>0&&a(0)}if(r===i){let t=i===0?1:Math.abs(i*.05);o(i+t),e||a(r-t)}this.min=r,this.max=i}getTickLimit(){let{maxTicksLimit:e,stepSize:t}=this.options.ticks,n;return t?(n=Math.ceil(this.max/t)-Math.floor(this.min/t)+1,n>1e3&&(console.warn(`scales.${this.id}.ticks.stepSize: ${t} would result generating up to ${n} ticks. Limiting to 1000.`),n=1e3)):(n=this.computeTickLimit(),e||=11),e&&(n=Math.min(e,n)),n}computeTickLimit(){return 1/0}buildTicks(){let e=this.options,t=e.ticks,n=this.getTickLimit();n=Math.max(2,n);let r=wf({maxTicks:n,bounds:e.bounds,min:e.min,max:e.max,precision:t.precision,step:t.stepSize,count:t.count,maxDigits:this._maxDigits(),horizontal:this.isHorizontal(),minRotation:t.minRotation||0,includeBounds:t.includeBounds!==!1},this._range||this);return e.bounds===`ticks`&&Ao(r,this,`value`),e.reverse?(r.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),r}configure(){let e=this.ticks,t=this.min,n=this.max;if(super.configure(),this.options.offset&&e.length){let r=(n-t)/Math.max(e.length-1,1)/2;t-=r,n+=r}this._startValue=t,this._endValue=n,this._valueRange=n-t}getLabelForValue(e){return ms(e,this.chart.options.locale,this.options.ticks.format)}},Df=class extends Ef{static id=`linear`;static defaults={ticks:{callback:_s.formatters.numeric}};determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=K(e)?e:0,this.max=K(t)?t:1,this.handleTickRangeOptions()}computeTickLimit(){let e=this.isHorizontal(),t=e?this.width:this.height,n=jo(this.options.ticks.minRotation),r=(e?Math.sin(n):Math.cos(n))||.001,i=this._resolveTickFontOptions(0);return Math.ceil(t/Math.min(40,i.lineHeight/r))}getPixelForValue(e){return e===null?NaN:this.getPixelForDecimal((e-this._startValue)/this._valueRange)}getValueForPixel(e){return this._startValue+this.getDecimalForPixel(e)*this._valueRange}},Of=e=>Math.floor(So(e)),kf=(e,t)=>10**(Of(e)+t);function Af(e){return e/10**Of(e)==1}function jf(e,t,n){let r=10**n,i=Math.floor(e/r);return Math.ceil(t/r)-i}function Mf(e,t){let n=Of(t-e);for(;jf(e,t,n)>10;)n++;for(;jf(e,t,n)<10;)n--;return Math.min(n,Of(e))}function Nf(e,{min:t,max:n}){t=Za(e.min,t);let r=[],i=Of(t),a=Mf(t,n),o=a<0?10**Math.abs(a):1,s=10**a,c=i>a?10**i:0,l=Math.round((t-c)*o)/o,u=Math.floor((t-c)/s/10)*s*10,d=Math.floor((l-u)/10**a),f=Za(e.min,Math.round((c+u+d*10**a)*o)/o);for(;f<n;)r.push({value:f,major:Af(f),significand:d}),d>=10?d=d<15?15:20:d++,d>=20&&(a++,d=2,o=a>=0?1:o),f=Math.round((c+u+d*10**a)*o)/o;let p=Za(e.max,f);return r.push({value:p,major:Af(p),significand:d}),r}(class extends Uu{static id=`logarithmic`;static defaults={ticks:{callback:_s.formatters.logarithmic,major:{enabled:!0}}};constructor(e){super(e),this.start=void 0,this.end=void 0,this._startValue=void 0,this._valueRange=0}parse(e,t){let n=Ef.prototype.parse.apply(this,[e,t]);if(n===0){this._zero=!0;return}return K(n)&&n>0?n:null}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=K(e)?Math.max(0,e):null,this.max=K(t)?Math.max(0,t):null,this.options.beginAtZero&&(this._zero=!0),this._zero&&this.min!==this._suggestedMin&&!K(this._userMin)&&(this.min=e===kf(this.min,0)?kf(this.min,-1):kf(this.min,0)),this.handleTickRangeOptions()}handleTickRangeOptions(){let{minDefined:e,maxDefined:t}=this.getUserBounds(),n=this.min,r=this.max,i=t=>n=e?n:t,a=e=>r=t?r:e;n===r&&(n<=0?(i(1),a(10)):(i(kf(n,-1)),a(kf(r,1)))),n<=0&&i(kf(r,-1)),r<=0&&a(kf(n,1)),this.min=n,this.max=r}buildTicks(){let e=this.options,t=Nf({min:this._userMin,max:this._userMax},this);return e.bounds===`ticks`&&Ao(t,this,`value`),e.reverse?(t.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),t}getLabelForValue(e){return e===void 0?`0`:ms(e,this.chart.options.locale,this.options.ticks.format)}configure(){let e=this.min;super.configure(),this._startValue=So(e),this._valueRange=So(this.max)-So(e)}getPixelForValue(e){return(e===void 0||e===0)&&(e=this.min),e===null||isNaN(e)?NaN:this.getPixelForDecimal(e===this.min?0:(So(e)-this._startValue)/this._valueRange)}getValueForPixel(e){let t=this.getDecimalForPixel(e);return 10**(this._startValue+t*this._valueRange)}});function Pf(e){let t=e.ticks;if(t.display&&e.display){let e=Q(t.backdropPadding);return q(t.font&&t.font.size,Z.font.size)+e.height}return 0}function Ff(e,t,n){return n=W(n)?n:[n],{w:Ts(e,t.string,n),h:n.length*t.lineHeight}}function If(e,t,n,r,i){return e===r||e===i?{start:t-n/2,end:t+n/2}:e<r||e>i?{start:t-n,end:t}:{start:t,end:t+n}}function Lf(e){let t={l:e.left+e._padding.left,r:e.right-e._padding.right,t:e.top+e._padding.top,b:e.bottom-e._padding.bottom},n=Object.assign({},t),r=[],i=[],a=e._pointLabels.length,o=e.options.pointLabels,s=o.centerPointLabels?X/a:0;for(let c=0;c<a;c++){let a=o.setContext(e.getPointLabelContext(c));i[c]=a.padding;let l=e.getPointPosition(c,e.drawingArea+i[c],s),u=$(a.font),d=Ff(e.ctx,u,e._pointLabels[c]);r[c]=d;let f=Io(e.getIndexAngle(c)+s),p=Math.round(Mo(f));Rf(n,t,f,If(p,l.x,d.w,0,180),If(p,l.y,d.h,90,270))}e.setCenterPoint(t.l-n.l,n.r-t.r,t.t-n.t,n.b-t.b),e._pointLabelItems=Vf(e,r,i)}function Rf(e,t,n,r,i){let a=Math.abs(Math.sin(n)),o=Math.abs(Math.cos(n)),s=0,c=0;r.start<t.l?(s=(t.l-r.start)/a,e.l=Math.min(e.l,t.l-s)):r.end>t.r&&(s=(r.end-t.r)/a,e.r=Math.max(e.r,t.r+s)),i.start<t.t?(c=(t.t-i.start)/o,e.t=Math.min(e.t,t.t-c)):i.end>t.b&&(c=(i.end-t.b)/o,e.b=Math.max(e.b,t.b+c))}function zf(e,t,n){let r=e.drawingArea,{extra:i,additionalAngle:a,padding:o,size:s}=n,c=e.getPointPosition(t,r+i+o,a),l=Math.round(Mo(Io(c.angle+yo))),u=Wf(c.y,s.h,l),d=Hf(l),f=Uf(c.x,s.w,d);return{visible:!0,x:c.x,y:u,textAlign:d,left:f,top:u,right:f+s.w,bottom:u+s.h}}function Bf(e,t){if(!t)return!0;let{left:n,top:r,right:i,bottom:a}=e;return!(As({x:n,y:r},t)||As({x:n,y:a},t)||As({x:i,y:r},t)||As({x:i,y:a},t))}function Vf(e,t,n){let r=[],i=e._pointLabels.length,a=e.options,{centerPointLabels:o,display:s}=a.pointLabels,c={extra:Pf(a)/2,additionalAngle:o?X/i:0},l;for(let a=0;a<i;a++){c.padding=n[a],c.size=t[a];let i=zf(e,a,c);r.push(i),s===`auto`&&(i.visible=Bf(i,l),i.visible&&(l=i))}return r}function Hf(e){return e===0||e===180?`center`:e<180?`left`:`right`}function Uf(e,t,n){return n===`right`?e-=t:n===`center`&&(e-=t/2),e}function Wf(e,t,n){return n===90||n===270?e-=t/2:(n>270||n<90)&&(e-=t),e}function Gf(e,t,n){let{left:r,top:i,right:a,bottom:o}=n,{backdropColor:s}=t;if(!U(s)){let n=Ws(t.borderRadius),c=Q(t.backdropPadding);e.fillStyle=s;let l=r-c.left,u=i-c.top,d=a-r+c.width,f=o-i+c.height;Object.values(n).some(e=>e!==0)?(e.beginPath(),Ls(e,{x:l,y:u,w:d,h:f,radius:n}),e.fill()):e.fillRect(l,u,d,f)}}function Kf(e,t){let{ctx:n,options:{pointLabels:r}}=e;for(let i=t-1;i>=0;i--){let t=e._pointLabelItems[i];if(!t.visible)continue;let a=r.setContext(e.getPointLabelContext(i));Gf(n,a,t);let o=$(a.font),{x:s,y:c,textAlign:l}=t;Is(n,e._pointLabels[i],s,c+o.lineHeight/2,o,{color:a.color,textAlign:l,textBaseline:`middle`})}}function qf(e,t,n,r){let{ctx:i}=e;if(n)i.arc(e.xCenter,e.yCenter,t,0,go);else{let n=e.getPointPosition(0,t);i.moveTo(n.x,n.y);for(let a=1;a<r;a++)n=e.getPointPosition(a,t),i.lineTo(n.x,n.y)}}function Jf(e,t,n,r,i){let a=e.ctx,o=t.circular,{color:s,lineWidth:c}=t;!o&&!r||!s||!c||n<0||(a.save(),a.strokeStyle=s,a.lineWidth=c,a.setLineDash(i.dash||[]),a.lineDashOffset=i.dashOffset,a.beginPath(),qf(e,n,o,r),a.closePath(),a.stroke(),a.restore())}function Yf(e,t,n){return qs(e,{label:n,index:t,type:`pointLabel`})}(class extends Ef{static id=`radialLinear`;static defaults={display:!0,animate:!0,position:`chartArea`,angleLines:{display:!0,lineWidth:1,borderDash:[],borderDashOffset:0},grid:{circular:!1},startAngle:0,ticks:{showLabelBackdrop:!0,callback:_s.formatters.numeric},pointLabels:{backdropColor:void 0,backdropPadding:2,display:!0,font:{size:10},callback(e){return e},padding:5,centerPointLabels:!1}};static defaultRoutes={"angleLines.color":`borderColor`,"pointLabels.color":`color`,"ticks.color":`color`};static descriptors={angleLines:{_fallback:`grid`}};constructor(e){super(e),this.xCenter=void 0,this.yCenter=void 0,this.drawingArea=void 0,this._pointLabels=[],this._pointLabelItems=[]}setDimensions(){let e=this._padding=Q(Pf(this.options)/2),t=this.width=this.maxWidth-e.width,n=this.height=this.maxHeight-e.height;this.xCenter=Math.floor(this.left+t/2+e.left),this.yCenter=Math.floor(this.top+n/2+e.top),this.drawingArea=Math.floor(Math.min(t,n)/2)}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!1);this.min=K(e)&&!isNaN(e)?e:0,this.max=K(t)&&!isNaN(t)?t:0,this.handleTickRangeOptions()}computeTickLimit(){return Math.ceil(this.drawingArea/Pf(this.options))}generateTickLabels(e){Ef.prototype.generateTickLabels.call(this,e),this._pointLabels=this.getLabels().map((e,t)=>{let n=J(this.options.pointLabels.callback,[e,t],this);return n||n===0?n:``}).filter((e,t)=>this.chart.getDataVisibility(t))}fit(){let e=this.options;e.display&&e.pointLabels.display?Lf(this):this.setCenterPoint(0,0,0,0)}setCenterPoint(e,t,n,r){this.xCenter+=Math.floor((e-t)/2),this.yCenter+=Math.floor((n-r)/2),this.drawingArea-=Math.min(this.drawingArea/2,Math.max(e,t,n,r))}getIndexAngle(e){let t=go/(this._pointLabels.length||1),n=this.options.startAngle||0;return Io(e*t+jo(n))}getDistanceFromCenterForValue(e){if(U(e))return NaN;let t=this.drawingArea/(this.max-this.min);return this.options.reverse?(this.max-e)*t:(e-this.min)*t}getValueForDistanceFromCenter(e){if(U(e))return NaN;let t=e/(this.drawingArea/(this.max-this.min));return this.options.reverse?this.max-t:this.min+t}getPointLabelContext(e){let t=this._pointLabels||[];if(e>=0&&e<t.length){let n=t[e];return Yf(this.getContext(),e,n)}}getPointPosition(e,t,n=0){let r=this.getIndexAngle(e)-yo+n;return{x:Math.cos(r)*t+this.xCenter,y:Math.sin(r)*t+this.yCenter,angle:r}}getPointPositionForValue(e,t){return this.getPointPosition(e,this.getDistanceFromCenterForValue(t))}getBasePosition(e){return this.getPointPositionForValue(e||0,this.getBaseValue())}getPointLabelPosition(e){let{left:t,top:n,right:r,bottom:i}=this._pointLabelItems[e];return{left:t,top:n,right:r,bottom:i}}drawBackground(){let{backgroundColor:e,grid:{circular:t}}=this.options;if(e){let n=this.ctx;n.save(),n.beginPath(),qf(this,this.getDistanceFromCenterForValue(this._endValue),t,this._pointLabels.length),n.closePath(),n.fillStyle=e,n.fill(),n.restore()}}drawGrid(){let e=this.ctx,t=this.options,{angleLines:n,grid:r,border:i}=t,a=this._pointLabels.length,o,s,c;if(t.pointLabels.display&&Kf(this,a),r.display&&this.ticks.forEach((e,t)=>{if(t!==0||t===0&&this.min<0){s=this.getDistanceFromCenterForValue(e.value);let n=this.getContext(t),o=r.setContext(n),c=i.setContext(n);Jf(this,o,s,a,c)}}),n.display){for(e.save(),o=a-1;o>=0;o--){let r=n.setContext(this.getPointLabelContext(o)),{color:i,lineWidth:a}=r;!a||!i||(e.lineWidth=a,e.strokeStyle=i,e.setLineDash(r.borderDash),e.lineDashOffset=r.borderDashOffset,s=this.getDistanceFromCenterForValue(t.reverse?this.min:this.max),c=this.getPointPosition(o,s),e.beginPath(),e.moveTo(this.xCenter,this.yCenter),e.lineTo(c.x,c.y),e.stroke())}e.restore()}}drawBorder(){}drawLabels(){let e=this.ctx,t=this.options,n=t.ticks;if(!n.display)return;let r=this.getIndexAngle(0),i,a;e.save(),e.translate(this.xCenter,this.yCenter),e.rotate(r),e.textAlign=`center`,e.textBaseline=`middle`,this.ticks.forEach((r,o)=>{if(o===0&&this.min>=0&&!t.reverse)return;let s=n.setContext(this.getContext(o)),c=$(s.font);if(i=this.getDistanceFromCenterForValue(this.ticks[o].value),s.showLabelBackdrop){e.font=c.string,a=e.measureText(r.label).width,e.fillStyle=s.backdropColor;let t=Q(s.backdropPadding);e.fillRect(-a/2-t.left,-i-c.size/2-t.top,a+t.width,c.size+t.height)}Is(e,r.label,0,-i,c,{color:s.color,strokeColor:s.textStrokeColor,strokeWidth:s.textStrokeWidth})}),e.restore()}drawTitle(){}});var Xf={millisecond:{common:!0,size:1,steps:1e3},second:{common:!0,size:1e3,steps:60},minute:{common:!0,size:6e4,steps:60},hour:{common:!0,size:36e5,steps:24},day:{common:!0,size:864e5,steps:30},week:{common:!1,size:6048e5,steps:4},month:{common:!0,size:2628e6,steps:12},quarter:{common:!1,size:7884e6,steps:4},year:{common:!0,size:3154e7}},Zf=Object.keys(Xf);function Qf(e,t){return e-t}function $f(e,t){if(U(t))return null;let n=e._adapter,{parser:r,round:i,isoWeekday:a}=e._parseOpts,o=t;return typeof r==`function`&&(o=r(o)),K(o)||(o=typeof r==`string`?n.parse(o,r):n.parse(o)),o===null?null:(i&&(o=i===`week`&&(Oo(a)||a===!0)?n.startOf(o,`isoWeek`,a):n.startOf(o,i)),+o)}function ep(e,t,n,r){let i=Zf.length;for(let a=Zf.indexOf(e);a<i-1;++a){let e=Xf[Zf[a]],i=e.steps?e.steps:2**53-1;if(e.common&&Math.ceil((n-t)/(i*e.size))<=r)return Zf[a]}return Zf[i-1]}function tp(e,t,n,r,i){for(let a=Zf.length-1;a>=Zf.indexOf(n);a--){let n=Zf[a];if(Xf[n].common&&e._adapter.diff(i,r,n)>=t-1)return n}return Zf[n?Zf.indexOf(n):0]}function np(e){for(let t=Zf.indexOf(e)+1,n=Zf.length;t<n;++t)if(Xf[Zf[t]].common)return Zf[t]}function rp(e,t,n){if(!n)e[t]=!0;else if(n.length){let{lo:r,hi:i}=Vo(n,t),a=n[r]>=t?n[r]:n[i];e[a]=!0}}function ip(e,t,n,r){let i=e._adapter,a=+i.startOf(t[0].value,r),o=t[t.length-1].value,s,c;for(s=a;s<=o;s=+i.add(s,1,r))c=n[s],c>=0&&(t[c].major=!0);return t}function ap(e,t,n){let r=[],i={},a=t.length,o,s;for(o=0;o<a;++o)s=t[o],i[s]=o,r.push({value:s,major:!1});return a===0||!n?r:ip(e,r,i,n)}var op=class extends Uu{static id=`time`;static defaults={bounds:`data`,adapters:{},time:{parser:!1,unit:!1,round:!1,isoWeekday:!1,minUnit:`millisecond`,displayFormats:{}},ticks:{source:`auto`,callback:!1,major:{enabled:!1}}};constructor(e){super(e),this._cache={data:[],labels:[],all:[]},this._unit=`day`,this._majorUnit=void 0,this._offsets={},this._normalized=!1,this._parseOpts=void 0}init(e,t={}){let n=e.time||={},r=this._adapter=new Dl._date(e.adapters.date);r.init(t),io(n.displayFormats,r.formats()),this._parseOpts={parser:n.parser,round:n.round,isoWeekday:n.isoWeekday},super.init(e),this._normalized=t.normalized}parse(e,t){return e===void 0?null:$f(this,e)}beforeLayout(){super.beforeLayout(),this._cache={data:[],labels:[],all:[]}}determineDataLimits(){let e=this.options,t=this._adapter,n=e.time.unit||`day`,{min:r,max:i,minDefined:a,maxDefined:o}=this.getUserBounds();function s(e){!a&&!isNaN(e.min)&&(r=Math.min(r,e.min)),!o&&!isNaN(e.max)&&(i=Math.max(i,e.max))}(!a||!o)&&(s(this._getLabelBounds()),(e.bounds!==`ticks`||e.ticks.source!==`labels`)&&s(this.getMinMax(!1))),r=K(r)&&!isNaN(r)?r:+t.startOf(Date.now(),n),i=K(i)&&!isNaN(i)?i:+t.endOf(Date.now(),n)+1,this.min=Math.min(r,i-1),this.max=Math.max(r+1,i)}_getLabelBounds(){let e=this.getLabelTimestamps(),t=1/0,n=-1/0;return e.length&&(t=e[0],n=e[e.length-1]),{min:t,max:n}}buildTicks(){let e=this.options,t=e.time,n=e.ticks,r=n.source===`labels`?this.getLabelTimestamps():this._generate();e.bounds===`ticks`&&r.length&&(this.min=this._userMin||r[0],this.max=this._userMax||r[r.length-1]);let i=this.min,a=this.max,o=Wo(r,i,a);return this._unit=t.unit||(n.autoSkip?ep(t.minUnit,this.min,this.max,this._getLabelCapacity(i)):tp(this,o.length,t.minUnit,this.min,this.max)),this._majorUnit=!n.major.enabled||this._unit===`year`?void 0:np(this._unit),this.initOffsets(r),e.reverse&&o.reverse(),ap(this,o,this._majorUnit)}afterAutoSkip(){this.options.offsetAfterAutoskip&&this.initOffsets(this.ticks.map(e=>+e.value))}initOffsets(e=[]){let t=0,n=0,r,i;this.options.offset&&e.length&&(r=this.getDecimalForValue(e[0]),t=e.length===1?1-r:(this.getDecimalForValue(e[1])-r)/2,i=this.getDecimalForValue(e[e.length-1]),n=e.length===1?i:(i-this.getDecimalForValue(e[e.length-2]))/2);let a=e.length<3?.5:.25;t=Ro(t,0,a),n=Ro(n,0,a),this._offsets={start:t,end:n,factor:1/(t+1+n)}}_generate(){let e=this._adapter,t=this.min,n=this.max,r=this.options,i=r.time,a=i.unit||ep(i.minUnit,t,n,this._getLabelCapacity(t)),o=q(r.ticks.stepSize,1),s=a===`week`&&i.isoWeekday,c=Oo(s)||s===!0,l={},u=t,d,f;if(c&&(u=+e.startOf(u,`isoWeek`,s)),u=+e.startOf(u,c?`day`:a),e.diff(n,t,a)>1e5*o)throw Error(t+` and `+n+` are too far apart with stepSize of `+o+` `+a);let p=r.ticks.source===`data`&&this.getDataTimestamps();for(d=u,f=0;d<n;d=+e.add(d,o,a),f++)rp(l,d,p);return(d===n||r.bounds===`ticks`||f===1)&&rp(l,d,p),Object.keys(l).sort(Qf).map(e=>+e)}getLabelForValue(e){let t=this._adapter,n=this.options.time;return n.tooltipFormat?t.format(e,n.tooltipFormat):t.format(e,n.displayFormats.datetime)}format(e,t){let n=this.options.time.displayFormats,r=this._unit,i=t||n[r];return this._adapter.format(e,i)}_tickFormatFunction(e,t,n,r){let i=this.options,a=i.ticks.callback;if(a)return J(a,[e,t,n],this);let o=i.time.displayFormats,s=this._unit,c=this._majorUnit,l=s&&o[s],u=c&&o[c],d=n[t],f=c&&u&&d&&d.major;return this._adapter.format(e,r||(f?u:l))}generateTickLabels(e){let t,n,r;for(t=0,n=e.length;t<n;++t)r=e[t],r.label=this._tickFormatFunction(r.value,t,e)}getDecimalForValue(e){return e===null?NaN:(e-this.min)/(this.max-this.min)}getPixelForValue(e){let t=this._offsets,n=this.getDecimalForValue(e);return this.getPixelForDecimal((t.start+n)*t.factor)}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return this.min+n*(this.max-this.min)}_getLabelSize(e){let t=this.options.ticks,n=this.ctx.measureText(e).width,r=jo(this.isHorizontal()?t.maxRotation:t.minRotation),i=Math.cos(r),a=Math.sin(r),o=this._resolveTickFontOptions(0).size;return{w:n*i+o*a,h:n*a+o*i}}_getLabelCapacity(e){let t=this.options.time,n=t.displayFormats,r=n[t.unit]||n.millisecond,i=this._tickFormatFunction(e,0,ap(this,[e],this._majorUnit),r),a=this._getLabelSize(i),o=Math.floor(this.isHorizontal()?this.width/a.w:this.height/a.h)-1;return o>0?o:1}getDataTimestamps(){let e=this._cache.data||[],t,n;if(e.length)return e;let r=this.getMatchingVisibleMetas();if(this._normalized&&r.length)return this._cache.data=r[0].controller.getAllParsedValues(this);for(t=0,n=r.length;t<n;++t)e=e.concat(r[t].controller.getAllParsedValues(this));return this._cache.data=this.normalize(e)}getLabelTimestamps(){let e=this._cache.labels||[],t,n;if(e.length)return e;let r=this.getLabels();for(t=0,n=r.length;t<n;++t)e.push($f(this,r[t]));return this._cache.labels=this._normalized?e:this.normalize(e)}normalize(e){return Jo(e.sort(Qf))}};function sp(e,t,n){let r=0,i=e.length-1,a,o,s,c;n?(t>=e[r].pos&&t<=e[i].pos&&({lo:r,hi:i}=Ho(e,`pos`,t)),{pos:a,time:s}=e[r],{pos:o,time:c}=e[i]):(t>=e[r].time&&t<=e[i].time&&({lo:r,hi:i}=Ho(e,`time`,t)),{time:a,pos:s}=e[r],{time:o,pos:c}=e[i]);let l=o-a;return l?s+(c-s)*(t-a)/l:s}(class extends op{static id=`timeseries`;static defaults=op.defaults;constructor(e){super(e),this._table=[],this._minPos=void 0,this._tableRange=void 0}initOffsets(){let e=this._getTimestampsForTable(),t=this._table=this.buildLookupTable(e);this._minPos=sp(t,this.min),this._tableRange=sp(t,this.max)-this._minPos,super.initOffsets(e)}buildLookupTable(e){let{min:t,max:n}=this,r=[],i=[],a,o,s,c,l;for(a=0,o=e.length;a<o;++a)c=e[a],c>=t&&c<=n&&r.push(c);if(r.length<2)return[{time:t,pos:0},{time:n,pos:1}];for(a=0,o=r.length;a<o;++a)l=r[a+1],s=r[a-1],c=r[a],Math.round((l+s)/2)!==c&&i.push({time:c,pos:a/(o-1)});return i}_generate(){let e=this.min,t=this.max,n=super.getDataTimestamps();return(!n.includes(e)||!n.length)&&n.splice(0,0,e),(!n.includes(t)||n.length===1)&&n.push(t),n.sort((e,t)=>e-t)}_getTimestampsForTable(){let e=this._cache.all||[];if(e.length)return e;let t=this.getDataTimestamps(),n=this.getLabelTimestamps();return e=t.length&&n.length?this.normalize(t.concat(n)):t.length?t:n,e=this._cache.all=e,e}getDecimalForValue(e){return(sp(this._table,e)-this._minPos)/this._tableRange}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return sp(this._table,n*this._tableRange+this._minPos,!0)}});var cp={data:{type:Object,required:!0},options:{type:Object,default:()=>({})},plugins:{type:Array,default:()=>[]},datasetIdKey:{type:String,default:`label`},updateMode:{type:String,default:void 0}},lp={ariaLabel:{type:String},ariaDescribedby:{type:String}},up={type:{type:String,required:!0},destroyDelay:{type:Number,default:0},...cp,...lp},dp=(e,t)=>Object.assign(e,t);function fp(e){return c(e)?O(e):e}function pp(e){let t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:e;return c(t)?new Proxy(e,{}):e}function mp(e,t){let n=e.options;n&&t&&Object.assign(n,t)}function hp(e,t){e.labels=t}function gp(e,t,n){let r=[];e.datasets=t.map(t=>{let i=e.datasets.find(e=>e[n]===t[n]);return!i||!t.data||r.includes(i)?{...t}:(r.push(i),Object.assign(i,t),i)})}function _p(e,t){let n={labels:[],datasets:[]};return hp(n,e.labels),gp(n,e.datasets,t),n}var vp=R({props:up,setup(e,t){let{expose:n,slots:r}=t,i=F(null),a=w(null);n({chart:a});let o=()=>{if(!i.value)return;let{type:t,data:n,options:r,plugins:o,datasetIdKey:s}=e,c=pp(_p(n,s),n);a.value=new jd(i.value,{type:t,data:c,options:{...r},plugins:o})},s=()=>{let t=O(a.value);t&&(e.destroyDelay>0?setTimeout(()=>{t.destroy(),a.value=null},e.destroyDelay):(t.destroy(),a.value=null))},c=t=>{t.update(e.updateMode)};return Me(o),we(s),V([()=>e.options,()=>e.data],(t,n)=>{let[r,i]=t,[o,s]=n,l=O(a.value);if(!l)return;let u=!1;if(r){let e=fp(r),t=fp(o);e&&e!==t&&(mp(l,e),u=!0)}if(i){let t=fp(i.labels),n=fp(s.labels),r=fp(i.datasets),a=fp(s.datasets);t!==n&&(hp(l.config.data,t),u=!0),r&&r!==a&&(gp(l.config.data,r,e.datasetIdKey),u=!0)}u&&xe(()=>{c(l)})},{deep:!0}),()=>Ae(`canvas`,{role:`img`,"aria-label":e.ariaLabel,"aria-describedby":e.ariaDescribedby,ref:i},[Ae(`p`,{},[r.default?r.default():``])])}});function yp(e,t){return jd.register(t),R({props:cp,setup(t,n){let{expose:r}=n,i=w(null),a=w(null);V(()=>a.value?.chart??null,e=>{i.value=e},{flush:`sync`}),r({chart:i});let o=e=>{a.value=e};return()=>Ae(vp,dp({ref:o},{type:e,...t}))}})}var bp=yp(`bar`,Tl);jd.register(Tl,Hd,Cf,Df,Zd,vf);function xp(){let e=F(``),t=F(``),n=F(``);function r(){let r=getComputedStyle(document.documentElement);e.value=r.getPropertyValue(`--foreground`).trim(),t.value=r.getPropertyValue(`--muted-foreground`).trim(),n.value=r.getPropertyValue(`--border`).trim()}let i;return Me(()=>{r(),i=window.matchMedia(`(prefers-color-scheme: dark)`),i.addEventListener(`change`,r)}),Ie(()=>{i?.removeEventListener(`change`,r)}),{foreground:e,mutedForeground:t,border:n}}var Sp={cost:`Cost`,req:`Requests`,tokin:`Tokens in`,tokout:`Tokens out`},Cp=20,wp=100,Tp=3e4,Ep={hour:24,day:30,month:12},Dp={hour:`24h`,day:`30d`,month:`12mo`};function Op(e){switch(e){case`requests`:return[`req`];case`tokens`:return[`tokin`,`tokout`];case`cost`:return[`cost`];case`models`:return[]}}var kp=de(`history`,{state:()=>({scope:`total`,window:`hour`,tab:`requests`,modelMetric:`cost`,seriesByMetric:{},modelRanking:[],modelOptions:[],loading:!1,error:``,timer:void 0}),actions:{setScope(e){e!==this.scope&&(this.scope=e,this.refresh())},setWindow(e){e!==this.window&&(this.window=e,this.refresh())},setTab(e){e!==this.tab&&(this.tab=e,this.refresh())},setModelMetric(e){e!==this.modelMetric&&(this.modelMetric=e,this.refresh())},async refresh(){await Promise.all([this.tab===`models`?this.fetchModelRanking():this.fetchSeries(),this.fetchModelOptions()])},async fetchSeries(){if(je().isAuthenticated){this.loading=!0;try{let e=Ep[this.window],t=Op(this.tab),n=await Promise.all(t.map(t=>Fe(`/admin/api/usage/history?scope=${encodeURIComponent(this.scope)}&metric=${t}&window=${this.window}&span=${e}`))),r={};t.forEach((e,t)=>{r[e]=n[t].points}),this.seriesByMetric=r,this.error=``}catch(e){if(e instanceof be&&(e.status===401||e.status===403))return;this.error=e instanceof Error?e.message:String(e)}finally{this.loading=!1}}},async fetchModelRanking(){if(je().isAuthenticated){this.loading=!0;try{let e=await Fe(`/admin/api/usage/models?metric=${this.modelMetric}&window=${this.window}&limit=${Cp}`);this.modelRanking=e.models,this.error=``}catch(e){if(e instanceof be&&(e.status===401||e.status===403))return;this.error=e instanceof Error?e.message:String(e)}finally{this.loading=!1}}},async fetchModelOptions(){if(je().isAuthenticated)try{let e=await Fe(`/admin/api/usage/models?metric=req&window=${this.window}&limit=${wp}`);this.modelOptions=e.models}catch{}},startAutoRefresh(){this.timer===void 0&&(this.timer=setInterval(()=>void this.refresh(),Tp))},stopAutoRefresh(){this.timer!==void 0&&(clearInterval(this.timer),this.timer=void 0)}}}),Ap={key:0,class:`py-8 text-center text-sm text-muted-foreground`},jp=R({__name:`ModelUsageChart`,props:{metric:{},models:{}},setup(e){let t=e,{foreground:n,mutedForeground:r,border:a}=xp(),o={req:`--chart-requests`,tokin:`--chart-tokens-in`,tokout:`--chart-tokens-out`,cost:`--chart-cost`};function s(e,t){return e===`cost`?t/1e6:t}function c(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let l=M(()=>(n.value,{labels:t.models.map(e=>e.id),datasets:[{label:Sp[t.metric],backgroundColor:c(o[t.metric]),data:t.models.map(e=>s(t.metric,e.value))}]})),u=M(()=>`${Math.max(180,t.models.length*28+60)}px`),d=M(()=>({indexAxis:`y`,responsive:!0,maintainAspectRatio:!1,animation:!1,scales:{x:{beginAtZero:!0,grid:{color:a.value},ticks:{color:r.value,callback:e=>t.metric===`cost`?`$${e}`:ke(Number(e))}},y:{grid:{display:!1},ticks:{color:r.value,autoSkip:!1}}},plugins:{legend:{display:!1},tooltip:{callbacks:{label:e=>{let n=e.parsed.x??0;return t.metric===`cost`?`${Sp[t.metric]}: $${n.toFixed(4)}`:`${Sp[t.metric]}: ${ke(n)} (${Ue(n)})`}}}}}));return(t,n)=>e.models.length===0?(N(),P(`p`,Ap,` No model recorded any usage in this window. `)):(N(),P(`div`,{key:1,class:`w-full`,style:i({height:u.value})},[L(b(bp),{data:l.value,options:d.value},null,8,[`data`,`options`])],4))}}),Mp={class:`h-72 w-full`},Np=R({__name:`UsageChart`,props:{tab:{},window:{},seriesByMetric:{}},setup(e){let t=e,{foreground:n,mutedForeground:r,border:i}=xp(),a={requests:[{metric:`req`,label:`Requests`,color:`--chart-requests`}],tokens:[{metric:`tokin`,label:`Tokens in`,color:`--chart-tokens-in`},{metric:`tokout`,label:`Tokens out`,color:`--chart-tokens-out`}],cost:[{metric:`cost`,label:`Cost (USD)`,color:`--chart-cost`}]};function o(e,t){return e===`cost`?t/1e6:t}let s=M(()=>{let e=a[t.tab],n=new Set;for(let r of e)for(let e of t.seriesByMetric[r.metric]??[])n.add(e.bucket);return Array.from(n).sort()}),c=M(()=>s.value.map(e=>_e(e,t.window)));function l(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let u=M(()=>{n.value;let e=s.value;return{labels:c.value,datasets:a[t.tab].map(n=>{let r=new Map((t.seriesByMetric[n.metric]??[]).map(e=>[e.bucket,e.value]));return{label:n.label,backgroundColor:l(n.color),data:e.map(e=>o(n.metric,r.get(e)??0))}})}}),d=M(()=>a[t.tab].length>1),f=M(()=>({responsive:!0,maintainAspectRatio:!1,animation:!1,scales:{x:{stacked:d.value,grid:{color:i.value,display:!1},ticks:{color:r.value}},y:{stacked:d.value,beginAtZero:!0,grid:{color:i.value},ticks:{color:r.value,callback:e=>t.tab===`cost`?`$${e}`:ke(Number(e))}}},plugins:{legend:{display:d.value,labels:{color:n.value}},tooltip:{callbacks:{label:e=>{let n=e.parsed.y??0;return t.tab===`cost`?`${e.dataset.label}: $${n.toFixed(4)}`:`${e.dataset.label}: ${ke(n)} (${Ue(n)})`}}}}}));return(e,t)=>(N(),P(`div`,Mp,[L(b(bp),{data:u.value,options:f.value},null,8,[`data`,`options`])]))}}),Pp={class:`flex flex-wrap items-center gap-3`},Fp={key:0,class:`text-sm text-destructive`},Ip={class:`text-sm text-muted-foreground`},Lp=R({__name:`ChartsView`,setup(e){let t=ye(),n=kp(),{query:r,normalized:i,hasQuery:a}=Pe(),o=M(()=>{let e=t.usage?.users??[],r=t.usage?.groups??[],o=e.filter(e=>!a.value||Ne(e,i.value)||`user:${e.id}`===n.scope).map(e=>({value:`user:${e.id}`,label:e.id})),s=r.filter(t=>!a.value||Ve(t,e,i.value)||`group:${t.id}`===n.scope).map(e=>({value:`group:${e.id}`,label:e.id})),c=(n.modelOptions??[]).filter(e=>!a.value||e.id.toLowerCase().includes(i.value)||`model:${e.id}`===n.scope).map(e=>({value:`model:${e.id}`,label:e.id}));return n.scope.startsWith(`model:`)&&!c.some(e=>e.value===n.scope)&&c.push({value:n.scope,label:n.scope.slice(6)}),[{value:`total`,label:`Total (all traffic)`},...s,...o,...c]}),s=[`hour`,`day`,`month`],c=[`cost`,`req`,`tokin`,`tokout`],l=M(()=>n.tab===`models`?`requests`:n.tab);function u(e){n.setTab(e)}function d(e){typeof e==`string`&&n.setScope(e)}function f(e){typeof e==`string`&&n.setModelMetric(e)}return Me(()=>{n.refresh(),n.startAutoRefresh()}),we(()=>{n.stopAutoRefresh()}),V(o,e=>{e.some(e=>e.value===n.scope)||n.setScope(`total`)}),(e,t)=>(N(),I(b(Ge),null,{default:B(()=>[L(b(Se),{class:`flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between`},{default:B(()=>[L(b(Ce),null,{default:B(()=>[...t[2]||=[ge(`Usage charts`,-1)]]),_:1}),He(`div`,Pp,[L(Be,{modelValue:b(r),"onUpdate:modelValue":t[0]||=e=>E(r)?r.value=e:null,placeholder:`Filter users, groups or models`,class:`w-56`},null,8,[`modelValue`]),b(n).tab===`models`?(N(),I(b(Xi),{key:0,"model-value":b(n).modelMetric,"onUpdate:modelValue":f},{default:B(()=>[L(b(na),{class:`w-40`,"aria-label":`Rank models by`},{default:B(()=>[L(b(ra),{placeholder:`Rank by`})]),_:1}),L(b(Zi),null,{default:B(()=>[(N(),P(k,null,me(c,e=>L(b($i),{key:e,value:e},{default:B(()=>[ge(ce(b(Sp)[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`])):(N(),I(b(Xi),{key:1,"model-value":b(n).scope,"onUpdate:modelValue":d},{default:B(()=>[L(b(na),{class:`w-56`},{default:B(()=>[L(b(ra),{placeholder:`Scope`})]),_:1}),L(b(Zi),null,{default:B(()=>[(N(!0),P(k,null,me(o.value,e=>(N(),I(b($i),{key:e.value,value:e.value},{default:B(()=>[ge(ce(e.label),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])),L(b(he),{"model-value":b(n).window,"onUpdate:modelValue":t[1]||=e=>b(n).setWindow(e)},{default:B(()=>[L(b(Te),null,{default:B(()=>[(N(),P(k,null,me(s,e=>L(b(Re),{key:e,value:e},{default:B(()=>[ge(ce(b(Dp)[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`])])]),_:1}),L(b(pe),{class:`flex flex-col gap-4`},{default:B(()=>[L(b(he),{"model-value":b(n).tab,"onUpdate:modelValue":u},{default:B(()=>[L(b(Te),null,{default:B(()=>[L(b(Re),{value:`requests`},{default:B(()=>[...t[3]||=[ge(`Requests`,-1)]]),_:1}),L(b(Re),{value:`tokens`},{default:B(()=>[...t[4]||=[ge(`Tokens`,-1)]]),_:1}),L(b(Re),{value:`cost`},{default:B(()=>[...t[5]||=[ge(`Cost`,-1)]]),_:1}),L(b(Re),{value:`models`},{default:B(()=>[...t[6]||=[ge(`Models`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`]),b(n).error?(N(),P(`p`,Fp,ce(b(n).error),1)):ze(``,!0),b(n).tab===`models`?(N(),P(k,{key:1},[He(`p`,Ip,` Models with usage in the selected window, ranked by `+ce(b(Sp)[b(n).modelMetric].toLowerCase())+`. Each row is the provider that served the traffic, so a model reached through more than one provider appears once per provider. `,1),L(jp,{metric:b(n).modelMetric,models:b(n).modelRanking},null,8,[`metric`,`models`])],64)):(N(),I(Np,{key:2,tab:l.value,window:b(n).window,"series-by-metric":b(n).seriesByMetric},null,8,[`tab`,`window`,`series-by-metric`]))]),_:1})]),_:1}))}});export{Lp as default};", ), }, "index-CSkIItro.css": { @@ -52,10 +52,10 @@ var adminAssets = map[string]adminAsset{ "@keyframes authgate-shake-4be6bc09{10%,90%{transform:translate(-1px)}20%,80%{transform:translate(2px)}30%,50%,70%{transform:translate(-4px)}40%,60%{transform:translate(4px)}}@media (prefers-reduced-motion:no-preference){.authgate-shake[data-v-4be6bc09]{animation:.4s ease-in-out authgate-shake-4be6bc09}}@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){:root,:host{--shimmer-angle:20deg}*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-border-style:solid;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-outline-style:solid;--tw-blur:initial;--tw-brightness:initial;--tw-contrast:initial;--tw-grayscale:initial;--tw-hue-rotate:initial;--tw-invert:initial;--tw-opacity:initial;--tw-saturate:initial;--tw-sepia:initial;--tw-drop-shadow:initial;--tw-drop-shadow-color:initial;--tw-drop-shadow-alpha:100%;--tw-drop-shadow-size:initial;--tw-duration:initial;--tw-content:"";--tw-animation-delay:0s;--tw-animation-direction:normal;--tw-animation-duration:initial;--tw-animation-fill-mode:none;--tw-animation-iteration-count:1;--tw-enter-blur:0;--tw-enter-opacity:1;--tw-enter-rotate:0;--tw-enter-scale:1;--tw-enter-translate-x:0;--tw-enter-translate-y:0;--tw-exit-blur:0;--tw-exit-opacity:1;--tw-exit-rotate:0;--tw-exit-scale:1;--tw-exit-translate-x:0;--tw-exit-translate-y:0;--scroll-fade-t:0;--scroll-fade-b:0;--scroll-fade-s:0;--scroll-fade-e:0;--scroll-fade-mask:initial;--shimmer-image:initial;--shimmer-text-fill:initial}}}@layer theme{:root,:host{--font-sans:ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;--spacing:.25rem;--container-xs:20rem;--container-sm:24rem;--container-md:28rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-base:1rem;--text-base--line-height:calc(1.5 / 1);--text-lg:1.125rem;--text-lg--line-height:calc(1.75 / 1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75 / 1.25);--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--tracking-tight:-.025em;--leading-snug:1.375;--radius-md:calc(var(--radius) - 2px);--radius-4xl:2rem;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;--default-mono-font-family:ui-monospace, "SF Mono", "Cascadia Code", "Roboto Mono", Consolas, monospace}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--default-font-family,-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", "Noto Sans", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring:where(:not(iframe)){outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab, red, red)){::placeholder{color:color-mix(in oklab, currentcolor 50%, transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){appearance:button}::file-selector-button{appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}*{border-color:var(--border);outline-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){*{outline-color:color-mix(in oklab, var(--ring) 50%, transparent)}}body{background-color:var(--background);color:var(--foreground);font-variant-numeric:tabular-nums;font-family:ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif}}@layer components;@layer utilities{.\@container\/card-header{container:card-header/inline-size}.pointer-events-none{pointer-events:none}.collapse{visibility:collapse}.invisible{visibility:hidden}.visible{visibility:visible}.sr-only{clip-path:inset(50%);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.top-1\/2{top:50%}.top-2{top:calc(var(--spacing) * 2)}.right-1{right:var(--spacing)}.right-1\.5{right:calc(var(--spacing) * 1.5)}.right-2{right:calc(var(--spacing) * 2)}.left-2\.5{left:calc(var(--spacing) * 2.5)}.z-10{z-index:10}.z-50{z-index:50}.col-start-2{grid-column-start:2}.row-span-2{grid-row:span 2/span 2}.row-start-1{grid-row-start:1}.-mx-1{margin-inline:calc(var(--spacing) * -1)}.-mx-1\.5{margin-inline:calc(var(--spacing) * -1.5)}.mx-auto{margin-inline:auto}.my-1{margin-block:var(--spacing)}.mt-0\.5{margin-top:calc(var(--spacing) * .5)}.mt-2{margin-top:calc(var(--spacing) * 2)}.mt-4{margin-top:calc(var(--spacing) * 4)}.mb-1\.5{margin-bottom:calc(var(--spacing) * 1.5)}.mb-3{margin-bottom:calc(var(--spacing) * 3)}.block{display:block}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline{display:inline}.inline-flex{display:inline-flex}.table{display:table}.table-caption{display:table-caption}.table-cell{display:table-cell}.table-row{display:table-row}.size-2\.5{width:calc(var(--spacing) * 2.5);height:calc(var(--spacing) * 2.5)}.size-3{width:calc(var(--spacing) * 3);height:calc(var(--spacing) * 3)}.size-3\.5{width:calc(var(--spacing) * 3.5);height:calc(var(--spacing) * 3.5)}.size-4{width:calc(var(--spacing) * 4);height:calc(var(--spacing) * 4)}.size-5{width:calc(var(--spacing) * 5);height:calc(var(--spacing) * 5)}.size-6{width:calc(var(--spacing) * 6);height:calc(var(--spacing) * 6)}.size-7{width:calc(var(--spacing) * 7);height:calc(var(--spacing) * 7)}.size-8{width:calc(var(--spacing) * 8);height:calc(var(--spacing) * 8)}.size-9{width:calc(var(--spacing) * 9);height:calc(var(--spacing) * 9)}.size-12{width:calc(var(--spacing) * 12);height:calc(var(--spacing) * 12)}.h-5{height:calc(var(--spacing) * 5)}.h-6{height:calc(var(--spacing) * 6)}.h-7{height:calc(var(--spacing) * 7)}.h-8{height:calc(var(--spacing) * 8)}.h-9{height:calc(var(--spacing) * 9)}.h-10{height:calc(var(--spacing) * 10)}.h-72{height:calc(var(--spacing) * 72)}.h-\[calc\(100\%-1px\)\]{height:calc(100% - 1px)}.h-px{height:1px}.max-h-\(--reka-select-content-available-height\){max-height:var(--reka-select-content-available-height)}.min-h-\[70vh\]{min-height:70vh}.w-40{width:calc(var(--spacing) * 40)}.w-56{width:calc(var(--spacing) * 56)}.w-fit{width:fit-content}.w-full{width:100%}.max-w-md{max-width:var(--container-md)}.max-w-sm{max-width:var(--container-sm)}.max-w-xs{max-width:var(--container-xs)}.min-w-0{min-width:0}.min-w-36{min-width:calc(var(--spacing) * 36)}.flex-1{flex:1}.shrink-0{flex-shrink:0}.grow{flex-grow:1}.caption-bottom{caption-side:bottom}.origin-\(--reka-select-content-transform-origin\){transform-origin:var(--reka-select-content-transform-origin)}.-translate-y-1\/2{--tw-translate-y:calc(calc(1 / 2 * 100%) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.transform{transform:var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,)}.cursor-default{cursor:default}.cursor-pointer{cursor:pointer}.scroll-my-1{scroll-margin-block:var(--spacing)}.auto-rows-min{grid-auto-rows:min-content}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-center{align-items:center}.items-start{align-items:flex-start}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.gap-0\.5{gap:calc(var(--spacing) * .5)}.gap-1{gap:var(--spacing)}.gap-1\.5{gap:calc(var(--spacing) * 1.5)}.gap-2{gap:calc(var(--spacing) * 2)}.gap-3{gap:calc(var(--spacing) * 3)}.gap-4{gap:calc(var(--spacing) * 4)}.gap-6{gap:calc(var(--spacing) * 6)}.gap-x-3{column-gap:calc(var(--spacing) * 3)}.gap-x-4{column-gap:calc(var(--spacing) * 4)}.gap-x-6{column-gap:calc(var(--spacing) * 6)}.gap-y-1{row-gap:var(--spacing)}.gap-y-1\.5{row-gap:calc(var(--spacing) * 1.5)}.self-start{align-self:flex-start}.justify-self-end{justify-self:flex-end}.truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-x-hidden{overflow-x:hidden}.overflow-y-auto{overflow-y:auto}.rounded{border-radius:.25rem}.rounded-4xl{border-radius:var(--radius-4xl)}.rounded-\[min\(var\(--radius-md\)\,10px\)\]{border-radius:min(var(--radius-md), 10px)}.rounded-\[min\(var\(--radius-md\)\,12px\)\]{border-radius:min(var(--radius-md), 12px)}.rounded-full{border-radius:2147483647px}.rounded-lg{border-radius:var(--radius)}.rounded-md{border-radius:calc(var(--radius) - 2px)}.rounded-xl{border-radius:calc(var(--radius) + 4px)}.rounded-t-xl{border-top-left-radius:calc(var(--radius) + 4px);border-top-right-radius:calc(var(--radius) + 4px)}.rounded-b-xl{border-bottom-right-radius:calc(var(--radius) + 4px);border-bottom-left-radius:calc(var(--radius) + 4px)}.border{border-style:var(--tw-border-style);border-width:1px}.border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.border-border{border-color:var(--border)}.border-input{border-color:var(--input)}.border-status-warn\/40{border-color:var(--status-warn)}@supports (color:color-mix(in lab, red, red)){.border-status-warn\/40{border-color:color-mix(in oklab, var(--status-warn) 40%, transparent)}}.border-transparent{border-color:#0000}.bg-background{background-color:var(--background)}.bg-border{background-color:var(--border)}.bg-card{background-color:var(--card)}.bg-destructive\/10{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.bg-destructive\/10{background-color:color-mix(in oklab, var(--destructive) 10%, transparent)}}.bg-muted,.bg-muted\/50{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.bg-muted\/50{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.bg-popover{background-color:var(--popover)}.bg-primary,.bg-primary\/10{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.bg-primary\/10{background-color:color-mix(in oklab, var(--primary) 10%, transparent)}}.bg-secondary{background-color:var(--secondary)}.bg-transparent{background-color:#0000}.bg-clip-padding{background-clip:padding-box}.p-0\.75{padding:calc(var(--spacing) * .75)}.p-1{padding:var(--spacing)}.p-2{padding:calc(var(--spacing) * 2)}.p-4{padding:calc(var(--spacing) * 4)}.px-1\.5{padding-inline:calc(var(--spacing) * 1.5)}.px-2{padding-inline:calc(var(--spacing) * 2)}.px-2\.5{padding-inline:calc(var(--spacing) * 2.5)}.px-3{padding-inline:calc(var(--spacing) * 3)}.px-4{padding-inline:calc(var(--spacing) * 4)}.py-0\.5{padding-block:calc(var(--spacing) * .5)}.py-1{padding-block:var(--spacing)}.py-2{padding-block:calc(var(--spacing) * 2)}.py-2\.5{padding-block:calc(var(--spacing) * 2.5)}.py-4{padding-block:calc(var(--spacing) * 4)}.py-6{padding-block:calc(var(--spacing) * 6)}.py-8{padding-block:calc(var(--spacing) * 8)}.py-10{padding-block:calc(var(--spacing) * 10)}.pt-0{padding-top:0}.pr-2{padding-right:calc(var(--spacing) * 2)}.pr-8{padding-right:calc(var(--spacing) * 8)}.pr-10{padding-right:calc(var(--spacing) * 10)}.pb-2\.5{padding-bottom:calc(var(--spacing) * 2.5)}.pl-1\.5{padding-left:calc(var(--spacing) * 1.5)}.pl-2\.5{padding-left:calc(var(--spacing) * 2.5)}.pl-8{padding-left:calc(var(--spacing) * 8)}.text-center{text-align:center}.text-left{text-align:left}.text-right{text-align:right}.align-middle{vertical-align:middle}.font-mono{font-family:ui-monospace,SF Mono,Cascadia Code,Roboto Mono,Consolas,monospace}.text-base{font-size:var(--text-base);line-height:var(--tw-leading,var(--text-base--line-height))}.text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-xl{font-size:var(--text-xl);line-height:var(--tw-leading,var(--text-xl--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.text-\[0\.8rem\]{font-size:.8rem}.leading-snug{--tw-leading:var(--leading-snug);line-height:var(--leading-snug)}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-normal{--tw-font-weight:var(--font-weight-normal);font-weight:var(--font-weight-normal)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.text-balance{text-wrap:balance}.break-all{word-break:break-all}.whitespace-nowrap{white-space:nowrap}.text-card-foreground{color:var(--card-foreground)}.text-chart-requests{color:var(--chart-requests)}.text-destructive{color:var(--destructive)}.text-foreground,.text-foreground\/60{color:var(--foreground)}@supports (color:color-mix(in lab, red, red)){.text-foreground\/60{color:color-mix(in oklab, var(--foreground) 60%, transparent)}}.text-muted-foreground,.text-muted-foreground\/60{color:var(--muted-foreground)}@supports (color:color-mix(in lab, red, red)){.text-muted-foreground\/60{color:color-mix(in oklab, var(--muted-foreground) 60%, transparent)}}.text-popover-foreground{color:var(--popover-foreground)}.text-primary{color:var(--primary)}.text-primary-foreground{color:var(--primary-foreground)}.text-secondary-foreground{color:var(--secondary-foreground)}.text-status-warn{color:var(--status-warn)}.lowercase{text-transform:lowercase}.tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,)}.underline-offset-4{text-underline-offset:4px}.shadow-md{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a), 0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ring,.ring-1{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ring-foreground\/10{--tw-ring-color:var(--foreground)}@supports (color:color-mix(in lab, red, red)){.ring-foreground\/10{--tw-ring-color:color-mix(in oklab, var(--foreground) 10%, transparent)}}.outline-hidden{--tw-outline-style:none;outline-style:none}@media (forced-colors:active){.outline-hidden{outline-offset:2px;outline:2px solid #0000}}.outline{outline-style:var(--tw-outline-style);outline-width:1px}.filter{filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,content-visibility,overlay,pointer-events;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.duration-100{--tw-duration:.1s;transition-duration:.1s}.outline-none{--tw-outline-style:none;outline-style:none}.select-none{-webkit-user-select:none;user-select:none}.select-text{-webkit-user-select:text;user-select:text}.running{animation-play-state:running}.not-last\:border-b:not(:last-child){border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.group-has-\[\>svg\]\/alert\:col-start-2:is(:where(.group\/alert):has(>svg) *){grid-column-start:2}.group-aria-expanded\/accordion-trigger\:hidden:is(:where(.group\/accordion-trigger)[aria-expanded=true] *){display:none}.group-aria-expanded\/accordion-trigger\:inline:is(:where(.group\/accordion-trigger)[aria-expanded=true] *){display:inline}.group-data-\[size\=sm\]\/card\:p-3:is(:where(.group\/card)[data-size=sm] *){padding:calc(var(--spacing) * 3)}.group-data-\[size\=sm\]\/card\:px-3:is(:where(.group\/card)[data-size=sm] *){padding-inline:calc(var(--spacing) * 3)}.group-data-\[size\=sm\]\/card\:text-sm:is(:where(.group\/card)[data-size=sm] *){font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.group-data-\[variant\=line\]\/tabs-list\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *){background-color:#0000}.group-data-horizontal\/tabs\:h-8:is(:where(.group\/tabs):where([data-orientation=horizontal]) *){height:calc(var(--spacing) * 8)}.group-data-vertical\/tabs\:h-fit:is(:where(.group\/tabs):where([data-orientation=vertical]) *){height:fit-content}.group-data-vertical\/tabs\:w-full:is(:where(.group\/tabs):where([data-orientation=vertical]) *){width:100%}.group-data-vertical\/tabs\:flex-col:is(:where(.group\/tabs):where([data-orientation=vertical]) *){flex-direction:column}.group-data-vertical\/tabs\:justify-start:is(:where(.group\/tabs):where([data-orientation=vertical]) *){justify-content:flex-start}.file\:inline-flex::file-selector-button{display:inline-flex}.file\:h-6::file-selector-button{height:calc(var(--spacing) * 6)}.file\:border-0::file-selector-button{border-style:var(--tw-border-style);border-width:0}.file\:bg-transparent::file-selector-button{background-color:#0000}.file\:text-sm::file-selector-button{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.file\:font-medium::file-selector-button{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.file\:text-foreground::file-selector-button{color:var(--foreground)}.placeholder\:text-muted-foreground::placeholder{color:var(--muted-foreground)}.after\:absolute:after{content:var(--tw-content);position:absolute}.after\:bg-foreground:after{content:var(--tw-content);background-color:var(--foreground)}.after\:opacity-0:after{content:var(--tw-content);opacity:0}.after\:transition-opacity:after{content:var(--tw-content);transition-property:opacity;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.group-data-horizontal\/tabs\:after\:inset-x-0:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);inset-inline:0}.group-data-horizontal\/tabs\:after\:bottom-\[-5px\]:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);bottom:-5px}.group-data-horizontal\/tabs\:after\:h-0\.5:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);height:calc(var(--spacing) * .5)}.group-data-vertical\/tabs\:after\:inset-y-0:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);inset-block:0}.group-data-vertical\/tabs\:after\:-right-1:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);right:calc(var(--spacing) * -1)}.group-data-vertical\/tabs\:after\:w-0\.5:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);width:calc(var(--spacing) * .5)}@media (hover:hover){.hover\:bg-accent:hover{background-color:var(--accent)}.hover\:bg-destructive\/20:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.hover\:bg-destructive\/20:hover{background-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.hover\:bg-muted:hover,.hover\:bg-muted\/50:hover{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.hover\:bg-muted\/50:hover{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.hover\:bg-secondary\/80:hover{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){.hover\:bg-secondary\/80:hover{background-color:color-mix(in oklab, var(--secondary) 80%, transparent)}}.hover\:text-accent-foreground:hover{color:var(--accent-foreground)}.hover\:text-foreground:hover{color:var(--foreground)}.hover\:text-muted-foreground:hover{color:var(--muted-foreground)}.hover\:underline:hover{text-decoration-line:underline}}.focus\:bg-accent:focus{background-color:var(--accent)}.focus\:text-accent-foreground:focus,:is(.not-data-\[variant\=destructive\]\:focus\:\*\*\:text-accent-foreground:not([data-variant=destructive]):focus *){color:var(--accent-foreground)}.focus-visible\:border-destructive\/40:focus-visible{border-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.focus-visible\:border-destructive\/40:focus-visible{border-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}.focus-visible\:border-ring:focus-visible{border-color:var(--ring)}.focus-visible\:ring-3:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){.focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:color-mix(in oklab, var(--ring) 50%, transparent)}}.focus-visible\:outline-1:focus-visible{outline-style:var(--tw-outline-style);outline-width:1px}.focus-visible\:outline-ring:focus-visible{outline-color:var(--ring)}.focus-visible\:after\:border-ring:focus-visible:after{content:var(--tw-content);border-color:var(--ring)}.active\:not-aria-\[haspopup\]\:translate-y-px:active:not([aria-haspopup]){--tw-translate-y:1px;translate:var(--tw-translate-x) var(--tw-translate-y)}.disabled\:pointer-events-none:disabled{pointer-events:none}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:bg-input\/50:disabled{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.disabled\:bg-input\/50:disabled{background-color:color-mix(in oklab, var(--input) 50%, transparent)}}.disabled\:opacity-50:disabled{opacity:.5}:where([data-slot=button-group]) .in-data-\[slot\=button-group\]\:rounded-lg{border-radius:var(--radius)}.has-aria-expanded\:bg-muted\/50:has([aria-expanded=true]){background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.has-aria-expanded\:bg-muted\/50:has([aria-expanded=true]){background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.has-data-\[icon\=inline-end\]\:pr-1:has([data-icon=inline-end]){padding-right:var(--spacing)}.has-data-\[icon\=inline-end\]\:pr-1\.5:has([data-icon=inline-end]){padding-right:calc(var(--spacing) * 1.5)}.has-data-\[icon\=inline-end\]\:pr-2:has([data-icon=inline-end]){padding-right:calc(var(--spacing) * 2)}.has-data-\[icon\=inline-start\]\:pl-1:has([data-icon=inline-start]){padding-left:var(--spacing)}.has-data-\[icon\=inline-start\]\:pl-1\.5:has([data-icon=inline-start]){padding-left:calc(var(--spacing) * 1.5)}.has-data-\[icon\=inline-start\]\:pl-2:has([data-icon=inline-start]){padding-left:calc(var(--spacing) * 2)}.has-data-\[slot\=alert-action\]\:relative:has([data-slot=alert-action]){position:relative}.has-data-\[slot\=alert-action\]\:pr-18:has([data-slot=alert-action]){padding-right:calc(var(--spacing) * 18)}.has-data-\[slot\=card-action\]\:grid-cols-\[1fr_auto\]:has([data-slot=card-action]){grid-template-columns:1fr auto}.has-data-\[slot\=card-description\]\:grid-rows-\[auto_auto\]:has([data-slot=card-description]){grid-template-rows:auto auto}.has-data-\[slot\=card-footer\]\:pb-0:has([data-slot=card-footer]){padding-bottom:0}.has-\[\>img\:first-child\]\:pt-0:has(>img:first-child){padding-top:0}.has-\[\>svg\]\:grid-cols-\[auto_1fr\]:has(>svg){grid-template-columns:auto 1fr}.has-\[\>svg\]\:gap-x-2:has(>svg){column-gap:calc(var(--spacing) * 2)}.aria-expanded\:bg-muted[aria-expanded=true]{background-color:var(--muted)}.aria-expanded\:bg-secondary[aria-expanded=true]{background-color:var(--secondary)}.aria-expanded\:text-foreground[aria-expanded=true]{color:var(--foreground)}.aria-expanded\:text-secondary-foreground[aria-expanded=true]{color:var(--secondary-foreground)}.aria-invalid\:border-destructive[aria-invalid=true]{border-color:var(--destructive)}.aria-invalid\:ring-3[aria-invalid=true]{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.data-placeholder\:text-muted-foreground[data-placeholder]{color:var(--muted-foreground)}.data-\[align-trigger\=true\]\:animate-none[data-align-trigger=true]{animation:none}.data-\[disabled\]\:pointer-events-none[data-disabled]{pointer-events:none}.data-\[disabled\]\:opacity-50[data-disabled]{opacity:.5}.data-\[position\=popper\]\:h-\(--reka-select-trigger-height\)[data-position=popper]{height:var(--reka-select-trigger-height)}.data-\[position\=popper\]\:w-full[data-position=popper]{width:100%}.data-\[position\=popper\]\:min-w-\(--reka-select-trigger-width\)[data-position=popper]{min-width:var(--reka-select-trigger-width)}.data-\[side\=bottom\]\:translate-y-1[data-side=bottom]{--tw-translate-y:var(--spacing);translate:var(--tw-translate-x) var(--tw-translate-y)}.data-\[side\=bottom\]\:slide-in-from-top-2[data-side=bottom]{--tw-enter-translate-y:calc(2*var(--spacing)*-1)}.data-\[side\=inline-end\]\:slide-in-from-left-2[data-side=inline-end]{--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.data-\[side\=inline-start\]\:slide-in-from-right-2[data-side=inline-start]{--tw-enter-translate-x:calc(2*var(--spacing))}.data-\[side\=left\]\:-translate-x-1[data-side=left]{--tw-translate-x:calc(var(--spacing) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.data-\[side\=left\]\:slide-in-from-right-2[data-side=left]{--tw-enter-translate-x:calc(2*var(--spacing))}.data-\[side\=right\]\:translate-x-1[data-side=right]{--tw-translate-x:var(--spacing);translate:var(--tw-translate-x) var(--tw-translate-y)}.data-\[side\=right\]\:slide-in-from-left-2[data-side=right]{--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.data-\[side\=top\]\:-translate-y-1[data-side=top]{--tw-translate-y:calc(var(--spacing) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.data-\[side\=top\]\:slide-in-from-bottom-2[data-side=top]{--tw-enter-translate-y:calc(2*var(--spacing))}.data-\[size\=default\]\:h-8[data-size=default]{height:calc(var(--spacing) * 8)}.data-\[size\=sm\]\:h-7[data-size=sm]{height:calc(var(--spacing) * 7)}.data-\[size\=sm\]\:gap-3[data-size=sm]{gap:calc(var(--spacing) * 3)}.data-\[size\=sm\]\:rounded-\[min\(var\(--radius-md\)\,10px\)\][data-size=sm]{border-radius:min(var(--radius-md), 10px)}.data-\[size\=sm\]\:py-3[data-size=sm]{padding-block:calc(var(--spacing) * 3)}.data-\[size\=sm\]\:has-data-\[slot\=card-footer\]\:pb-0[data-size=sm]:has([data-slot=card-footer]){padding-bottom:0}:is(.\*\*\:data-\[slot\=accordion-trigger-icon\]\:ml-auto *)[data-slot=accordion-trigger-icon]{margin-left:auto}:is(.\*\*\:data-\[slot\=accordion-trigger-icon\]\:size-4 *)[data-slot=accordion-trigger-icon]{width:calc(var(--spacing) * 4);height:calc(var(--spacing) * 4)}:is(.\*\*\:data-\[slot\=accordion-trigger-icon\]\:text-muted-foreground *)[data-slot=accordion-trigger-icon]{color:var(--muted-foreground)}:is(.\*\:data-\[slot\=alert-description\]\:text-destructive\/90>*)[data-slot=alert-description]{color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){:is(.\*\:data-\[slot\=alert-description\]\:text-destructive\/90>*)[data-slot=alert-description]{color:color-mix(in oklab, var(--destructive) 90%, transparent)}}:is(.\*\:data-\[slot\=select-value\]\:line-clamp-1>*)[data-slot=select-value]{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}:is(.\*\:data-\[slot\=select-value\]\:flex>*)[data-slot=select-value]{display:flex}:is(.\*\:data-\[slot\=select-value\]\:items-center>*)[data-slot=select-value]{align-items:center}:is(.\*\:data-\[slot\=select-value\]\:gap-1\.5>*)[data-slot=select-value]{gap:calc(var(--spacing) * 1.5)}.data-\[state\=selected\]\:bg-muted[data-state=selected]{background-color:var(--muted)}.data-\[variant\=line\]\:rounded-none[data-variant=line]{border-radius:0}@media (width>=40rem){.sm\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.sm\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.sm\:flex-row{flex-direction:row}.sm\:items-center{align-items:center}.sm\:justify-between{justify-content:space-between}.sm\:px-6{padding-inline:calc(var(--spacing) * 6)}}@media (width>=48rem){.md\:text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.md\:text-pretty{text-wrap:pretty}}@media (width>=64rem){.lg\:px-8{padding-inline:calc(var(--spacing) * 8)}}@media (prefers-color-scheme:dark){.dark\:border-input{border-color:var(--input)}.dark\:bg-destructive\/20{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:bg-destructive\/20{background-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.dark\:bg-input\/30{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:bg-input\/30{background-color:color-mix(in oklab, var(--input) 30%, transparent)}}.dark\:text-muted-foreground{color:var(--muted-foreground)}@media (hover:hover){.dark\:hover\:bg-destructive\/30:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:hover\:bg-destructive\/30:hover{background-color:color-mix(in oklab, var(--destructive) 30%, transparent)}}.dark\:hover\:bg-input\/50:hover{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:hover\:bg-input\/50:hover{background-color:color-mix(in oklab, var(--input) 50%, transparent)}}.dark\:hover\:bg-muted\/50:hover{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.dark\:hover\:bg-muted\/50:hover{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.dark\:hover\:text-foreground:hover{color:var(--foreground)}}.dark\:focus-visible\:ring-destructive\/40:focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:focus-visible\:ring-destructive\/40:focus-visible{--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}.dark\:disabled\:bg-input\/80:disabled{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:disabled\:bg-input\/80:disabled{background-color:color-mix(in oklab, var(--input) 80%, transparent)}}.dark\:aria-invalid\:border-destructive\/50[aria-invalid=true]{border-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:aria-invalid\:border-destructive\/50[aria-invalid=true]{border-color:color-mix(in oklab, var(--destructive) 50%, transparent)}}.dark\:aria-invalid\:ring-destructive\/40[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:aria-invalid\:ring-destructive\/40[aria-invalid=true]{--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}}.data-open\:animate-accordion-down:where([data-state=open]),.data-open\:animate-accordion-down:where([data-open]:not([data-open=false])){animation:accordion-down var(--tw-animation-duration,var(--tw-duration,.2s))var(--tw-ease,ease-out)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-open\:animate-in:where([data-state=open]),.data-open\:animate-in:where([data-open]:not([data-open=false])){animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-open\:fade-in-0:where([data-state=open]),.data-open\:fade-in-0:where([data-open]:not([data-open=false])){--tw-enter-opacity:0}.data-open\:zoom-in-95:where([data-state=open]),.data-open\:zoom-in-95:where([data-open]:not([data-open=false])){--tw-enter-scale:.95}.data-closed\:animate-accordion-up:where([data-state=closed]),.data-closed\:animate-accordion-up:where([data-closed]:not([data-closed=false])){animation:accordion-up var(--tw-animation-duration,var(--tw-duration,.2s))var(--tw-ease,ease-out)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-closed\:animate-out:where([data-state=closed]),.data-closed\:animate-out:where([data-closed]:not([data-closed=false])){animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-closed\:fade-out-0:where([data-state=closed]),.data-closed\:fade-out-0:where([data-closed]:not([data-closed=false])){--tw-exit-opacity:0}.data-closed\:zoom-out-95:where([data-state=closed]),.data-closed\:zoom-out-95:where([data-closed]:not([data-closed=false])){--tw-exit-scale:.95}.data-active\:bg-background:where([data-state=active]),.data-active\:bg-background:where([data-active]:not([data-active=false])){background-color:var(--background)}.data-active\:text-foreground:where([data-state=active]),.data-active\:text-foreground:where([data-active]:not([data-active=false])){color:var(--foreground)}.group-data-\[variant\=default\]\/tabs-list\:data-active\:shadow-sm:is(:where(.group\/tabs-list)[data-variant=default] *):where([data-state=active]),.group-data-\[variant\=default\]\/tabs-list\:data-active\:shadow-sm:is(:where(.group\/tabs-list)[data-variant=default] *):where([data-active]:not([data-active=false])){--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){background-color:#0000}.group-data-\[variant\=line\]\/tabs-list\:data-active\:shadow-none:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.group-data-\[variant\=line\]\/tabs-list\:data-active\:shadow-none:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){--tw-shadow:0 0 #0000;box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}:is(.group-data-\[variant\=line\]\/tabs-list\:data-active\:after\:opacity-100:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.group-data-\[variant\=line\]\/tabs-list\:data-active\:after\:opacity-100:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false]))):after{content:var(--tw-content);opacity:1}@media (prefers-color-scheme:dark){.dark\:data-active\:border-input:where([data-state=active]),.dark\:data-active\:border-input:where([data-active]:not([data-active=false])){border-color:var(--input)}.dark\:data-active\:bg-input\/30:where([data-state=active]),.dark\:data-active\:bg-input\/30:where([data-active]:not([data-active=false])){background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:data-active\:bg-input\/30:where([data-state=active]),.dark\:data-active\:bg-input\/30:where([data-active]:not([data-active=false])){background-color:color-mix(in oklab, var(--input) 30%, transparent)}}.dark\:data-active\:text-foreground:where([data-state=active]),.dark\:data-active\:text-foreground:where([data-active]:not([data-active=false])){color:var(--foreground)}.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:border-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:border-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){border-color:#0000}.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){background-color:#0000}}.data-horizontal\:flex-col:where([data-orientation=horizontal]){flex-direction:column}.\[\&_a\]\:underline a{text-decoration-line:underline}.\[\&_a\]\:underline-offset-3 a{text-underline-offset:3px}@media (hover:hover){.\[\&_a\]\:hover\:text-foreground a:hover{color:var(--foreground)}}.\[\&_p\:not\(\:last-child\)\]\:mb-4 p:not(:last-child){margin-bottom:calc(var(--spacing) * 4)}.\[\&_svg\]\:pointer-events-none svg{pointer-events:none}.\[\&_svg\]\:shrink-0 svg{flex-shrink:0}.\[\&_svg\:not\(\[class\*\=size-\]\)\]\:size-3 svg:not([class*=size-]){width:calc(var(--spacing) * 3);height:calc(var(--spacing) * 3)}.\[\&_svg\:not\(\[class\*\=size-\]\)\]\:size-3\.5 svg:not([class*=size-]){width:calc(var(--spacing) * 3.5);height:calc(var(--spacing) * 3.5)}.\[\&_svg\:not\(\[class\*\=size-\]\)\]\:size-4 svg:not([class*=size-]){width:calc(var(--spacing) * 4);height:calc(var(--spacing) * 4)}.\[\&_tr\]\:border-b tr{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.\[\&_tr\:last-child\]\:border-0 tr:last-child{border-style:var(--tw-border-style);border-width:0}.\[\&\:has\(\[role\=checkbox\]\)\]\:pr-0:has([role=checkbox]){padding-right:0}.\[\.border-b\]\:pb-4.border-b{padding-bottom:calc(var(--spacing) * 4)}.group-data-\[size\=sm\]\/card\:\[\.border-b\]\:pb-3:is(:where(.group\/card)[data-size=sm] *).border-b{padding-bottom:calc(var(--spacing) * 3)}@media (hover:hover){.\[a\]\:hover\:bg-destructive\/20:is(a):hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.\[a\]\:hover\:bg-destructive\/20:is(a):hover{background-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.\[a\]\:hover\:bg-muted:is(a):hover{background-color:var(--muted)}.\[a\]\:hover\:bg-primary\/80:is(a):hover{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.\[a\]\:hover\:bg-primary\/80:is(a):hover{background-color:color-mix(in oklab, var(--primary) 80%, transparent)}}.\[a\]\:hover\:bg-secondary\/80:is(a):hover{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){.\[a\]\:hover\:bg-secondary\/80:is(a):hover{background-color:color-mix(in oklab, var(--secondary) 80%, transparent)}}.\[a\]\:hover\:text-muted-foreground:is(a):hover{color:var(--muted-foreground)}}:is(.\*\:\[img\:first-child\]\:rounded-t-xl>*):is(img:first-child){border-top-left-radius:calc(var(--radius) + 4px);border-top-right-radius:calc(var(--radius) + 4px)}:is(.\*\:\[img\:last-child\]\:rounded-b-xl>*):is(img:last-child){border-bottom-right-radius:calc(var(--radius) + 4px);border-bottom-left-radius:calc(var(--radius) + 4px)}:is(.\*\:\[span\]\:last\:flex>*):is(span):last-child{display:flex}:is(.\*\:\[span\]\:last\:items-center>*):is(span):last-child{align-items:center}:is(.\*\:\[span\]\:last\:gap-2>*):is(span):last-child{gap:calc(var(--spacing) * 2)}:is(.\*\:\[svg\]\:row-span-2>*):is(svg){grid-row:span 2/span 2}:is(.\*\:\[svg\]\:translate-y-0\.5>*):is(svg){--tw-translate-y:calc(var(--spacing) * .5);translate:var(--tw-translate-x) var(--tw-translate-y)}:is(.\*\:\[svg\]\:text-current>*):is(svg){color:currentColor}:is(.\*\:\[svg\:not\(\[class\*\=size-\]\)\]\:size-4>*):is(svg:not([class*=size-])){width:calc(var(--spacing) * 4);height:calc(var(--spacing) * 4)}.\[\&\>svg\]\:pointer-events-none>svg{pointer-events:none}.\[\&\>svg\]\:size-3\!>svg{width:calc(var(--spacing) * 3)!important;height:calc(var(--spacing) * 3)!important}.\[\&\>tr\]\:last\:border-b-0>tr:last-child{border-bottom-style:var(--tw-border-style);border-bottom-width:0}}@property --tw-animation-delay{syntax:"*";inherits:false;initial-value:0s}@property --tw-animation-direction{syntax:"*";inherits:false;initial-value:normal}@property --tw-animation-duration{syntax:"*";inherits:false}@property --tw-animation-fill-mode{syntax:"*";inherits:false;initial-value:none}@property --tw-animation-iteration-count{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-translate-y{syntax:"*";inherits:false;initial-value:0}@property --scroll-fade-t{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-b{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-s{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-e{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-mask{syntax:"*";inherits:false}@property --shimmer-angle{syntax:"<angle>";inherits:true;initial-value:20deg}@property --shimmer-image{syntax:"*";inherits:false}@property --shimmer-text-fill{syntax:"*";inherits:false}@media (prefers-reduced-motion:reduce){.shimmer{-webkit-text-fill-color:currentColor;background-image:none;animation:none}}:root{--background:oklch(99% .004 75);--foreground:oklch(19% .012 75);--card:oklch(99.5% .003 75);--card-foreground:oklch(19% .012 75);--popover:oklch(99.5% .003 75);--popover-foreground:oklch(19% .012 75);--primary:oklch(46% .09 200);--primary-foreground:oklch(98% .006 200);--secondary:oklch(95% .006 75);--secondary-foreground:oklch(22% .01 75);--muted:oklch(95% .006 75);--muted-foreground:oklch(48% .012 75);--accent:oklch(93% .02 200);--accent-foreground:oklch(28% .05 200);--destructive:oklch(55% .2 25);--border:oklch(90% .007 75);--input:oklch(90% .007 75);--ring:oklch(55% .09 200);--radius:.375rem;--chart-requests:#009e73;--chart-tokens-in:#0072b2;--chart-tokens-out:#e69f00;--chart-cost:#d55e00;--status-warn:#a35c00}@media (prefers-color-scheme:dark){:root{--background:oklch(17% .007 75);--foreground:oklch(95% .005 75);--card:oklch(21% .009 75);--card-foreground:oklch(95% .005 75);--popover:oklch(21% .009 75);--popover-foreground:oklch(95% .005 75);--primary:oklch(74% .11 200);--primary-foreground:oklch(16% .012 200);--secondary:oklch(27% .011 75);--secondary-foreground:oklch(93% .005 75);--muted:oklch(27% .011 75);--muted-foreground:oklch(68% .012 75);--accent:oklch(32% .035 200);--accent-foreground:oklch(91% .03 200);--destructive:oklch(68% .19 25);--border:oklch(100% 0 0/.12);--input:oklch(100% 0 0/.16);--ring:oklch(62% .1 200);--chart-requests:#16b891;--chart-tokens-in:#4098d7;--chart-tokens-out:#f0ac1f;--chart-cost:#e8763a;--status-warn:#f0ac1f}}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-rotate-x{syntax:"*";inherits:false}@property --tw-rotate-y{syntax:"*";inherits:false}@property --tw-rotate-z{syntax:"*";inherits:false}@property --tw-skew-x{syntax:"*";inherits:false}@property --tw-skew-y{syntax:"*";inherits:false}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-ordinal{syntax:"*";inherits:false}@property --tw-slashed-zero{syntax:"*";inherits:false}@property --tw-numeric-figure{syntax:"*";inherits:false}@property --tw-numeric-spacing{syntax:"*";inherits:false}@property --tw-numeric-fraction{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"<length>";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-outline-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-blur{syntax:"*";inherits:false}@property --tw-brightness{syntax:"*";inherits:false}@property --tw-contrast{syntax:"*";inherits:false}@property --tw-grayscale{syntax:"*";inherits:false}@property --tw-hue-rotate{syntax:"*";inherits:false}@property --tw-invert{syntax:"*";inherits:false}@property --tw-opacity{syntax:"*";inherits:false}@property --tw-saturate{syntax:"*";inherits:false}@property --tw-sepia{syntax:"*";inherits:false}@property --tw-drop-shadow{syntax:"*";inherits:false}@property --tw-drop-shadow-color{syntax:"*";inherits:false}@property --tw-drop-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-drop-shadow-size{syntax:"*";inherits:false}@property --tw-duration{syntax:"*";inherits:false}@property --tw-content{syntax:"*";inherits:false;initial-value:""}@keyframes enter{0%{opacity:var(--tw-enter-opacity,1);transform:translate3d(var(--tw-enter-translate-x,0),var(--tw-enter-translate-y,0),0)scale3d(var(--tw-enter-scale,1),var(--tw-enter-scale,1),var(--tw-enter-scale,1))rotate(var(--tw-enter-rotate,0));filter:blur(var(--tw-enter-blur,0))}}@keyframes exit{to{opacity:var(--tw-exit-opacity,1);transform:translate3d(var(--tw-exit-translate-x,0),var(--tw-exit-translate-y,0),0)scale3d(var(--tw-exit-scale,1),var(--tw-exit-scale,1),var(--tw-exit-scale,1))rotate(var(--tw-exit-rotate,0));filter:blur(var(--tw-exit-blur,0))}}@keyframes accordion-down{0%{height:0}to{height:var(--reka-accordion-content-height,var(--accordion-panel-height,auto))}}@keyframes accordion-up{0%{height:var(--reka-accordion-content-height,var(--accordion-panel-height,auto))}to{height:0}}
", ), }, - "index-D8B8ACGt.js": { + "index-CwP_MbOb.js": { contentType: "text/javascript; charset=utf-8", body: decodeAdminAsset( - "var e=Object.defineProperty,t=(t,n)=>{let r={};for(var i in t)e(r,i,{get:t[i],enumerable:!0});return n||e(r,Symbol.toStringTag,{value:`Module`}),r};function n(e){let t=Object.create(null);for(let n of e.split(`,`))t[n]=1;return e=>e in t}var r={},i=[],a=()=>{},o=()=>!1,s=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&(e.charCodeAt(2)>122||e.charCodeAt(2)<97),c=e=>e.startsWith(`onUpdate:`),l=Object.assign,u=(e,t)=>{let n=e.indexOf(t);n>-1&&e.splice(n,1)},d=Object.prototype.hasOwnProperty,f=(e,t)=>d.call(e,t),p=Array.isArray,m=e=>w(e)===`[object Map]`,h=e=>w(e)===`[object Set]`,g=e=>w(e)===`[object Date]`,_=e=>w(e)===`[object RegExp]`,v=e=>typeof e==`function`,y=e=>typeof e==`string`,b=e=>typeof e==`symbol`,x=e=>typeof e==`object`&&!!e,S=e=>(x(e)||v(e))&&v(e.then)&&v(e.catch),C=Object.prototype.toString,w=e=>C.call(e),ee=e=>w(e).slice(8,-1),te=e=>w(e)===`[object Object]`,T=e=>y(e)&&e!==`NaN`&&e[0]!==`-`&&``+parseInt(e,10)===e,ne=n(`,key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted`),re=e=>{let t=Object.create(null);return(n=>t[n]||(t[n]=e(n)))},ie=/-\w/g,E=re(e=>e.replace(ie,e=>e.slice(1).toUpperCase())),ae=/\B([A-Z])/g,oe=re(e=>e.replace(ae,`-$1`).toLowerCase()),se=re(e=>e.charAt(0).toUpperCase()+e.slice(1)),ce=re(e=>e?`on${se(e)}`:``),D=(e,t)=>!Object.is(e,t),le=(e,...t)=>{for(let n=0;n<e.length;n++)e[n](...t)},ue=(e,t,n,r=!1)=>{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:r,value:n})},de=e=>{let t=parseFloat(e);return isNaN(t)?e:t},fe=e=>{let t=y(e)?Number(e):NaN;return isNaN(t)?e:t},pe,me=()=>pe||=typeof globalThis<`u`?globalThis:typeof self<`u`?self:typeof window<`u`?window:typeof global<`u`?global:{},he=n(`Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol`);function ge(e){if(p(e)){let t={};for(let n=0;n<e.length;n++){let r=e[n],i=y(r)?be(r):ge(r);if(i)for(let e in i)t[e]=i[e]}return t}if(y(e)||x(e))return e}var _e=/;(?![^(]*\))/g,ve=/:([^]+)/,ye=/\/\*[^]*?\*\//g;function be(e){let t={};return e.replace(ye,``).split(_e).forEach(e=>{if(e){let n=e.split(ve);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}function O(e){let t=``;if(y(e))t=e;else if(p(e))for(let n=0;n<e.length;n++){let r=O(e[n]);r&&(t+=r+` `)}else if(x(e))for(let n in e)e[n]&&(t+=n+` `);return t.trim()}function xe(e){if(!e)return null;let{class:t,style:n}=e;return t&&!y(t)&&(e.class=O(t)),n&&(e.style=ge(n)),e}var Se=`itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`,Ce=n(Se);Se+``;function we(e){return!!e||e===``}function Te(e,t){if(e.length!==t.length)return!1;let n=!0;for(let r=0;n&&r<e.length;r++)n=Ee(e[r],t[r]);return n}function Ee(e,t){if(e===t)return!0;let n=g(e),r=g(t);if(n||r)return n&&r?e.getTime()===t.getTime():!1;if(n=b(e),r=b(t),n||r)return e===t;if(n=p(e),r=p(t),n||r)return n&&r?Te(e,t):!1;if(n=x(e),r=x(t),n||r){if(!n||!r||Object.keys(e).length!==Object.keys(t).length)return!1;for(let n in e){let r=e.hasOwnProperty(n),i=t.hasOwnProperty(n);if(r&&!i||!r&&i||!Ee(e[n],t[n]))return!1}}return String(e)===String(t)}function De(e,t){return e.findIndex(e=>Ee(e,t))}var Oe=e=>!!(e&&e.__v_isRef===!0),k=e=>y(e)?e:e==null?``:p(e)||x(e)&&(e.toString===C||!v(e.toString))?Oe(e)?k(e.value):JSON.stringify(e,ke,2):String(e),ke=(e,t)=>Oe(t)?ke(e,t.value):m(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((e,[t,n],r)=>(e[Ae(t,r)+` =>`]=n,e),{})}:h(t)?{[`Set(${t.size})`]:[...t.values()].map(e=>Ae(e))}:b(t)?Ae(t):x(t)&&!p(t)&&!te(t)?String(t):t,Ae=(e,t=``)=>b(e)?`Symbol(${e.description??t})`:e;function je(e){return e==null?`initial`:typeof e==`string`?e===``?` `:e:String(e)}var Me,Ne=class{constructor(e=!1){this.detached=e,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this._warnOnRun=!0,this.__v_skip=!0,!e&&Me&&(Me.active?(this.parent=Me,this.index=(Me.scopes||(Me.scopes=[])).push(this)-1):(this._active=!1,this._warnOnRun=!1))}get active(){return this._active}pause(){if(this._active){this._isPaused=!0;let e,t;if(this.scopes){let n=this.scopes.slice();for(e=0,t=n.length;e<t;e++)n[e].pause()}for(e=0,t=this.effects.length;e<t;e++)this.effects[e].pause()}}resume(){if(this._active&&this._isPaused){this._isPaused=!1;let e,t;if(this.scopes){let n=this.scopes.slice();for(e=0,t=n.length;e<t;e++)n[e].resume()}let n=this.effects.slice();for(e=0,t=n.length;e<t;e++)n[e].resume()}}run(e){if(this._active){let t=Me;try{return Me=this,e()}finally{Me=t}}}on(){++this._on===1&&(this.prevScope=Me,Me=this)}off(){if(this._on>0&&--this._on===0){if(Me===this)Me=this.prevScope;else{let e=Me;for(;e;){if(e.prevScope===this){e.prevScope=this.prevScope;break}e=e.prevScope}}this.prevScope=void 0}}stop(e){if(this._active){this._active=!1;let t,n;for(t=0,n=this.effects.length;t<n;t++)this.effects[t].stop();for(this.effects.length=0,t=0,n=this.cleanups.length;t<n;t++)this.cleanups[t]();if(this.cleanups.length=0,this.scopes){let e=this.scopes.slice();for(t=0,n=e.length;t<n;t++)e[t].stop(!0);this.scopes.length=0}if(!this.detached&&this.parent&&!e){let e=this.parent.scopes.pop();e&&e!==this&&(this.parent.scopes[this.index]=e,e.index=this.index)}this.parent=void 0}}};function Pe(e){return new Ne(e)}function Fe(){return Me}function Ie(e,t=!1){Me&&Me.cleanups.push(e)}var Le,Re=new WeakSet,ze=class{constructor(e){this.fn=e,this.deps=void 0,this.depsTail=void 0,this.flags=5,this.next=void 0,this.cleanup=void 0,this.scheduler=void 0,Me&&(Me.active?Me.effects.push(this):this.flags&=-2)}pause(){this.flags|=64}resume(){this.flags&64&&(this.flags&=-65,Re.has(this)&&(Re.delete(this),this.trigger()))}notify(){this.flags&2&&!(this.flags&32)||this.flags&8||Ue(this)}run(){if(!(this.flags&1))return this.fn();this.flags|=2,it(this),Ke(this);let e=Le,t=et;Le=this,et=!0;try{return this.fn()}finally{qe(this),Le=e,et=t,this.flags&=-3}}stop(){if(this.flags&1){for(let e=this.deps;e;e=e.nextDep)Xe(e);this.deps=this.depsTail=void 0,it(this),this.onStop&&this.onStop(),this.flags&=-2}}trigger(){this.flags&64?Re.add(this):this.scheduler?this.scheduler():this.runIfDirty()}runIfDirty(){Je(this)&&this.run()}get dirty(){return Je(this)}},Be=0,Ve,He;function Ue(e,t=!1){if(e.flags|=8,t){e.next=He,He=e;return}e.next=Ve,Ve=e}function We(){Be++}function Ge(){if(--Be>0)return;if(He){let e=He;for(He=void 0;e;){let t=e.next;e.next=void 0,e.flags&=-9,e=t}}let e;for(;Ve;){let t=Ve;for(Ve=void 0;t;){let n=t.next;if(t.next=void 0,t.flags&=-9,t.flags&1)try{t.trigger()}catch(t){e||=t}t=n}}if(e)throw e}function Ke(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function qe(e){let t,n=e.depsTail,r=n;for(;r;){let e=r.prevDep;r.version===-1?(r===n&&(n=e),Xe(r),Ze(r)):t=r,r.dep.activeLink=r.prevActiveLink,r.prevActiveLink=void 0,r=e}e.deps=t,e.depsTail=n}function Je(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(Ye(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function Ye(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===at)||(e.globalVersion=at,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!Je(e))))return;e.flags|=2;let t=e.dep,n=Le,r=et;Le=e,et=!0;try{Ke(e);let n=e.fn(e._value);(t.version===0||D(n,e._value))&&(e.flags|=128,e._value=n,t.version++)}catch(e){throw t.version++,e}finally{Le=n,et=r,qe(e),e.flags&=-3}}function Xe(e,t=!1){let{dep:n,prevSub:r,nextSub:i}=e;if(r&&(r.nextSub=i,e.prevSub=void 0),i&&(i.prevSub=r,e.nextSub=void 0),n.subs===e&&(n.subs=r,!r&&n.computed)){n.computed.flags&=-5;for(let e=n.computed.deps;e;e=e.nextDep)Xe(e,!0)}!t&&!--n.sc&&n.map&&n.map.delete(n.key)}function Ze(e){let{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}function Qe(e,t){e.effect instanceof ze&&(e=e.effect.fn);let n=new ze(e);t&&l(n,t);try{n.run()}catch(e){throw n.stop(),e}let r=n.run.bind(n);return r.effect=n,r}function $e(e){e.effect.stop()}var et=!0,tt=[];function nt(){tt.push(et),et=!1}function rt(){let e=tt.pop();et=e===void 0||e}function it(e){let{cleanup:t}=e;if(e.cleanup=void 0,t){let e=Le;Le=void 0;try{t()}finally{Le=e}}}var at=0,ot=class{constructor(e,t){this.sub=e,this.dep=t,this.version=t.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}},st=class{constructor(e){this.computed=e,this.version=0,this.activeLink=void 0,this.subs=void 0,this.map=void 0,this.key=void 0,this.sc=0,this.__v_skip=!0}track(e){if(!Le||!et||Le===this.computed)return;let t=this.activeLink;if(t===void 0||t.sub!==Le)t=this.activeLink=new ot(Le,this),Le.deps?(t.prevDep=Le.depsTail,Le.depsTail.nextDep=t,Le.depsTail=t):Le.deps=Le.depsTail=t,ct(t);else if(t.version===-1&&(t.version=this.version,t.nextDep)){let e=t.nextDep;e.prevDep=t.prevDep,t.prevDep&&(t.prevDep.nextDep=e),t.prevDep=Le.depsTail,t.nextDep=void 0,Le.depsTail.nextDep=t,Le.depsTail=t,Le.deps===t&&(Le.deps=e)}return t}trigger(e){this.version++,at++,this.notify(e)}notify(e){We();try{for(let e=this.subs;e;e=e.prevSub)e.sub.notify()&&e.sub.dep.notify()}finally{Ge()}}};function ct(e){if(e.dep.sc++,e.sub.flags&4){let t=e.dep.computed;if(t&&!e.dep.subs){t.flags|=20;for(let e=t.deps;e;e=e.nextDep)ct(e)}let n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}var lt=new WeakMap,ut=Symbol(``),dt=Symbol(``),ft=Symbol(``);function pt(e,t,n){if(et&&Le){let t=lt.get(e);t||lt.set(e,t=new Map);let r=t.get(n);r||(t.set(n,r=new st),r.map=t,r.key=n),r.track()}}function mt(e,t,n,r,i,a){let o=lt.get(e);if(!o){at++;return}let s=e=>{e&&e.trigger()};if(We(),t===`clear`)o.forEach(s);else{let i=p(e),a=i&&T(n);if(i&&n===`length`){let e=Number(r);o.forEach((t,n)=>{(n===`length`||n===ft||!b(n)&&n>=e)&&s(t)})}else switch((n!==void 0||o.has(void 0))&&s(o.get(n)),a&&s(o.get(ft)),t){case`add`:i?a&&s(o.get(`length`)):(s(o.get(ut)),m(e)&&s(o.get(dt)));break;case`delete`:i||(s(o.get(ut)),m(e)&&s(o.get(dt)));break;case`set`:m(e)&&s(o.get(ut))}}Ge()}function ht(e,t){let n=lt.get(e);return n&&n.get(t)}function gt(e){let t=A(e);return t===e?t:(pt(t,`iterate`,ft),an(e)?t:t.map(cn))}function _t(e){return pt(e=A(e),`iterate`,ft),e}function vt(e,t){return rn(e)?ln(nn(e)?cn(t):t):cn(t)}var yt={__proto__:null,[Symbol.iterator](){return bt(this,Symbol.iterator,e=>vt(this,e))},concat(...e){return gt(this).concat(...e.map(e=>p(e)?gt(e):e))},entries(){return bt(this,`entries`,e=>(e[1]=vt(this,e[1]),e))},every(e,t){return St(this,`every`,e,t,void 0,arguments)},filter(e,t){return St(this,`filter`,e,t,e=>e.map(e=>vt(this,e)),arguments)},find(e,t){return St(this,`find`,e,t,e=>vt(this,e),arguments)},findIndex(e,t){return St(this,`findIndex`,e,t,void 0,arguments)},findLast(e,t){return St(this,`findLast`,e,t,e=>vt(this,e),arguments)},findLastIndex(e,t){return St(this,`findLastIndex`,e,t,void 0,arguments)},forEach(e,t){return St(this,`forEach`,e,t,void 0,arguments)},includes(...e){return wt(this,`includes`,e)},indexOf(...e){return wt(this,`indexOf`,e)},join(e){return gt(this).join(e)},lastIndexOf(...e){return wt(this,`lastIndexOf`,e)},map(e,t){return St(this,`map`,e,t,void 0,arguments)},pop(){return Tt(this,`pop`)},push(...e){return Tt(this,`push`,e)},reduce(e,...t){return Ct(this,`reduce`,e,t)},reduceRight(e,...t){return Ct(this,`reduceRight`,e,t)},shift(){return Tt(this,`shift`)},some(e,t){return St(this,`some`,e,t,void 0,arguments)},splice(...e){return Tt(this,`splice`,e)},toReversed(){return gt(this).toReversed()},toSorted(e){return gt(this).toSorted(e)},toSpliced(...e){return gt(this).toSpliced(...e)},unshift(...e){return Tt(this,`unshift`,e)},values(){return bt(this,`values`,e=>vt(this,e))}};function bt(e,t,n){let r=_t(e),i=r[t]();return r!==e&&!an(e)&&(i._next=i.next,i.next=()=>{let e=i._next();return e.done||(e.value=n(e.value)),e}),i}var xt=Array.prototype;function St(e,t,n,r,i,a){let o=_t(e),s=o!==e&&!an(e),c=o[t];if(c!==xt[t]){let t=c.apply(e,a);return s?cn(t):t}let l=n;o!==e&&(s?l=function(t,r){return n.call(this,vt(e,t),r,e)}:n.length>2&&(l=function(t,r){return n.call(this,t,r,e)}));let u=c.call(o,l,r);return s&&i?i(u):u}function Ct(e,t,n,r){let i=_t(e),a=i!==e&&!an(e),o=n,s=!1;i!==e&&(a?(s=r.length===0,o=function(t,r,i){return s&&(s=!1,t=vt(e,t)),n.call(this,t,vt(e,r),i,e)}):n.length>3&&(o=function(t,r,i){return n.call(this,t,r,i,e)}));let c=i[t](o,...r);return s?vt(e,c):c}function wt(e,t,n){let r=A(e);pt(r,`iterate`,ft);let i=r[t](...n);return(i===-1||i===!1)&&on(n[0])?(n[0]=A(n[0]),r[t](...n)):i}function Tt(e,t,n=[]){nt(),We();let r=A(e)[t].apply(e,n);return Ge(),rt(),r}var Et=n(`__proto__,__v_isRef,__isVue`),Dt=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!==`arguments`&&e!==`caller`).map(e=>Symbol[e]).filter(b));function Ot(e){b(e)||(e=String(e));let t=A(this);return pt(t,`has`,e),t.hasOwnProperty(e)}var kt=class{constructor(e=!1,t=!1){this._isReadonly=e,this._isShallow=t}get(e,t,n){if(t===`__v_skip`)return e.__v_skip;let r=this._isReadonly,i=this._isShallow;if(t===`__v_isReactive`)return!r;if(t===`__v_isReadonly`)return r;if(t===`__v_isShallow`)return i;if(t===`__v_raw`)return n===(r?i?Yt:Jt:i?qt:Kt).get(e)||Object.getPrototypeOf(e)===Object.getPrototypeOf(n)?e:void 0;let a=p(e);if(!r){let e;if(a&&(e=yt[t]))return e;if(t===`hasOwnProperty`)return Ot}let o=Reflect.get(e,t,j(e)?e:n);if((b(t)?Dt.has(t):Et(t))||(r||pt(e,`get`,t),i))return o;if(j(o)){let e=a&&T(t)?o:o.value;return r&&x(e)?$t(e):e}return x(o)?r?$t(o):Zt(o):o}},At=class extends kt{constructor(e=!1){super(!1,e)}set(e,t,n,r){let i=e[t],a=p(e)&&T(t);if(!this._isShallow){let e=rn(i);if(!an(n)&&!rn(n)&&(i=A(i),n=A(n)),!a&&j(i)&&!j(n))return e||(i.value=n),!0}let o=a?Number(t)<e.length:f(e,t),s=Reflect.set(e,t,n,j(e)?e:r);return e===A(r)&&s&&(o?D(n,i)&&mt(e,`set`,t,n,i):mt(e,`add`,t,n)),s}deleteProperty(e,t){let n=f(e,t),r=e[t],i=Reflect.deleteProperty(e,t);return i&&n&&mt(e,`delete`,t,void 0,r),i}has(e,t){let n=Reflect.has(e,t);return(!b(t)||!Dt.has(t))&&pt(e,`has`,t),n}ownKeys(e){return pt(e,`iterate`,p(e)?`length`:ut),Reflect.ownKeys(e)}},jt=class extends kt{constructor(e=!1){super(!0,e)}set(e,t){return!0}deleteProperty(e,t){return!0}},Mt=new At,Nt=new jt,Pt=new At(!0),Ft=new jt(!0),It=e=>e,Lt=e=>Reflect.getPrototypeOf(e);function Rt(e,t,n){return function(...r){let i=this.__v_raw,a=A(i),o=m(a),s=e===`entries`||e===Symbol.iterator&&o,c=e===`keys`&&o,u=i[e](...r),d=n?It:t?ln:cn;return!t&&pt(a,`iterate`,c?dt:ut),l(Object.create(u),{next(){let{value:e,done:t}=u.next();return t?{value:e,done:t}:{value:s?[d(e[0]),d(e[1])]:d(e),done:t}}})}}function zt(e){return function(...t){return e===`delete`?!1:e===`clear`?void 0:this}}function Bt(e,t){let n={get(n){let r=this.__v_raw,i=A(r),a=A(n);e||(D(n,a)&&pt(i,`get`,n),pt(i,`get`,a));let{has:o}=Lt(i),s=t?It:e?ln:cn;if(o.call(i,n))return s(r.get(n));if(o.call(i,a))return s(r.get(a));r!==i&&r.get(n)},get size(){let t=this.__v_raw;return!e&&pt(A(t),`iterate`,ut),t.size},has(t){let n=this.__v_raw,r=A(n),i=A(t);return e||(D(t,i)&&pt(r,`has`,t),pt(r,`has`,i)),t===i?n.has(t):n.has(t)||n.has(i)},forEach(n,r){let i=this,a=i.__v_raw,o=A(a),s=t?It:e?ln:cn;return!e&&pt(o,`iterate`,ut),a.forEach((e,t)=>n.call(r,s(e),s(t),i))}};return l(n,e?{add:zt(`add`),set:zt(`set`),delete:zt(`delete`),clear:zt(`clear`)}:{add(e){let n=A(this),r=Lt(n),i=A(e),a=!t&&!an(e)&&!rn(e)?i:e;return r.has.call(n,a)||D(e,a)&&r.has.call(n,e)||D(i,a)&&r.has.call(n,i)||(n.add(a),mt(n,`add`,a,a)),this},set(e,n){!t&&!an(n)&&!rn(n)&&(n=A(n));let r=A(this),{has:i,get:a}=Lt(r),o=i.call(r,e);o||=(e=A(e),i.call(r,e));let s=a.call(r,e);return r.set(e,n),o?D(n,s)&&mt(r,`set`,e,n,s):mt(r,`add`,e,n),this},delete(e){let t=A(this),{has:n,get:r}=Lt(t),i=n.call(t,e);i||=(e=A(e),n.call(t,e));let a=r?r.call(t,e):void 0,o=t.delete(e);return i&&mt(t,`delete`,e,void 0,a),o},clear(){let e=A(this),t=e.size!==0,n=e.clear();return t&&mt(e,`clear`,void 0,void 0,void 0),n}}),[`keys`,`values`,`entries`,Symbol.iterator].forEach(r=>{n[r]=Rt(r,e,t)}),n}function Vt(e,t){let n=Bt(e,t);return(t,r,i)=>r===`__v_isReactive`?!e:r===`__v_isReadonly`?e:r===`__v_raw`?t:Reflect.get(f(n,r)&&r in t?n:t,r,i)}var Ht={get:Vt(!1,!1)},Ut={get:Vt(!1,!0)},Wt={get:Vt(!0,!1)},Gt={get:Vt(!0,!0)},Kt=new WeakMap,qt=new WeakMap,Jt=new WeakMap,Yt=new WeakMap;function Xt(e){switch(e){case`Object`:case`Array`:return 1;case`Map`:case`Set`:case`WeakMap`:case`WeakSet`:return 2;default:return 0}}function Zt(e){return rn(e)?e:tn(e,!1,Mt,Ht,Kt)}function Qt(e){return tn(e,!1,Pt,Ut,qt)}function $t(e){return tn(e,!0,Nt,Wt,Jt)}function en(e){return tn(e,!0,Ft,Gt,Yt)}function tn(e,t,n,r,i){if(!x(e)||e.__v_raw&&!(t&&e.__v_isReactive)||e.__v_skip||!Object.isExtensible(e))return e;let a=i.get(e);if(a)return a;let o=Xt(ee(e));if(o===0)return e;let s=new Proxy(e,o===2?r:n);return i.set(e,s),s}function nn(e){return rn(e)?nn(e.__v_raw):!!(e&&e.__v_isReactive)}function rn(e){return!!(e&&e.__v_isReadonly)}function an(e){return!!(e&&e.__v_isShallow)}function on(e){return e?!!e.__v_raw:!1}function A(e){let t=e&&e.__v_raw;return t?A(t):e}function sn(e){return!f(e,`__v_skip`)&&Object.isExtensible(e)&&ue(e,`__v_skip`,!0),e}var cn=e=>x(e)?Zt(e):e,ln=e=>x(e)?$t(e):e;function j(e){return e?e.__v_isRef===!0:!1}function M(e){return dn(e,!1)}function un(e){return dn(e,!0)}function dn(e,t){return j(e)?e:new fn(e,t)}var fn=class{constructor(e,t){this.dep=new st,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=t?e:A(e),this._value=t?e:cn(e),this.__v_isShallow=t}get value(){return this.dep.track(),this._value}set value(e){let t=this._rawValue,n=this.__v_isShallow||an(e)||rn(e);e=n?e:A(e),D(e,t)&&(this._rawValue=e,this._value=n?e:cn(e),this.dep.trigger())}};function pn(e){e.dep&&e.dep.trigger()}function N(e){return j(e)?e.value:e}function mn(e){return v(e)?e():N(e)}var hn={get:(e,t,n)=>t===`__v_raw`?e:N(Reflect.get(e,t,n)),set:(e,t,n,r)=>{let i=e[t];return j(i)&&!j(n)?(i.value=n,!0):Reflect.set(e,t,n,r)}};function gn(e){return nn(e)?e:new Proxy(e,hn)}var _n=class{constructor(e){this.__v_isRef=!0,this._value=void 0;let t=this.dep=new st,{get:n,set:r}=e(t.track.bind(t),t.trigger.bind(t));this._get=n,this._set=r}get value(){return this._value=this._get()}set value(e){this._set(e)}};function vn(e){return new _n(e)}function yn(e){let t=p(e)?Array(e.length):{};for(let n in e)t[n]=Cn(e,n);return t}var bn=class{constructor(e,t,n){this._object=e,this._defaultValue=n,this.__v_isRef=!0,this._value=void 0,this._key=b(t)?t:String(t),this._raw=A(e);let r=!0,i=e;if(!p(e)||b(this._key)||!T(this._key))do r=!on(i)||an(i);while(r&&(i=i.__v_raw));this._shallow=r}get value(){let e=this._object[this._key];return this._shallow&&(e=N(e)),this._value=e===void 0?this._defaultValue:e}set value(e){if(this._shallow&&j(this._raw[this._key])){let t=this._object[this._key];if(j(t)){t.value=e;return}}this._object[this._key]=e}get dep(){return ht(this._raw,this._key)}},xn=class{constructor(e){this._getter=e,this.__v_isRef=!0,this.__v_isReadonly=!0,this._value=void 0}get value(){return this._value=this._getter()}};function Sn(e,t,n){return j(e)?e:v(e)?new xn(e):x(e)&&arguments.length>1?Cn(e,t,n):M(e)}function Cn(e,t,n){return new bn(e,t,n)}var wn=class{constructor(e,t,n){this.fn=e,this.setter=t,this._value=void 0,this.dep=new st(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=at-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!t,this.isSSR=n}notify(){if(this.flags|=16,!(this.flags&8)&&Le!==this)return Ue(this,!0),!0}get value(){let e=this.dep.track();return Ye(this),e&&(e.version=this.dep.version),this._value}set value(e){this.setter&&this.setter(e)}};function Tn(e,t,n=!1){let r,i;return v(e)?r=e:(r=e.get,i=e.set),new wn(r,i,n)}var En={GET:`get`,HAS:`has`,ITERATE:`iterate`},Dn={SET:`set`,ADD:`add`,DELETE:`delete`,CLEAR:`clear`},On={},kn=new WeakMap,An=void 0;function jn(){return An}function Mn(e,t=!1,n=An){if(n){let t=kn.get(n);t||kn.set(n,t=[]),t.push(e)}}function Nn(e,t,n=r){let{immediate:i,deep:o,once:s,scheduler:c,augmentJob:l,call:d}=n,f=e=>o?e:an(e)||o===!1||o===0?Pn(e,1):Pn(e),m,h,g,_,y=!1,b=!1;if(j(e)?(h=()=>e.value,y=an(e)):nn(e)?(h=()=>f(e),y=!0):p(e)?(b=!0,y=e.some(e=>nn(e)||an(e)),h=()=>e.map(e=>{if(j(e))return e.value;if(nn(e))return f(e);if(v(e))return d?d(e,2):e()})):h=v(e)?t?d?()=>d(e,2):e:()=>{if(g){nt();try{g()}finally{rt()}}let t=An;An=m;try{return d?d(e,3,[_]):e(_)}finally{An=t}}:a,t&&o){let e=h,t=o===!0?1/0:o;h=()=>Pn(e(),t)}let x=Fe(),S=()=>{m.stop(),x&&x.active&&u(x.effects,m)};if(s&&t){let e=t;t=(...t)=>{let n=e(...t);return S(),n}}let C=b?Array(e.length).fill(On):On,w=e=>{if(!(!(m.flags&1)||!m.dirty&&!e)){if(t){let n=m.run();if(e||o||y||(b?n.some((e,t)=>D(e,C[t])):D(n,C))){g&&g();let e=An;An=m;try{let e=[n,C===On?void 0:b&&C[0]===On?[]:C,_];C=n,d?d(t,3,e):t(...e)}finally{An=e}}}else m.run()}};return l&&l(w),m=new ze(h),m.scheduler=c?()=>c(w,!1):w,_=e=>Mn(e,!1,m),g=m.onStop=()=>{let e=kn.get(m);if(e){if(d)d(e,4);else for(let t of e)t();kn.delete(m)}},t?i?w(!0):C=m.run():c?c(w.bind(null,!0),!0):m.run(),S.pause=m.pause.bind(m),S.resume=m.resume.bind(m),S.stop=S,S}function Pn(e,t=1/0,n){if(t<=0||!x(e)||e.__v_skip||(n||=new Map,(n.get(e)||0)>=t))return e;if(n.set(e,t),t--,j(e))Pn(e.value,t,n);else if(p(e))for(let r=0;r<e.length;r++)Pn(e[r],t,n);else if(h(e)||m(e))e.forEach(e=>{Pn(e,t,n)});else if(te(e)){for(let r in e)Pn(e[r],t,n);for(let r of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,r)&&Pn(e[r],t,n)}return e}var Fn=[];function In(e){Fn.push(e)}function Ln(){Fn.pop()}function Rn(e,t){}var zn={SETUP_FUNCTION:0,0:`SETUP_FUNCTION`,RENDER_FUNCTION:1,1:`RENDER_FUNCTION`,NATIVE_EVENT_HANDLER:5,5:`NATIVE_EVENT_HANDLER`,COMPONENT_EVENT_HANDLER:6,6:`COMPONENT_EVENT_HANDLER`,VNODE_HOOK:7,7:`VNODE_HOOK`,DIRECTIVE_HOOK:8,8:`DIRECTIVE_HOOK`,TRANSITION_HOOK:9,9:`TRANSITION_HOOK`,APP_ERROR_HANDLER:10,10:`APP_ERROR_HANDLER`,APP_WARN_HANDLER:11,11:`APP_WARN_HANDLER`,FUNCTION_REF:12,12:`FUNCTION_REF`,ASYNC_COMPONENT_LOADER:13,13:`ASYNC_COMPONENT_LOADER`,SCHEDULER:14,14:`SCHEDULER`,COMPONENT_UPDATE:15,15:`COMPONENT_UPDATE`,APP_UNMOUNT_CLEANUP:16,16:`APP_UNMOUNT_CLEANUP`},Bn={sp:`serverPrefetch hook`,bc:`beforeCreate hook`,c:`created hook`,bm:`beforeMount hook`,m:`mounted hook`,bu:`beforeUpdate hook`,u:`updated`,bum:`beforeUnmount hook`,um:`unmounted hook`,a:`activated hook`,da:`deactivated hook`,ec:`errorCaptured hook`,rtc:`renderTracked hook`,rtg:`renderTriggered hook`,0:`setup function`,1:`render function`,2:`watcher getter`,3:`watcher callback`,4:`watcher cleanup function`,5:`native event handler`,6:`component event handler`,7:`vnode hook`,8:`directive hook`,9:`transition hook`,10:`app errorHandler`,11:`app warnHandler`,12:`ref function`,13:`async component loader`,14:`scheduler flush`,15:`component update`,16:`app unmount cleanup function`};function Vn(e,t,n,r){try{return r?e(...r):e()}catch(e){Un(e,t,n)}}function Hn(e,t,n,r){if(v(e)){let i=Vn(e,t,n,r);return i&&S(i)&&i.catch(e=>{Un(e,t,n)}),i}if(p(e)){let i=[];for(let a=0;a<e.length;a++)i.push(Hn(e[a],t,n,r));return i}}function Un(e,t,n,i=!0){let a=t?t.vnode:null,{errorHandler:o,throwUnhandledErrorInProduction:s}=t&&t.appContext.config||r;if(t){let r=t.parent,i=t.proxy,a=`https://vuejs.org/error-reference/#runtime-${n}`;for(;r;){let t=r.ec;if(t){for(let n=0;n<t.length;n++)if(t[n](e,i,a)===!1)return}r=r.parent}if(o){nt(),Vn(o,null,10,[e,i,a]),rt();return}}Wn(e,n,a,i,s)}function Wn(e,t,n,r=!0,i=!1){if(i)throw e;console.error(e)}var Gn=[],Kn=-1,qn=[],Jn=null,Yn=0,Xn=Promise.resolve(),Zn=null;function Qn(e){let t=Zn||Xn;return e?t.then(this?e.bind(this):e):t}function $n(e){let t=Kn+1,n=Gn.length;for(;t<n;){let r=t+n>>>1,i=Gn[r],a=ar(i);a<e||a===e&&i.flags&2?t=r+1:n=r}return t}function er(e){if(!(e.flags&1)){let t=ar(e),n=Gn[Gn.length-1];!n||!(e.flags&2)&&t>=ar(n)?Gn.push(e):Gn.splice($n(t),0,e),e.flags|=1,tr()}}function tr(){Zn||=Xn.then(or)}function nr(e){if(!p(e))Jn&&e.id===-1?Jn.splice(Yn+1,0,e):e.flags&1||(qn.push(e),e.flags|=1);else for(let t=0;t<e.length;t++)qn.push(e[t]);tr()}function rr(e,t,n=Kn+1){for(;n<Gn.length;n++){let t=Gn[n];if(t&&t.flags&2){if(e&&t.id!==e.uid)continue;Gn.splice(n,1),n--,t.flags&4&&(t.flags&=-2),t(),t.flags&4||(t.flags&=-2)}}}function ir(e){if(qn.length){let e=[...new Set(qn)].sort((e,t)=>ar(e)-ar(t));if(qn.length=0,Jn){for(let t=0;t<e.length;t++)Jn.push(e[t]);return}for(Jn=e,Yn=0;Yn<Jn.length;Yn++){let e=Jn[Yn];e.flags&4&&(e.flags&=-2),e.flags&8||e(),e.flags&=-2}Jn=null,Yn=0}}var ar=e=>e.id==null?e.flags&2?-1:1/0:e.id;function or(e){try{for(Kn=0;Kn<Gn.length;Kn++){let e=Gn[Kn];e&&!(e.flags&8)&&(e.flags&4&&(e.flags&=-2),Vn(e,e.i,e.i?15:14),e.flags&4||(e.flags&=-2))}}finally{for(;Kn<Gn.length;Kn++){let e=Gn[Kn];e&&(e.flags&=-2)}Kn=-1,Gn.length=0,ir(e),Zn=null,(Gn.length||qn.length)&&or(e)}}var sr,cr=[];function lr(e,t){sr=e,sr?(sr.enabled=!0,cr.forEach(({event:e,args:t})=>sr.emit(e,...t)),cr=[]):typeof window<`u`&&window.HTMLElement&&!(window.navigator?.userAgent)?.includes(`jsdom`)?((t.__VUE_DEVTOOLS_HOOK_REPLAY__=t.__VUE_DEVTOOLS_HOOK_REPLAY__||[]).push(e=>{lr(e,t)}),setTimeout(()=>{sr||(t.__VUE_DEVTOOLS_HOOK_REPLAY__=null,cr=[])},3e3)):cr=[]}var ur=null,dr=null;function fr(e){let t=ur;return ur=e,dr=e&&e.type.__scopeId||null,t}function pr(e){dr=e}function mr(){dr=null}var hr=e=>P;function P(e,t=ur,n){if(!t||e._n)return e;let r=(...n)=>{r._d&&ms(-1);let i=fr(t),a=us.length,o;try{o=e(...n)}finally{for(let e=us.length;e>a;e--)fs();fr(i),r._d&&ms(1)}return o};return r._n=!0,r._c=!0,r._d=!0,r}function gr(e,t){if(ur===null)return e;let n=Qs(ur),i=e.dirs||=[];for(let e=0;e<t.length;e++){let[a,o,s,c=r]=t[e];a&&(v(a)&&(a={mounted:a,updated:a}),a.deep&&Pn(o),i.push({dir:a,instance:n,value:o,oldValue:void 0,arg:s,modifiers:c}))}return e}function _r(e,t,n,r){let i=e.dirs,a=t&&t.dirs;for(let o=0;o<i.length;o++){let s=i[o];a&&(s.oldValue=a[o].value);let c=s.dir[r];c&&(nt(),Hn(c,n,8,[e.el,s,e,t]),rt())}}function vr(e,t){if(Ps){let n=Ps.provides,r=Ps.parent&&Ps.parent.provides;r===n&&(n=Ps.provides=Object.create(r)),n[e]=t}}function yr(e,t,n=!1){let r=Fs();if(r||no){let i=no?no._context.provides:r?r.parent==null||r.ce?r.vnode.appContext&&r.vnode.appContext.provides:r.parent.provides:void 0;if(i&&e in i)return i[e];if(arguments.length>1)return n&&v(t)?t.call(r&&r.proxy):t}}function br(){return!!(Fs()||no)}var xr=Symbol.for(`v-scx`),Sr=()=>yr(xr);function Cr(e,t){return Dr(e,null,t)}function wr(e,t){return Dr(e,null,{flush:`post`})}function Tr(e,t){return Dr(e,null,{flush:`sync`})}function Er(e,t,n){return Dr(e,t,n)}function Dr(e,t,n=r){let{immediate:i,deep:o,flush:s,once:c}=n,u=l({},n),d=t&&i||!t&&s!==`post`,f;if(Vs){if(s===`sync`){let e=Sr();f=e.__watcherHandles||=[]}else if(!d){let e=()=>{};return e.stop=a,e.resume=a,e.pause=a,e}}let p=Ps;u.call=(e,t,n)=>Hn(e,p,t,n);let m=!1;s===`post`?u.scheduler=e=>{Io(e,p&&p.suspense)}:s!==`sync`&&(m=!0,u.scheduler=(e,t)=>{t?e():er(e)}),u.augmentJob=e=>{t&&(e.flags|=4),m&&(e.flags|=2,p&&(e.id=p.uid,e.i=p))};let h=Nn(e,t,u);return Vs&&(f?f.push(h):d&&h()),h}function Or(e,t,n){let r=this.proxy,i=y(e)?e.includes(`.`)?kr(r,e):()=>r[e]:e.bind(r,r),a;v(t)?a=t:(a=t.handler,n=t);let o=Rs(this),s=Dr(i,a.bind(r),n);return o(),s}function kr(e,t){let n=t.split(`.`);return()=>{let t=e;for(let e=0;e<n.length&&t;e++)t=t[n[e]];return t}}var Ar=new WeakMap,jr=Symbol(`_vte`),Mr=e=>e.__isTeleport,Nr=e=>e&&(e.disabled||e.disabled===``),Pr=e=>e&&(e.defer||e.defer===``),Fr=e=>typeof SVGElement<`u`&&e instanceof SVGElement,Ir=e=>typeof MathMLElement==`function`&&e instanceof MathMLElement,Lr=(e,t)=>{let n=e&&e.to;return y(n)?t?t(n):null:n},Rr={name:`Teleport`,__isTeleport:!0,process(e,t,n,r,i,a,o,s,c,l){let{mc:u,pc:d,pbc:f,o:{insert:p,querySelector:m,createText:h,createComment:g,parentNode:_}}=l,v=Nr(t.props),{dynamicChildren:y}=t,b=(e,t,n)=>{e.shapeFlag&16&&u(e.children,t,n,i,a,o,s,c)},x=(e=t)=>{let n=Nr(e.props),r=e.target=Lr(e.props,m),a=Ur(r,e,h,p);r&&(o!==`svg`&&Fr(r)?o=`svg`:o!==`mathml`&&Ir(r)&&(o=`mathml`),i&&i.isCE&&(i.ce._teleportTargets||(i.ce._teleportTargets=new Set)).add(r),n||(b(e,r,a),Hr(e,!1)))},S=e=>{let t=()=>{if(Ar.get(e)===t){if(Ar.delete(e),Nr(e.props)){let t=_(e.el)||n;b(e,t,e.anchor),Hr(e,!0)}x(e)}};Ar.set(e,t),Io(t,a)};if(e==null){let e=t.el=h(``),i=t.anchor=h(``);if(p(e,n,r),p(i,n,r),Pr(t.props)||a&&a.pendingBranch){S(t);return}v&&(b(t,n,i),Hr(t,!0)),x()}else{t.el=e.el;let r=t.anchor=e.anchor,u=Ar.get(e);if(u){u.flags|=8,Ar.delete(e),S(t);return}t.targetStart=e.targetStart;let p=t.target=e.target,h=t.targetAnchor=e.targetAnchor,g=Nr(e.props),_=g?n:p,b=g?r:h;if(o===`svg`||Fr(p)?o=`svg`:(o===`mathml`||Ir(p))&&(o=`mathml`),y?(f(e.dynamicChildren,y,_,i,a,o,s),Uo(e,t,!0)):c||d(e,t,_,b,i,a,o,s,!1),v)g?t.props&&e.props&&t.props.to!==e.props.to&&(t.props.to=e.props.to):zr(t,n,r,l,1);else if((t.props&&t.props.to)!==(e.props&&e.props.to)){let e=Lr(t.props,m);e&&(t.target=e,zr(t,e,null,l,0))}else g&&zr(t,p,h,l,1);Hr(t,v)}},remove(e,t,n,{um:r,o:{remove:i}},a){let{shapeFlag:o,children:s,anchor:c,targetStart:l,targetAnchor:u,target:d,props:f}=e,p=Nr(f),m=a||!p,h=Ar.get(e);if(h&&(h.flags|=8,Ar.delete(e)),d&&(i(l),i(u)),a&&i(c),!h&&(p||d)&&o&16)for(let e=0;e<s.length;e++){let i=s[e];r(i,t,n,m,!!i.dynamicChildren)}},move:zr,hydrate:Br};function zr(e,t,n,{o:{insert:r},m:i},a=2){a===0&&r(e.targetAnchor,t,n);let{el:o,anchor:s,shapeFlag:c,children:l,props:u}=e,d=a===2;if(d&&r(o,t,n),!Ar.has(e)&&(!d||Nr(u))&&c&16)for(let e=0;e<l.length;e++)i(l[e],t,n,2);d&&r(s,t,n)}function Br(e,t,n,r,i,a,{o:{nextSibling:o,parentNode:s,querySelector:c,insert:l,createText:u}},d){function f(e,n){let r=n;for(;r;){if(r&&r.nodeType===8){if(r.data===`teleport start anchor`)t.targetStart=r;else if(r.data===`teleport anchor`){t.targetAnchor=r,e._lpa=t.targetAnchor&&o(t.targetAnchor);break}}r=o(r)}}function p(e,t){t.anchor=d(o(e),t,s(e),n,r,i,a)}let m=t.target=Lr(t.props,c),h=Nr(t.props);if(m){let c=m._lpa||m.firstChild;t.shapeFlag&16&&(h?(p(e,t),f(m,c),t.targetAnchor||Ur(m,t,u,l,s(e)===m?e:null)):(t.anchor=o(e),f(m,c),t.targetAnchor||Ur(m,t,u,l),d(c&&o(c),t,m,n,r,i,a))),Hr(t,h)}else h&&t.shapeFlag&16&&(p(e,t),t.targetStart=e,t.targetAnchor=o(e));return t.anchor&&o(t.anchor)}var Vr=Rr;function Hr(e,t){let n=e.ctx;if(n&&n.ut){let r,i;for(t?(r=e.el,i=e.anchor):(r=e.targetStart,i=e.targetAnchor);r&&r!==i;)r.nodeType===1&&r.setAttribute(`data-v-owner`,n.uid),r=r.nextSibling;n.ut()}}function Ur(e,t,n,r,i=null){let a=t.targetStart=n(``),o=t.targetAnchor=n(``);return a[jr]=o,e&&(r(a,e,i),r(o,e,i)),o}var Wr=Symbol(`_leaveCb`),Gr=Symbol(`_enterCb`);function Kr(){let e={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return Zi(()=>{e.isMounted=!0}),ea(()=>{e.isUnmounting=!0}),e}var qr=[Function,Array],Jr={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:qr,onEnter:qr,onAfterEnter:qr,onEnterCancelled:qr,onBeforeLeave:qr,onLeave:qr,onAfterLeave:qr,onLeaveCancelled:qr,onBeforeAppear:qr,onAppear:qr,onAfterAppear:qr,onAppearCancelled:qr},Yr=e=>{let t=e.subTree;return t.component?Yr(t.component):t},Xr={name:`BaseTransition`,props:Jr,setup(e,{slots:t}){let n=Fs(),r=Kr();return()=>{let i=t.default&&ii(t.default(),!0),a=i&&i.length?Zr(i):n.subTree?Ts():void 0;if(!a)return;let o=A(e),{mode:s}=o;if(r.isLeaving)return ti(a);let c=ni(a);if(!c)return ti(a);let l=ei(c,o,r,n,e=>l=e);c.type!==cs&&ri(c,l);let u=n.subTree&&ni(n.subTree);if(u&&u.type!==cs&&!_s(u,c)&&Yr(n).type!==cs){let e=ei(u,o,r,n);if(ri(u,e),s===`out-in`&&c.type!==cs)return r.isLeaving=!0,e.afterLeave=()=>{r.isLeaving=!1,n.job.flags&8||n.update(),delete e.afterLeave,u=void 0},ti(a);s===`in-out`&&c.type!==cs?e.delayLeave=(e,t,n)=>{let i=$r(r,u);i[String(u.key)]=u,e[Wr]=()=>{t(),e[Wr]=void 0,delete l.delayedLeave,u=void 0},l.delayedLeave=()=>{n(),delete l.delayedLeave,u=void 0}}:u=void 0}else u&&=void 0;return a}}};function Zr(e){let t=e[0];if(e.length>1){for(let n of e)if(n.type!==cs){t=n;break}}return t}var Qr=Xr;function $r(e,t){let{leavingVNodes:n}=e,r=n.get(t.type);return r||(r=Object.create(null),n.set(t.type,r)),r}function ei(e,t,n,r,i){let{appear:a,mode:o,persisted:s=!1,onBeforeEnter:c,onEnter:l,onAfterEnter:u,onEnterCancelled:d,onBeforeLeave:f,onLeave:m,onAfterLeave:h,onLeaveCancelled:g,onBeforeAppear:_,onAppear:v,onAfterAppear:y,onAppearCancelled:b}=t,x=String(e.key),S=$r(n,e),C=(e,t)=>{e&&Hn(e,r,9,t)},w=(e,t)=>{let n=t[1];C(e,t),p(e)?e.every(e=>e.length<=1)&&n():e.length<=1&&n()},ee={mode:o,persisted:s,beforeEnter(t){let r=c;if(!n.isMounted){if(a)r=_||c;else return}t[Wr]&&t[Wr](!0);let i=S[x];i&&_s(e,i)&&i.el[Wr]&&i.el[Wr](),C(r,[t])},enter(t){if(S[x]===e)return;let r=l,i=u,o=d;if(!n.isMounted){if(a)r=v||l,i=y||u,o=b||d;else return}let s=!1;t[Gr]=e=>{s||(s=!0,C(e?o:i,[t]),ee.delayedLeave&&ee.delayedLeave(),t[Gr]=void 0)};let c=t[Gr].bind(null,!1);r?w(r,[t,c]):c()},leave(t,r){let i=String(e.key);if(t[Gr]&&t[Gr](!0),n.isUnmounting)return r();C(f,[t]);let a=!1;t[Wr]=n=>{a||(a=!0,r(),C(n?g:h,[t]),t[Wr]=void 0,S[i]===e&&delete S[i])};let o=t[Wr].bind(null,!1);S[i]=e,m?w(m,[t,o]):o()},clone(e){let a=ei(e,t,n,r,i);return i&&i(a),a}};return ee}function ti(e){if(zi(e))return e=Cs(e),e.children=null,e}function ni(e){if(!zi(e))return Mr(e.type)&&e.children?Zr(e.children):e;if(e.component)return e.component.subTree;let{shapeFlag:t,children:n}=e;if(n){if(t&16)return n[0];if(t&32&&v(n.default))return n.default()}}function ri(e,t){if(e.shapeFlag&6&&e.component){e.transition=t;let n=e.component.subTree;ri(Mr(n.type)&&ni(n)||n,t)}else e.shapeFlag&128?(e.ssContent.transition=t.clone(e.ssContent),e.ssFallback.transition=t.clone(e.ssFallback)):e.transition=t}function ii(e,t=!1,n){let r=[],i=0;for(let a=0;a<e.length;a++){let o=e[a],s=n==null?o.key:String(n)+String(o.key==null?a:o.key);o.type===L?(o.patchFlag&128&&i++,r=r.concat(ii(o.children,t,s))):(t||o.type!==cs)&&r.push(s==null?o:Cs(o,{key:s}))}if(i>1)for(let e=0;e<r.length;e++)r[e].patchFlag=-2;return r}function F(e,t){return v(e)?l({name:e.name},t,{setup:e}):e}function ai(){let e=Fs();return e?(e.appContext.config.idPrefix||`v`)+`-`+e.ids[0]+e.ids[1]++:``}function oi(e){e.ids=[e.ids[0]+e.ids[2]+++`-`,0,0]}function si(e){let t=Fs(),n=un(null);if(t){let i=t.refs===r?t.refs={}:t.refs;Object.defineProperty(i,e,{enumerable:!0,get:()=>n.value,set:e=>n.value=e})}return n}function ci(e,t){let n;return!!((n=Object.getOwnPropertyDescriptor(e,t))&&!n.configurable)}var li=new WeakMap;function ui(e,t,n,i,a=!1){if(p(e)){e.forEach((e,r)=>ui(e,t&&(p(t)?t[r]:t),n,i,a));return}if(Ii(i)&&!a){i.shapeFlag&512&&i.type.__asyncResolved&&i.component.subTree.component&&ui(e,t,n,i.component.subTree);return}let s=i.shapeFlag&4?Qs(i.component):i.el,c=a?null:s,{i:l,r:d}=e,m=t&&t.r,h=l.refs===r?l.refs={}:l.refs,g=l.setupState,_=A(g),b=g===r?o:e=>!ci(h,e)&&f(_,e),x=(e,t)=>!(t&&ci(h,t));if(m!=null&&m!==d){if(di(t),y(m))h[m]=null,b(m)&&(g[m]=null);else if(j(m)){let e=t;x(m,e.k)&&(m.value=null),e.k&&(h[e.k]=null)}}if(v(d))Vn(d,l,12,[c,h]);else{let t=y(d),r=j(d);if(t||r){let i=()=>{if(e.f){let n=t?b(d)?g[d]:h[d]:x(d)||!e.k?d.value:h[e.k];if(a)p(n)&&u(n,s);else if(p(n))n.includes(s)||n.push(s);else if(t)h[d]=[s],b(d)&&(g[d]=h[d]);else{let t=[s];x(d,e.k)&&(d.value=t),e.k&&(h[e.k]=t)}}else t?(h[d]=c,b(d)&&(g[d]=c)):r&&(x(d,e.k)&&(d.value=c),e.k&&(h[e.k]=c))};if(c){let t=()=>{i(),li.delete(e)};t.id=-1,li.set(e,t),Io(t,n)}else di(e),i()}}}function di(e){let t=li.get(e);t&&(t.flags|=8,li.delete(e))}var fi=!1,pi=()=>{fi||=(console.error(`Hydration completed but contains mismatches.`),!0)},mi=e=>e.namespaceURI.includes(`svg`)&&e.tagName!==`foreignObject`,hi=e=>e.namespaceURI.includes(`MathML`),gi=e=>{if(e.nodeType===1){if(mi(e))return`svg`;if(hi(e))return`mathml`}},_i=e=>e.nodeType===8;function vi(e){let{mt:t,p:n,o:{patchProp:r,createText:i,nextSibling:a,parentNode:o,remove:c,insert:l,createComment:u}}=e,d=(e,t)=>{if(!t.hasChildNodes()){n(null,e,t),ir(),t._vnode=e;return}f(t.firstChild,e,null,null,null),ir(),t._vnode=e},f=(n,r,s,c,u,d=!1)=>{d||=!!r.dynamicChildren;let b=_i(n)&&n.data===`[`,x=()=>g(n,r,s,c,u,b),{type:S,ref:C,shapeFlag:w,patchFlag:ee}=r,te=n.nodeType;r.el=n,ee===-2&&(d=!1,r.dynamicChildren=null);let T=null;switch(S){case ss:te===3?(n.data!==r.children&&(pi(),n.data=r.children),T=a(n)):r.children===``?(l(r.el=i(``),o(n),n),T=n):T=x();break;case cs:y(n)?(T=a(n),v(r.el=n.content.firstChild,n,s)):T=te!==8||b?x():a(n);break;case ls:if(b&&(n=a(n),te=n.nodeType),te===1||te===3){T=n;let e=!r.children.length;for(let t=0;t<r.staticCount;t++)e&&(r.children+=T.nodeType===1?T.outerHTML:T.data),t===r.staticCount-1&&(r.anchor=T),T=a(T);return b?a(T):T}x();break;case L:T=b?h(n,r,s,c,u,d):x();break;default:if(w&1)T=(te!==1||r.type.toLowerCase()!==n.tagName.toLowerCase())&&!y(n)?x():p(n,r,s,c,u,d);else if(w&6){r.slotScopeIds=u;let e=o(n);if(T=b?_(n):_i(n)&&n.data===`teleport start`?_(n,n.data,`teleport end`):a(n),t(r,e,null,s,c,gi(e),d),Ii(r)&&!r.type.__asyncResolved){let t;b?(t=H(L),t.anchor=T?T.previousSibling:e.lastChild):t=n.nodeType===3?U(``):H(`div`),t.el=n,r.component.subTree=t}}else w&64?T=te===8?r.type.hydrate(n,r,s,c,u,d,e,m):x():w&128&&(T=r.type.hydrate(n,r,s,c,gi(o(n)),u,d,e,f))}return C!=null&&ui(C,null,c,r),T},p=(e,t,n,i,a,o)=>{o||=!!t.dynamicChildren;let{type:l,dynamicProps:u,props:d,patchFlag:f,shapeFlag:p,dirs:h,transition:g}=t,_=l===`input`||l===`option`,b=!!u;if(_||b||f!==-1){h&&_r(t,null,n,`created`);let l=!1;if(y(e)){l=Ho(null,g)&&n&&n.vnode.props&&n.vnode.props.appear;let r=e.content.firstChild;if(l){let e=r.getAttribute(`class`);e&&(r.$cls=e),g.beforeEnter(r)}v(r,e,n),t.el=e=r}if(p&16&&!(d&&(d.innerHTML||d.textContent))){let r=m(e.firstChild,t,e,n,i,a,o);for(r&&!Ci(e,1)&&pi();r;){let e=r;r=r.nextSibling,c(e)}}else if(p&8){let n=t.children;n[0]===`
`&&(e.tagName===`PRE`||e.tagName===`TEXTAREA`)&&(n=n.slice(1));let{textContent:r}=e;r!==n&&r!==n.replace(/\r\n|\r/g,`
`)&&(Ci(e,0)||pi(),e.textContent=t.children)}if(d){if(_||b||!o||f&48){let t=e.tagName.includes(`-`),i=e.namespaceURI.includes(`svg`)?`svg`:e.namespaceURI.includes(`MathML`)?`mathml`:void 0;for(let a in d)if(_&&(a.endsWith(`value`)||a===`indeterminate`)||s(a)&&!ne(a)||a[0]===`.`||t&&!ne(a)||u&&u.includes(a)){if(bi(e,a,d[a]))continue;r(e,a,null,d[a],i,n)}}else if(d.onClick)r(e,`onClick`,null,d.onClick,void 0,n);else if(f&4&&nn(d.style))for(let e in d.style)d.style[e]}let x;(x=d&&d.onVnodeBeforeMount)&&As(x,n,t),h&&_r(t,null,n,`beforeMount`),((x=d&&d.onVnodeMounted)||h||l)&&is(()=>{x&&As(x,n,t),l&&g.enter(e),h&&_r(t,null,n,`mounted`)},i)}return e.nextSibling},m=(e,t,r,o,s,c,u)=>{u||=!!t.dynamicChildren;let d=t.children,p=d.length,m=!1;for(let t=0;t<p;t++){let h=u?d[t]:d[t]=Es(d[t]),g=h.type===ss;e?(g&&!u&&t+1<p&&Es(d[t+1]).type===ss&&(l(i(e.data.slice(h.children.length)),r,a(e)),e.data=h.children),e=f(e,h,o,s,c,u)):g&&!h.children?l(h.el=i(``),r):(m||(m=!0,Ci(r,1)||pi()),n(null,h,r,null,o,s,gi(r),c))}return e},h=(e,t,n,r,i,s)=>{let{slotScopeIds:c}=t;c&&(i=i?i.concat(c):c);let d=o(e),f=m(a(e),t,d,n,r,i,s);return f&&_i(f)&&f.data===`]`?a(t.anchor=f):(pi(),l(t.anchor=u(`]`),d,f),f)},g=(e,t,r,i,s,l)=>{if(Ti(e,t)||pi(),t.el=null,l){let t=_(e);for(;;){let n=a(e);if(n&&n!==t)c(n);else break}}let u=a(e),d=o(e);return c(e),n(null,t,d,u,r,i,gi(d),s),r&&(r.vnode.el=t.el,_o(r,t.el)),u},_=(e,t=`[`,n=`]`)=>{let r=0;for(;e;)if(e=a(e),e&&_i(e)&&(e.data===t&&r++,e.data===n)){if(r===0)return a(e);r--}return e},v=(e,t,n)=>{let r=t.parentNode;r&&r.replaceChild(e,t);let i=n;for(;i;)i.vnode.el===t&&(i.vnode.el=i.subTree.el=e),i=i.parent},y=e=>e.nodeType===1&&e.tagName===`TEMPLATE`;return[d,f]}var yi=new Set([`src`,`srcset`,`href`,`poster`]);function bi(e,t,n){return yi.has(t)?e.getAttribute(t)===(n==null?null:`${n}`):!1}var xi=`data-allow-mismatch`,Si={0:`text`,1:`children`,2:`class`,3:`style`,4:`attribute`};function Ci(e,t){if(t===0||t===1)for(;e&&!e.hasAttribute(xi);)e=e.parentElement;return wi(e&&e.getAttribute(xi),t)}function wi(e,t){if(e==null)return!1;if(e===``)return!0;{let n=e.split(`,`);return t===0&&n.includes(`children`)?!0:n.includes(Si[t])}}function Ti(e,t){return Ci(e.parentElement,1)||Ei(e)||Di(t)}function Ei(e){return e.nodeType===1&&wi(e.getAttribute(xi),1)}function Di({props:e}){let t=e&&e[xi];return typeof t==`string`&&wi(t,1)}var Oi=me().requestIdleCallback||(e=>setTimeout(e,1)),ki=me().cancelIdleCallback||(e=>clearTimeout(e)),Ai=(e=1e4)=>t=>{let n=Oi(t,{timeout:e});return()=>ki(n)};function ji(e){let{top:t,left:n,bottom:r,right:i}=e.getBoundingClientRect(),{innerHeight:a,innerWidth:o}=window;return(t>0&&t<a||r>0&&r<a)&&(n>0&&n<o||i>0&&i<o)}var Mi=e=>(t,n)=>{let r=new IntersectionObserver(e=>{for(let n of e)if(n.isIntersecting){r.disconnect(),t();break}},e);return n(e=>{if(e instanceof Element){if(ji(e))return t(),r.disconnect(),!1;r.observe(e)}}),()=>r.disconnect()},Ni=e=>t=>{if(e){let n=matchMedia(e);if(n.matches)t();else return n.addEventListener(`change`,t,{once:!0}),()=>n.removeEventListener(`change`,t)}},Pi=(e=[])=>(t,n)=>{y(e)&&(e=[e]);let r=!1,i=e=>{r||(r=!0,a(),t(),e.target.dispatchEvent(new e.constructor(e.type,e)))},a=()=>{n(t=>{for(let n of e)t.removeEventListener(n,i)})};return n(t=>{for(let n of e)t.addEventListener(n,i,{once:!0})}),a};function Fi(e,t){if(_i(e)&&e.data===`[`){let n=1,r=e.nextSibling;for(;r;){if(r.nodeType===1){if(t(r)===!1)break}else if(_i(r)){if(r.data===`]`){if(--n===0)break}else r.data===`[`&&n++}r=r.nextSibling}}else t(e)}var Ii=e=>!!e.type.__asyncLoader;function Li(e){v(e)&&(e={loader:e});let{loader:t,loadingComponent:n,errorComponent:r,delay:i=200,hydrate:a,timeout:o,suspensible:s=!0,onError:c}=e,l=null,u,d=0,f=()=>(d++,l=null,p()),p=()=>{let e;return l||(e=l=t().catch(e=>{if(e=e instanceof Error?e:Error(String(e)),c)return new Promise((t,n)=>{c(e,()=>t(f()),()=>n(e),d+1)});throw e}).then(t=>e!==l&&l?l:(t&&(t.__esModule||t[Symbol.toStringTag]===`Module`)&&(t=t.default),u=t,t)))};return F({name:`AsyncComponentWrapper`,__asyncLoader:p,__asyncHydrate(e,t,n){let r=e.isConnected,i=!1;(t.bu||=[]).push(()=>i=!0);let o=()=>{i||!e.parentNode||r&&!e.isConnected||n()},s=a?()=>{let n=a(o,t=>Fi(e,t));n&&(t.bum||=[]).push(n)}:o;u?s():p().then(()=>!t.isUnmounted&&s())},get __asyncResolved(){return u},setup(){let e=Ps;if(oi(e),u)return()=>Ri(u,e);let t=t=>{l=null,Un(t,e,13,!r)};if(s&&e.suspense||Vs)return p().then(t=>()=>Ri(t,e)).catch(e=>(t(e),()=>r?H(r,{error:e}):null));let a=M(!1),c=M(),d=M(!!i),f,m;return ta(()=>{f!=null&&clearTimeout(f),m!=null&&clearTimeout(m)}),i&&(m=setTimeout(()=>{e.isUnmounted||(d.value=!1)},i)),o!=null&&(f=setTimeout(()=>{if(!e.isUnmounted&&!a.value&&!c.value){let e=Error(`Async component timed out after ${o}ms.`);t(e),c.value=e}},o)),p().then(()=>{e.isUnmounted||(a.value=!0,e.parent&&zi(e.parent.vnode)&&e.parent.update())}).catch(n=>{if(e.isUnmounted){l=null;return}t(n),c.value=n}),()=>{if(a.value&&u)return Ri(u,e);if(c.value&&r)return H(r,{error:c.value});if(n&&!d.value)return Ri(n,e)}}})}function Ri(e,t){let{ref:n,props:r,children:i,ce:a}=t.vnode,o=H(e,r,i);return o.ref=n,o.ce=a,delete t.vnode.ce,o}var zi=e=>e.type.__isKeepAlive,Bi={name:`KeepAlive`,__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(e,{slots:t}){let n=Fs(),r=n.ctx;if(!r.renderer)return()=>{let e=t.default&&t.default();return e&&e.length===1?e[0]:e};let i=new Map,a=new Set,o=null,s=n.suspense,{renderer:{p:c,m:l,um:u,o:{createElement:d}}}=r,f=d(`div`);r.activate=(e,t,n,r,i)=>{let a=e.component;l(e,t,n,0,s),c(a.vnode,e,t,n,a,s,r,e.slotScopeIds,i),Io(()=>{a.isDeactivated=!1,a.a&&le(a.a);let t=e.props&&e.props.onVnodeMounted;t&&As(t,a.parent,e)},s)},r.deactivate=e=>{let t=e.component;Ko(t.m),Ko(t.a),l(e,f,null,1,s),Io(()=>{t.da&&le(t.da);let n=e.props&&e.props.onVnodeUnmounted;n&&As(n,t.parent,e),t.isDeactivated=!0},s)};function p(e){Ki(e),u(e,n,s,!0)}function m(e){i.forEach((t,n)=>{let r=$s(Ii(t)?t.type.__asyncResolved||{}:t.type);r&&!e(r)&&h(n)})}function h(e){let t=i.get(e);t&&(!o||!_s(t,o))?p(t):o&&Ki(o),i.delete(e),a.delete(e)}Er(()=>[e.include,e.exclude],([e,t])=>{e&&m(t=>Vi(e,t)),t&&m(e=>!Vi(t,e))},{flush:`post`,deep:!0});let g=null,_=()=>{g!=null&&(Jo(n.subTree.type)?Io(()=>{i.set(g,qi(n.subTree))},n.subTree.suspense):i.set(g,qi(n.subTree)))};return Zi(_),$i(_),ea(()=>{i.forEach(e=>{let{subTree:t,suspense:r}=n,i=qi(t);if(e.type===i.type&&e.key===i.key){Ki(i);let e=i.component.da;e&&Io(e,r);return}p(e)})}),()=>{if(g=null,!t.default)return o=null;let n=t.default(),r=n[0];if(n.length>1)return o=null,n;if(!gs(r)||!(r.shapeFlag&4)&&!(r.shapeFlag&128))return o=null,r;let s=qi(r);if(s.type===cs)return o=null,s;let c=s.type,l=$s(Ii(s)?s.type.__asyncResolved||{}:c),{include:u,exclude:d,max:f}=e;if(u&&(!l||!Vi(u,l))||d&&l&&Vi(d,l))return s.shapeFlag&=-257,o=s,r;let p=s.key==null?c:s.key,m=i.get(p);return s.el&&(s=Cs(s),r.shapeFlag&128&&(r.ssContent=s)),g=p,m?(s.el=m.el,s.component=m.component,s.transition&&ri(s,s.transition),s.shapeFlag|=512,a.delete(p),a.add(p)):(a.add(p),f&&a.size>parseInt(f,10)&&h(a.values().next().value)),s.shapeFlag|=256,o=s,Jo(r.type)?r:s}}};function Vi(e,t){return p(e)?e.some(e=>Vi(e,t)):y(e)?e.split(`,`).includes(t):_(e)?(e.lastIndex=0,e.test(t)):!1}function Hi(e,t){Wi(e,`a`,t)}function Ui(e,t){Wi(e,`da`,t)}function Wi(e,t,n=Ps){let r=e.__wdc||=()=>{let t=n;for(;t;){if(t.isDeactivated)return;t=t.parent}return e()};if(Ji(t,r,n),n){let e=n.parent;for(;e&&e.parent;)zi(e.parent.vnode)&&Gi(r,t,n,e),e=e.parent}}function Gi(e,t,n,r){let i=Ji(t,e,r,!0);ta(()=>{u(r[t],i)},n)}function Ki(e){e.shapeFlag&=-257,e.shapeFlag&=-513}function qi(e){return e.shapeFlag&128?e.ssContent:e}function Ji(e,t,n=Ps,r=!1){if(n){let i=n[e]||(n[e]=[]),a=t.__weh||=(...r)=>{nt();let i=Rs(n),a=Hn(t,n,e,r);return i(),rt(),a};return r?i.unshift(a):i.push(a),a}}var Yi=e=>(t,n=Ps)=>{(!Vs||e===`sp`)&&Ji(e,(...e)=>t(...e),n)},Xi=Yi(`bm`),Zi=Yi(`m`),Qi=Yi(`bu`),$i=Yi(`u`),ea=Yi(`bum`),ta=Yi(`um`),na=Yi(`sp`),ra=Yi(`rtg`),ia=Yi(`rtc`);function aa(e,t=Ps){Ji(`ec`,e,t)}var oa=`components`,sa=`directives`;function ca(e,t){return fa(oa,e,!0,t)||e}var la=Symbol.for(`v-ndc`);function ua(e){return y(e)?fa(oa,e,!1)||e:e||la}function da(e){return fa(sa,e)}function fa(e,t,n=!0,r=!1){let i=ur||Ps;if(i){let n=i.type;if(e===oa){let e=$s(n,!1);if(e&&(e===t||e===E(t)||e===se(E(t))))return n}let a=pa(i[e]||n[e],t)||pa(i.appContext[e],t);return!a&&r?n:a}}function pa(e,t){return e&&(e[t]||e[E(t)]||e[se(E(t))])}function ma(e,t,n,r){let i,a=n&&n[r],o=p(e);if(o||y(e)){let n=o&&nn(e),r=!1,s=!1;n&&(r=!an(e),s=rn(e),e=_t(e)),i=Array(e.length);for(let n=0,o=e.length;n<o;n++)i[n]=t(r?s?ln(cn(e[n])):cn(e[n]):e[n],n,void 0,a&&a[n])}else if(typeof e==`number`){i=Array(e);for(let n=0;n<e;n++)i[n]=t(n+1,n,void 0,a&&a[n])}else if(x(e)){if(e[Symbol.iterator])i=Array.from(e,(e,n)=>t(e,n,void 0,a&&a[n]));else{let n=Object.keys(e);i=Array(n.length);for(let r=0,o=n.length;r<o;r++){let o=n[r];i[r]=t(e[o],o,r,a&&a[r])}}}else i=[];return n&&(n[r]=i),i}function ha(e,t){for(let n=0;n<t.length;n++){let r=t[n];if(p(r))for(let t=0;t<r.length;t++)e[r[t].name]=r[t].fn;else r&&(e[r.name]=r.key?(...e)=>{let t=r.fn(...e);return t&&(t.key=r.key),t}:r.fn)}return e}function I(e,t,n,r,i,a){if(n??={},ur.ce||ur.parent&&Ii(ur.parent)&&ur.parent.ce){let e=a!=null&&n.key==null?l({},n,{key:a}):n,i=Object.keys(e).length>0;return t!=="default"&&(e.name=t),R(),B(L,null,[H(`slot`,e,r&&r())],i?-2:64)}let o=e[t];o&&o._c&&(o._d=!1);let s=us.length;R();let c;try{let i=o&&ga(o(n)),s=n.key||a||i&&i.key;c=B(L,{key:(s&&!b(s)?s:`_${t}`)+(!i&&r?`_fb`:``)},i||(r?r():[]),i&&e._===1?64:-2)}catch(e){for(let e=us.length;e>s;e--)fs();throw e}finally{o&&o._c&&(o._d=!0)}return!i&&c.scopeId&&(c.slotScopeIds=[c.scopeId+`-s`]),c}function ga(e){return e.some(e=>!gs(e)||!(e.type===cs||e.type===L&&!ga(e.children)))?e:null}function _a(e,t){let n={};for(let r in e)n[t&&/[A-Z]/.test(r)?`on:${r}`:ce(r)]=e[r];return n}var va=e=>e?Bs(e)?Qs(e):va(e.parent):null,ya=l(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>e.props,$attrs:e=>e.attrs,$slots:e=>e.slots,$refs:e=>e.refs,$parent:e=>va(e.parent),$root:e=>va(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>Ua(e),$forceUpdate:e=>e.f||=()=>{er(e.update)},$nextTick:e=>e.n||=Qn.bind(e.proxy),$watch:e=>Or.bind(e)}),ba=(e,t)=>e!==r&&!e.__isScriptSetup&&f(e,t),xa={get({_:e},t){if(t===`__v_skip`)return!0;let{ctx:n,setupState:i,data:a,props:o,accessCache:s,type:c,appContext:l}=e;if(t[0]!==`$`){let e=s[t];if(e!==void 0)switch(e){case 1:return i[t];case 2:return a[t];case 4:return n[t];case 3:return o[t]}else if(ba(i,t))return s[t]=1,i[t];else if(a!==r&&f(a,t))return s[t]=2,a[t];else if(f(o,t))return s[t]=3,o[t];else if(n!==r&&f(n,t))return s[t]=4,n[t];else Ra&&(s[t]=0)}let u=ya[t],d,p;if(u)return t===`$attrs`&&pt(e.attrs,`get`,``),u(e);if((d=c.__cssModules)&&(d=d[t]))return d;if(n!==r&&f(n,t))return s[t]=4,n[t];if(p=l.config.globalProperties,f(p,t))return p[t]},set({_:e},t,n){let{data:i,setupState:a,ctx:o}=e;return ba(a,t)?(a[t]=n,!0):i!==r&&f(i,t)?(i[t]=n,!0):f(e.props,t)||t[0]===`$`&&t.slice(1)in e?!1:(o[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:i,appContext:a,props:o,type:s}},c){let l;return!!(n[c]||e!==r&&c[0]!==`$`&&f(e,c)||ba(t,c)||f(o,c)||f(i,c)||f(ya,c)||f(a.config.globalProperties,c)||(l=s.__cssModules)&&l[c])},defineProperty(e,t,n){return n.get==null?f(n,`value`)&&this.set(e,t,n.value,null):e._.accessCache[t]=0,Reflect.defineProperty(e,t,n)}},Sa=l({},xa,{get(e,t){if(t!==Symbol.unscopables)return xa.get(e,t,e)},has(e,t){return t[0]!==`_`&&!he(t)}});function Ca(){return null}function wa(){return null}function Ta(e){}function Ea(e){}function Da(){return null}function Oa(){}function ka(e,t){return null}function Aa(){return Ma(`useSlots`).slots}function ja(){return Ma(`useAttrs`).attrs}function Ma(e){let t=Fs();return t.setupContext||=Zs(t)}function Na(e){return p(e)?e.reduce((e,t)=>(e[t]=null,e),{}):e}function Pa(e,t){let n=Na(e);for(let e in t){if(e.startsWith(`__skip`))continue;let r=n[e];r?p(r)||v(r)?r=n[e]={type:r,default:t[e]}:r.default=t[e]:r===null&&(r=n[e]={default:t[e]}),r&&t[`__skip_${e}`]&&(r.skipFactory=!0)}return n}function Fa(e,t){return!e||!t?e||t:p(e)&&p(t)?e.concat(t):l({},Na(e),Na(t))}function Ia(e,t){let n={};for(let r in e)t.includes(r)||Object.defineProperty(n,r,{enumerable:!0,get:()=>e[r]});return n}function La(e){let t=Fs(),n=Vs,r=e();zs(),n&&Ls(!1);let i=()=>{Rs(t),n&&Ls(!0)},a=()=>{Fs()!==t&&t.scope.off(),zs(),n&&Ls(!1)};return S(r)&&(r=r.catch(e=>{throw i(),Promise.resolve().then(()=>Promise.resolve().then(a)),e})),[r,()=>{i(),Promise.resolve().then(a)}]}var Ra=!0;function za(e){let t=Ua(e),n=e.proxy,r=e.ctx;Ra=!1,t.beforeCreate&&Va(t.beforeCreate,e,`bc`);let{data:i,computed:o,methods:s,watch:c,provide:l,inject:u,created:d,beforeMount:f,mounted:m,beforeUpdate:h,updated:g,activated:_,deactivated:y,beforeDestroy:b,beforeUnmount:S,destroyed:C,unmounted:w,render:ee,renderTracked:te,renderTriggered:T,errorCaptured:ne,serverPrefetch:re,expose:ie,inheritAttrs:E,components:ae,directives:oe,filters:se}=t;if(u&&Ba(u,r,null),s)for(let e in s){let t=s[e];v(t)&&(r[e]=t.bind(n))}if(i){let t=i.call(n,n);x(t)&&(e.data=Zt(t))}if(Ra=!0,o)for(let e in o){let t=o[e],i=W({get:v(t)?t.bind(n,n):v(t.get)?t.get.bind(n,n):a,set:!v(t)&&v(t.set)?t.set.bind(n):a});Object.defineProperty(r,e,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e})}if(c)for(let e in c)Ha(c[e],r,n,e);if(l){let e=v(l)?l.call(n):l;Reflect.ownKeys(e).forEach(t=>{vr(t,e[t])})}d&&Va(d,e,`c`);function ce(e,t){p(t)?t.forEach(t=>e(t.bind(n))):t&&e(t.bind(n))}if(ce(Xi,f),ce(Zi,m),ce(Qi,h),ce($i,g),ce(Hi,_),ce(Ui,y),ce(aa,ne),ce(ia,te),ce(ra,T),ce(ea,S),ce(ta,w),ce(na,re),p(ie)){if(ie.length){let t=e.exposed||={};ie.forEach(e=>{Object.defineProperty(t,e,{get:()=>n[e],set:t=>n[e]=t,enumerable:!0})})}else e.exposed||={}}ee&&e.render===a&&(e.render=ee),E!=null&&(e.inheritAttrs=E),ae&&(e.components=ae),oe&&(e.directives=oe),re&&oi(e)}function Ba(e,t,n=a){p(e)&&(e=Ja(e));for(let n in e){let r=e[n],i;i=x(r)?`default`in r?yr(r.from||n,r.default,!0):yr(r.from||n):yr(r),j(i)?Object.defineProperty(t,n,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e}):t[n]=i}}function Va(e,t,n){Hn(p(e)?e.map(e=>e.bind(t.proxy)):e.bind(t.proxy),t,n)}function Ha(e,t,n,r){let i=r.includes(`.`)?kr(n,r):()=>n[r];if(y(e)){let n=t[e];v(n)&&Er(i,n)}else if(v(e))Er(i,e.bind(n));else if(x(e)){if(p(e))e.forEach(e=>Ha(e,t,n,r));else{let r=v(e.handler)?e.handler.bind(n):t[e.handler];v(r)&&Er(i,r,e)}}}function Ua(e){let t=e.type,{mixins:n,extends:r}=t,{mixins:i,optionsCache:a,config:{optionMergeStrategies:o}}=e.appContext,s=a.get(t),c;return s?c=s:!i.length&&!n&&!r?c=t:(c={},i.length&&i.forEach(e=>Wa(c,e,o,!0)),Wa(c,t,o)),x(t)&&a.set(t,c),c}function Wa(e,t,n,r=!1){let{mixins:i,extends:a}=t;a&&Wa(e,a,n,!0),i&&i.forEach(t=>Wa(e,t,n,!0));for(let i in t)if(!(r&&i===`expose`)){let r=Ga[i]||n&&n[i];e[i]=r?r(e[i],t[i]):t[i]}return e}var Ga={data:Ka,props:Za,emits:Za,methods:Xa,computed:Xa,beforeCreate:Ya,created:Ya,beforeMount:Ya,mounted:Ya,beforeUpdate:Ya,updated:Ya,beforeDestroy:Ya,beforeUnmount:Ya,destroyed:Ya,unmounted:Ya,activated:Ya,deactivated:Ya,errorCaptured:Ya,serverPrefetch:Ya,components:Xa,directives:Xa,watch:Qa,provide:Ka,inject:qa};function Ka(e,t){return t?e?function(){return l(v(e)?e.call(this,this):e,v(t)?t.call(this,this):t)}:t:e}function qa(e,t){return Xa(Ja(e),Ja(t))}function Ja(e){if(p(e)){let t={};for(let n=0;n<e.length;n++)t[e[n]]=e[n];return t}return e}function Ya(e,t){return e?[...new Set([].concat(e,t))]:t}function Xa(e,t){return e?l(Object.create(null),e,t):t}function Za(e,t){return e?p(e)&&p(t)?[...new Set([...e,...t])]:l(Object.create(null),Na(e),Na(t??{})):t}function Qa(e,t){if(!e)return t;if(!t)return e;let n=l(Object.create(null),e);for(let r in t)n[r]=Ya(e[r],t[r]);return n}function $a(){return{app:null,config:{isNativeTag:o,performance:!1,globalProperties:{},optionMergeStrategies:{},errorHandler:void 0,warnHandler:void 0,compilerOptions:{}},mixins:[],components:{},directives:{},provides:Object.create(null),optionsCache:new WeakMap,propsCache:new WeakMap,emitsCache:new WeakMap}}var eo=0;function to(e,t){return function(n,r=null){v(n)||(n=l({},n)),r!=null&&!x(r)&&(r=null);let i=$a(),a=new WeakSet,o=[],s=!1,c=i.app={_uid:eo++,_component:n,_props:r,_container:null,_context:i,_instance:null,version:ac,get config(){return i.config},set config(e){},use(e,...t){return a.has(e)||(e&&v(e.install)?(a.add(e),e.install(c,...t)):v(e)&&(a.add(e),e(c,...t))),c},mixin(e){return i.mixins.includes(e)||i.mixins.push(e),c},component(e,t){return t?(i.components[e]=t,c):i.components[e]},directive(e,t){return t?(i.directives[e]=t,c):i.directives[e]},mount(a,o,l){if(!s){let u=c._ceVNode||H(n,r);return u.appContext=i,l===!0?l=`svg`:l===!1&&(l=void 0),o&&t?t(u,a):e(u,a,l),s=!0,c._container=a,a.__vue_app__=c,Qs(u.component)}},onUnmount(e){o.push(e)},unmount(){s&&(Hn(o,c._instance,16),e(null,c._container),delete c._container.__vue_app__)},provide(e,t){return i.provides[e]=t,c},runWithContext(e){let t=no;no=c;try{return e()}finally{no=t}}};return c}}var no=null;function ro(e,t,n=r){let i=Fs(),a=E(t),o=oe(t),s=io(e,a),c=vn((s,c)=>{let l,u=r,d;return Tr(()=>{let t=e[a];D(l,t)&&(l=t,c())}),{get(){return s(),n.get?n.get(l):l},set(e){let s=n.set?n.set(e):e;if(!D(s,l)&&!(u!==r&&D(e,u)))return;let f=i.vnode.props,p=!!(f&&(t in f||a in f||o in f)&&(`onUpdate:${t}`in f||`onUpdate:${a}`in f||`onUpdate:${o}`in f));p||(l=e,c()),i.emit(`update:${t}`,s),D(e,u)&&(D(e,s)&&!D(s,d)||p&&u!==r&&!D(s,l))&&c(),u=e,d=s}}});return c[Symbol.iterator]=()=>{let e=0;return{next(){return e<2?{value:e++?s||r:c,done:!1}:{done:!0}}}},c}var io=(e,t)=>t===`modelValue`||t===`model-value`?e.modelModifiers:e[`${t}Modifiers`]||e[`${E(t)}Modifiers`]||e[`${oe(t)}Modifiers`];function ao(e,t,...n){if(e.isUnmounted)return;let i=e.vnode.props||r,a=n,o=t.startsWith(`update:`),s=o&&io(i,t.slice(7));s&&(s.trim&&(a=n.map(e=>y(e)?e.trim():e)),s.number&&(a=n.map(de)));let c,l=i[c=ce(t)]||i[c=ce(E(t))];!l&&o&&(l=i[c=ce(oe(t))]),l&&Hn(l,e,6,a);let u=i[c+`Once`];if(u){if(!e.emitted)e.emitted={};else if(e.emitted[c])return;e.emitted[c]=!0,Hn(u,e,6,a)}}var oo=new WeakMap;function so(e,t,n=!1){let r=n?oo:t.emitsCache,i=r.get(e);if(i!==void 0)return i;let a=e.emits,o={},s=!1;if(!v(e)){let r=e=>{let n=so(e,t,!0);n&&(s=!0,l(o,n))};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}return!a&&!s?(x(e)&&r.set(e,null),null):(p(a)?a.forEach(e=>o[e]=null):l(o,a),x(e)&&r.set(e,o),o)}function co(e,t){return!e||!s(t)?!1:(t=t.slice(2),t=t===`Once`?t:t.replace(/Once$/,``),f(e,t[0].toLowerCase()+t.slice(1))||f(e,oe(t))||f(e,t))}function lo(e){let{type:t,vnode:n,proxy:r,withProxy:i,propsOptions:[a],slots:o,attrs:s,emit:l,render:u,renderCache:d,props:f,data:p,setupState:m,ctx:h,inheritAttrs:g}=e,_=fr(e),v,y;try{if(n.shapeFlag&4){let e=i||r,t=e;v=Es(u.call(t,e,d,f,m,p,h)),y=s}else{let e=t;v=Es(e.length>1?e(f,{attrs:s,slots:o,emit:l}):e(f,null)),y=t.props?s:fo(s)}}catch(t){us.length=0,Un(t,e,1),v=H(cs)}let b=v;if(y&&g!==!1){let e=Object.keys(y),{shapeFlag:t}=b;e.length&&t&7&&(a&&e.some(c)&&(y=po(y,a)),b=Cs(b,y,!1,!0))}return n.dirs&&(b=Cs(b,null,!1,!0),b.dirs=b.dirs?b.dirs.concat(n.dirs):n.dirs),n.transition&&ri(Mr(b.type)&&ni(b)||b,n.transition),v=b,fr(_),v}function uo(e,t=!0){let n;for(let t=0;t<e.length;t++){let r=e[t];if(gs(r)){if(r.type!==cs||r.children===`v-if`){if(n)return;n=r}}else return}return n}var fo=e=>{let t;for(let n in e)(n===`class`||n===`style`||s(n))&&((t||={})[n]=e[n]);return t},po=(e,t)=>{let n={};for(let r in e)(!c(r)||!(r.slice(9)in t))&&(n[r]=e[r]);return n};function mo(e,t,n){let{props:r,children:i,component:a}=e,{props:o,children:s,patchFlag:c}=t,l=a.emitsOptions;if(t.dirs||t.transition)return!0;if(n&&c>=0){if(c&1024)return!0;if(c&16)return r?ho(r,o,l):!!o;if(c&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let n=e[t];if(go(o,r,n)&&!co(l,n))return!0}}}else return(i||s)&&(!s||!s.$stable)?!0:r===o?!1:r?!o||ho(r,o,l):!!o;return!1}function ho(e,t,n){let r=Object.keys(t);if(r.length!==Object.keys(e).length)return!0;for(let i=0;i<r.length;i++){let a=r[i];if(go(t,e,a)&&!co(n,a))return!0}return!1}function go(e,t,n){let r=e[n],i=t[n];return n===`style`&&x(r)&&x(i)?!Ee(r,i):r!==i}function _o({vnode:e,parent:t,suspense:n},r){for(;t;){let n=t.subTree;if(n.suspense&&n.suspense.activeBranch===e&&(n.suspense.vnode.el=n.el=r,e=n),n===e)(e=t.vnode).el=r,t=t.parent;else break}n&&n.activeBranch===e&&(n.vnode.el=r)}var vo={},yo=()=>Object.create(vo),bo=e=>Object.getPrototypeOf(e)===vo;function xo(e,t,n,r=!1){let i={},a=yo();e.propsDefaults=Object.create(null),Co(e,t,i,a);for(let t in e.propsOptions[0])t in i||(i[t]=void 0);e.props=n?r?i:Qt(i):e.type.props?i:a,e.attrs=a}function So(e,t,n,r){let{props:i,attrs:a,vnode:{patchFlag:o}}=e,s=A(i),[c]=e.propsOptions,l=!1;if((r||o>0)&&!(o&16)){if(o&8){let n=e.vnode.dynamicProps;for(let r=0;r<n.length;r++){let o=n[r];if(co(e.emitsOptions,o))continue;let u=t[o];if(c){if(f(a,o))u!==a[o]&&(a[o]=u,l=!0);else{let t=E(o);i[t]=wo(c,s,t,u,e,!1)}}else u!==a[o]&&(a[o]=u,l=!0)}}}else{Co(e,t,i,a)&&(l=!0);let r;for(let a in s)(!t||!f(t,a)&&((r=oe(a))===a||!f(t,r)))&&(c?n&&(n[a]!==void 0||n[r]!==void 0)&&(i[a]=wo(c,s,a,void 0,e,!0)):delete i[a]);if(a!==s)for(let e in a)(!t||!f(t,e))&&(delete a[e],l=!0)}l&&mt(e.attrs,`set`,``)}function Co(e,t,n,i){let[a,o]=e.propsOptions,s=!1,c;if(t)for(let r in t){if(ne(r))continue;let l=t[r],u;a&&f(a,u=E(r))?!o||!o.includes(u)?n[u]=l:(c||={})[u]=l:co(e.emitsOptions,r)||(!(r in i)||l!==i[r])&&(i[r]=l,s=!0)}if(o){let t=A(n),i=c||r;for(let r=0;r<o.length;r++){let s=o[r];n[s]=wo(a,t,s,i[s],e,!f(i,s))}}return s}function wo(e,t,n,r,i,a){let o=e[n];if(o!=null){let e=f(o,`default`);if(e&&r===void 0){let e=o.default;if(o.type!==Function&&!o.skipFactory&&v(e)){let{propsDefaults:a}=i;if(n in a)r=a[n];else{let o=Rs(i);r=a[n]=e.call(null,t),o()}}else r=e;i.ce&&i.ce._setProp(n,r)}o[0]&&(a&&!e?r=!1:o[1]&&(r===``||r===oe(n))&&(r=!0))}return r}var To=new WeakMap;function Eo(e,t,n=!1){let a=n?To:t.propsCache,o=a.get(e);if(o)return o;let s=e.props,c={},u=[],d=!1;if(!v(e)){let r=e=>{d=!0;let[n,r]=Eo(e,t,!0);l(c,n),r&&u.push(...r)};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}if(!s&&!d)return x(e)&&a.set(e,i),i;if(p(s))for(let e=0;e<s.length;e++){let t=E(s[e]);Do(t)&&(c[t]=r)}else if(s)for(let e in s){let t=E(e);if(Do(t)){let n=s[e],r=c[t]=p(n)||v(n)?{type:n}:l({},n),i=r.type,a=!1,o=!0;if(p(i))for(let e=0;e<i.length;++e){let t=i[e],n=v(t)&&t.name;if(n===`Boolean`){a=!0;break}n===`String`&&(o=!1)}else a=v(i)&&i.name===`Boolean`;r[0]=a,r[1]=o,(a||f(r,`default`))&&u.push(t)}}let m=[c,u];return x(e)&&a.set(e,m),m}function Do(e){return e[0]!==`$`&&!ne(e)}var Oo=e=>e===`_`||e===`_ctx`||e===`$stable`,ko=e=>p(e)?e.map(Es):[Es(e)],Ao=(e,t,n)=>{if(t._n)return t;let r=P((...e)=>ko(t(...e)),n);return r._c=!1,r},jo=(e,t,n)=>{let r=e._ctx;for(let n in e){if(Oo(n))continue;let i=e[n];if(v(i))t[n]=Ao(n,i,r);else if(i!=null){let e=ko(i);t[n]=()=>e}}},Mo=(e,t)=>{let n=ko(t);e.slots.default=()=>n},No=(e,t,n)=>{for(let r in t)(n||!Oo(r))&&(e[r]=t[r])},Po=(e,t,n)=>{let r=e.slots=yo();if(e.vnode.shapeFlag&32){let e=t._;e?(No(r,t,n),n&&ue(r,`_`,e,!0)):jo(t,r)}else t&&Mo(e,t)},Fo=(e,t,n)=>{let{vnode:i,slots:a}=e,o=!0,s=r;if(i.shapeFlag&32){let e=t._;e?n&&e===1?o=!1:No(a,t,n):(o=!t.$stable,jo(t,a)),s=t}else t&&(Mo(e,t),s={default:1});if(o)for(let e in a)!Oo(e)&&s[e]==null&&delete a[e]},Io=is;function Lo(e){return zo(e)}function Ro(e){return zo(e,vi)}function zo(e,t){let n=me();n.__VUE__=!0;let{insert:o,remove:s,patchProp:c,createElement:l,createText:u,createComment:d,setText:f,setElementText:p,parentNode:m,nextSibling:h,setScopeId:g=a,insertStaticContent:_}=e,v=(e,t,n,r=null,i=null,a=null,o=void 0,s=null,c=!!t.dynamicChildren)=>{if(e===t)return;e&&!_s(e,t)&&(r=O(e),ge(e,i,a,!0),e=null),t.patchFlag===-2&&(c=!1,t.dynamicChildren=null);let{type:l,ref:u,shapeFlag:d}=t;switch(l){case ss:y(e,t,n,r);break;case cs:b(e,t,n,r);break;case ls:e??x(t,n,r,o);break;case L:ae(e,t,n,r,i,a,o,s,c);break;default:d&1?w(e,t,n,r,i,a,o,s,c):d&6?oe(e,t,n,r,i,a,o,s,c):(d&64||d&128)&&l.process(e,t,n,r,i,a,o,s,c,Ce)}u!=null&&i?ui(u,e&&e.ref,a,t||e,!t):u==null&&e&&e.ref!=null&&ui(e.ref,null,a,e,!0)},y=(e,t,n,r)=>{if(e==null)o(t.el=u(t.children),n,r);else{let n=t.el=e.el;t.children!==e.children&&f(n,t.children)}},b=(e,t,n,r)=>{e==null?o(t.el=d(t.children||``),n,r):t.el=e.el},x=(e,t,n,r)=>{[e.el,e.anchor]=_(e.children,t,n,r,e.el,e.anchor)},S=({el:e,anchor:t},n,r)=>{let i;for(;e&&e!==t;)i=h(e),o(e,n,r),e=i;o(t,n,r)},C=({el:e,anchor:t})=>{let n;for(;e&&e!==t;)n=h(e),s(e),e=n;s(t)},w=(e,t,n,r,i,a,o,s,c)=>{if(t.type===`svg`?o=`svg`:t.type===`math`&&(o=`mathml`),e==null)ee(t,n,r,i,a,o,s,c);else{let n=e.el&&e.el._isVueCE?e.el:null;try{n&&n._beginPatch(),re(e,t,i,a,o,s,c)}finally{n&&n._endPatch()}}},ee=(e,t,n,r,i,a,s,u)=>{let d,f,{props:m,shapeFlag:h,transition:g,dirs:_}=e;if(d=e.el=l(e.type,a,m&&m.is,m),h&8?p(d,e.children):h&16&&T(e.children,d,null,r,i,Bo(e,a),s,u),_&&_r(e,null,r,`created`),te(d,e,e.scopeId,s,r),m){for(let e in m)e!==`value`&&!ne(e)&&c(d,e,null,m[e],a,r);`value`in m&&c(d,`value`,null,m.value,a),(f=m.onVnodeBeforeMount)&&As(f,r,e)}_&&_r(e,null,r,`beforeMount`);let v=Ho(i,g);v&&g.beforeEnter(d),o(d,t,n),((f=m&&m.onVnodeMounted)||v||_)&&Io(()=>{try{f&&As(f,r,e),v&&g.enter(d),_&&_r(e,null,r,`mounted`)}finally{}},i)},te=(e,t,n,r,i)=>{if(n&&g(e,n),r)for(let t=0;t<r.length;t++)g(e,r[t]);if(i){let n=i.subTree;if(t===n||Jo(n.type)&&(n.ssContent===t||n.ssFallback===t)){let t=i.vnode;te(e,t,t.scopeId,t.slotScopeIds,i.parent)}}},T=(e,t,n,r,i,a,o,s,c=0)=>{for(let l=c;l<e.length;l++){let c=e[l]=s?Ds(e[l]):Es(e[l]);v(null,c,t,n,r,i,a,o,s)}},re=(e,t,n,i,a,o,s)=>{let l=t.el=e.el,{patchFlag:u,dynamicChildren:d,dirs:f}=t;u|=e.patchFlag&16;let m=e.props||r,h=t.props||r,g;if(n&&Vo(n,!1),(g=h.onVnodeBeforeUpdate)&&As(g,n,t,e),f&&_r(t,e,n,`beforeUpdate`),n&&Vo(n,!0),d&&(!e.dynamicChildren||e.dynamicChildren.length!==d.length)&&(u=0,s=!1,d=null),(m.innerHTML&&h.innerHTML==null||m.textContent&&h.textContent==null)&&p(l,``),d?ie(e.dynamicChildren,d,l,n,i,Bo(t,a),o):s||de(e,t,l,null,n,i,Bo(t,a),o,!1),u>0){if(u&16)E(l,m,h,n,a);else if(u&2&&m.class!==h.class&&c(l,`class`,null,h.class,a),u&4&&c(l,`style`,m.style,h.style,a),u&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let r=e[t],i=m[r],o=h[r];(o!==i||r===`value`)&&c(l,r,i,o,a,n)}}u&1&&e.children!==t.children&&p(l,t.children)}else!s&&d==null&&E(l,m,h,n,a);((g=h.onVnodeUpdated)||f)&&Io(()=>{g&&As(g,n,t,e),f&&_r(t,e,n,`updated`)},i)},ie=(e,t,n,r,i,a,o)=>{for(let s=0;s<t.length;s++){let c=e[s],l=t[s],u=c.el&&(c.type===L||!_s(c,l)||c.shapeFlag&198)?m(c.el):n;v(c,l,u,null,r,i,a,o,!0)}},E=(e,t,n,i,a)=>{if(t!==n){if(t!==r)for(let r in t)!ne(r)&&!(r in n)&&c(e,r,t[r],null,a,i);for(let r in n){if(ne(r))continue;let o=n[r],s=t[r];o!==s&&r!==`value`&&c(e,r,s,o,a,i)}`value`in n&&c(e,`value`,t.value,n.value,a)}},ae=(e,t,n,r,i,a,s,c,l)=>{let d=t.el=e?e.el:u(``),f=t.anchor=e?e.anchor:u(``),{patchFlag:p,dynamicChildren:m,slotScopeIds:h}=t;h&&(c=c?c.concat(h):h),e==null?(o(d,n,r),o(f,n,r),T(t.children||[],n,f,i,a,s,c,l)):p>0&&p&64&&m&&e.dynamicChildren&&e.dynamicChildren.length===m.length?(ie(e.dynamicChildren,m,n,i,a,s,c),(t.key!=null||i&&t===i.subTree)&&Uo(e,t,!0)):de(e,t,n,f,i,a,s,c,l)},oe=(e,t,n,r,i,a,o,s,c)=>{t.slotScopeIds=s,e==null?t.shapeFlag&512?i.ctx.activate(t,n,r,o,c):se(t,n,r,i,a,o,c):ce(e,t,c)},se=(e,t,n,r,i,a,o)=>{let s=e.component=Ns(e,r,i);if(zi(e)&&(s.ctx.renderer=Ce),Hs(s,!1,o),s.asyncDep){if(i&&i.registerDep(s,D,o),!e.el){let r=s.subTree=H(cs);b(null,r,t,n),e.placeholder=r.el}}else D(s,e,t,n,i,a,o)},ce=(e,t,n)=>{let r=t.component=e.component;if(mo(e,t,n)){if(r.asyncDep&&!r.asyncResolved){ue(r,t,n);return}r.next=t,r.update()}else t.el=e.el,r.vnode=t},D=(e,t,n,r,i,a,o)=>{let s=()=>{if(e.isMounted){let{next:t,bu:n,u:r,parent:s,vnode:c}=e;{let n=Go(e);if(n){t&&(t.el=c.el,ue(e,t,o)),n.asyncDep.then(()=>{Io(()=>{e.isUnmounted||l()},i)});return}}let u=t,d;Vo(e,!1),t?(t.el=c.el,ue(e,t,o)):t=c,n&&le(n),(d=t.props&&t.props.onVnodeBeforeUpdate)&&As(d,s,t,c),Vo(e,!0);let f=lo(e),p=e.subTree;e.subTree=f,v(p,f,m(p.el),O(p),e,i,a),t.el=f.el,u===null&&_o(e,f.el),r&&Io(r,i),(d=t.props&&t.props.onVnodeUpdated)&&Io(()=>As(d,s,t,c),i)}else{let o,{el:s,props:c}=t,{bm:l,m:u,parent:d,root:f,type:p}=e,m=Ii(t);if(Vo(e,!1),l&&le(l),!m&&(o=c&&c.onVnodeBeforeMount)&&As(o,d,t),Vo(e,!0),s&&Te){let t=()=>{e.subTree=lo(e),Te(s,e.subTree,e,i,null)};m&&p.__asyncHydrate?p.__asyncHydrate(s,e,t):t()}else{f.ce&&f.ce._hasShadowRoot()&&f.ce._injectChildStyle(p,e.parent?e.parent.type:void 0);let o=e.subTree=lo(e);v(null,o,n,r,e,i,a),t.el=o.el}if(u&&Io(u,i),!m&&(o=c&&c.onVnodeMounted)){let e=t;Io(()=>As(o,d,e),i)}(t.shapeFlag&256||d&&Ii(d.vnode)&&d.vnode.shapeFlag&256)&&e.a&&Io(e.a,i),e.isMounted=!0,t=n=r=null}};e.scope.on();let c=e.effect=new ze(s);e.scope.off();let l=e.update=c.run.bind(c),u=e.job=c.runIfDirty.bind(c);u.i=e,u.id=e.uid,c.scheduler=()=>er(u),Vo(e,!0),l()},ue=(e,t,n)=>{t.component=e;let r=e.vnode.props;e.vnode=t,e.next=null,So(e,t.props,r,n),Fo(e,t.children,n),nt(),rr(e),rt()},de=(e,t,n,r,i,a,o,s,c=!1)=>{let l=e&&e.children,u=e?e.shapeFlag:0,d=t.children,{patchFlag:f,shapeFlag:m}=t;if(f>0){if(f&128){pe(l,d,n,r,i,a,o,s,c);return}if(f&256){fe(l,d,n,r,i,a,o,s,c);return}}m&8?(u&16&&be(l,i,a),d!==l&&p(n,d)):u&16?m&16?pe(l,d,n,r,i,a,o,s,c):be(l,i,a,!0):(u&8&&p(n,``),m&16&&T(d,n,r,i,a,o,s,c))},fe=(e,t,n,r,a,o,s,c,l)=>{e||=i,t||=i;let u=e.length,d=t.length,f=Math.min(u,d),p;for(p=0;p<f;p++){let r=t[p]=l?Ds(t[p]):Es(t[p]);v(e[p],r,n,null,a,o,s,c,l)}u>d?be(e,a,o,!0,!1,f):T(t,n,r,a,o,s,c,l,f)},pe=(e,t,n,r,a,o,s,c,l)=>{let u=0,d=t.length,f=e.length-1,p=d-1;for(;u<=f&&u<=p;){let r=e[u],i=t[u]=l?Ds(t[u]):Es(t[u]);if(_s(r,i))v(r,i,n,null,a,o,s,c,l);else break;u++}for(;u<=f&&u<=p;){let r=e[f],i=t[p]=l?Ds(t[p]):Es(t[p]);if(_s(r,i))v(r,i,n,null,a,o,s,c,l);else break;f--,p--}if(u>f){if(u<=p){let e=p+1,i=e<d?t[e].el:r;for(;u<=p;)v(null,t[u]=l?Ds(t[u]):Es(t[u]),n,i,a,o,s,c,l),u++}}else if(u>p)for(;u<=f;)ge(e[u],a,o,!0),u++;else{let m=u,h=u,g=new Map;for(u=h;u<=p;u++){let e=t[u]=l?Ds(t[u]):Es(t[u]);e.key!=null&&g.set(e.key,u)}let _,y=0,b=p-h+1,x=!1,S=0,C=Array(b);for(u=0;u<b;u++)C[u]=0;for(u=m;u<=f;u++){let r=e[u];if(y>=b){ge(r,a,o,!0);continue}let i;if(r.key!=null)i=g.get(r.key);else for(_=h;_<=p;_++)if(C[_-h]===0&&_s(r,t[_])){i=_;break}i===void 0?ge(r,a,o,!0):(C[i-h]=u+1,i>=S?S=i:x=!0,v(r,t[i],n,null,a,o,s,c,l),y++)}let w=x?Wo(C):i;for(_=w.length-1,u=b-1;u>=0;u--){let e=h+u,i=t[e],f=t[e+1],p=e+1<d?f.el||qo(f):r;C[u]===0?v(null,i,n,p,a,o,s,c,l):x&&(_<0||u!==w[_]?he(i,n,p,2):_--)}}},he=(e,t,n,r,i=null)=>{let{el:a,type:c,transition:l,children:u,shapeFlag:d}=e;if(d&6){he(e.component.subTree,t,n,r);return}if(d&128){e.suspense.move(t,n,r);return}if(d&64){c.move(e,t,n,Ce);return}if(c===L){o(a,t,n);for(let e=0;e<u.length;e++)he(u[e],t,n,r);o(e.anchor,t,n);return}if(c===ls){S(e,t,n);return}if(r!==2&&d&1&&l){if(r===0)l.persisted&&!a[Wr]?o(a,t,n):(l.beforeEnter(a),o(a,t,n),Io(()=>l.enter(a),i));else{let{leave:r,delayLeave:i,afterLeave:c}=l,u=()=>{e.ctx.isUnmounted?s(a):o(a,t,n)},d=()=>{let e=a._isLeaving||!!a[Wr];a._isLeaving&&a[Wr](!0),l.persisted&&!e?u():r(a,()=>{u(),c&&c()})};i?i(a,u,d):d()}}else o(a,t,n)},ge=(e,t,n,r=!1,i=!1)=>{let{type:a,props:o,ref:s,children:c,dynamicChildren:l,shapeFlag:u,patchFlag:d,dirs:f,cacheIndex:p,memo:m}=e;if(d===-2&&(i=!1),s!=null&&(nt(),ui(s,null,n,e,!0),rt()),p!=null&&(t.renderCache[p]=void 0),u&256){t.ctx.deactivate(e);return}let h=u&1&&f,g=!Ii(e),_;if(g&&(_=o&&o.onVnodeBeforeUnmount)&&As(_,t,e),u&6)ye(e.component,n,r);else{if(u&128){e.suspense.unmount(n,r);return}h&&_r(e,null,t,`beforeUnmount`),u&64?e.type.remove(e,t,n,Ce,r):l&&!l.hasOnce&&(a!==L||d>0&&d&64)?be(l,t,n,!1,!0):(a===L&&d&384||!i&&u&16)&&be(c,t,n),r&&_e(e)}let v=m!=null&&p==null;(g&&(_=o&&o.onVnodeUnmounted)||h||v)&&Io(()=>{_&&As(_,t,e),h&&_r(e,null,t,`unmounted`),v&&(e.el=null)},n)},_e=e=>{let{type:t,el:n,anchor:r,transition:i}=e;if(t===L){ve(n,r);return}if(t===ls){C(e);return}let a=()=>{s(n),i&&!i.persisted&&i.afterLeave&&i.afterLeave()};if(e.shapeFlag&1&&i&&!i.persisted){let{leave:t,delayLeave:r}=i,o=()=>t(n,a);r?r(e.el,a,o):o()}else a()},ve=(e,t)=>{let n;for(;e!==t;)n=h(e),s(e),e=n;s(t)},ye=(e,t,n)=>{let{bum:r,scope:i,job:a,subTree:o,um:s,m:c,a:l}=e;Ko(c),Ko(l),r&&le(r),i.stop(),a&&(a.flags|=8,ge(o,e,t,n)),s&&Io(s,t),Io(()=>{e.isUnmounted=!0},t)},be=(e,t,n,r=!1,i=!1,a=0)=>{for(let o=a;o<e.length;o++)ge(e[o],t,n,r,i)},O=e=>{if(e.shapeFlag&6)return O(e.component.subTree);if(e.shapeFlag&128)return e.suspense.next();let t=h(e.anchor||e.el),n=t&&t[jr];return n?h(n):t},xe=!1,Se=(e,t,n)=>{let r;e==null?t._vnode&&(ge(t._vnode,null,null,!0),r=t._vnode.component):v(t._vnode||null,e,t,null,null,null,n),t._vnode=e,xe||=(xe=!0,rr(r),ir(),!1)},Ce={p:v,um:ge,m:he,r:_e,mt:se,mc:T,pc:de,pbc:ie,n:O,o:e},we,Te;return t&&([we,Te]=t(Ce)),{render:Se,hydrate:we,createApp:to(Se,we)}}function Bo({type:e,props:t},n){return n===`svg`&&e===`foreignObject`||n===`mathml`&&e===`annotation-xml`&&t&&t.encoding&&t.encoding.includes(`html`)?void 0:n}function Vo({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function Ho(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function Uo(e,t,n=!1){let r=e.children,i=t.children;if(p(r)&&p(i))for(let e=0;e<r.length;e++){let t=r[e],a=i[e];a.shapeFlag&1&&!a.dynamicChildren&&((a.patchFlag<=0||a.patchFlag===32)&&(a=i[e]=Ds(i[e]),a.el=t.el),!n&&a.patchFlag!==-2&&Uo(t,a)),a.type===ss&&(a.patchFlag===-1&&(a=i[e]=Ds(a)),a.el=t.el),a.type===cs&&!a.el&&(a.el=t.el)}}function Wo(e){let t=e.slice(),n=[0],r,i,a,o,s,c=e.length;for(r=0;r<c;r++){let c=e[r];if(c!==0){if(i=n[n.length-1],e[i]<c){t[r]=i,n.push(r);continue}for(a=0,o=n.length-1;a<o;)s=a+o>>1,e[n[s]]<c?a=s+1:o=s;c<e[n[a]]&&(a>0&&(t[r]=n[a-1]),n[a]=r)}}for(a=n.length,o=n[a-1];a-->0;)n[a]=o,o=t[o];return n}function Go(e){let t=e.subTree.component;if(t)return t.asyncDep&&!t.asyncResolved?t:Go(t)}function Ko(e){if(e)for(let t=0;t<e.length;t++)e[t].flags|=8}function qo(e){if(e.placeholder)return e.placeholder;let t=e.component;return t?qo(t.subTree):null}var Jo=e=>e.__isSuspense,Yo=0,Xo={name:`Suspense`,__isSuspense:!0,process(e,t,n,r,i,a,o,s,c,l){if(e==null)Qo(t,n,r,i,a,o,s,c,l);else{if(a&&a.deps>0&&!e.suspense.isInFallback){t.suspense=e.suspense,t.suspense.vnode=t,t.el=e.el;return}$o(e,t,n,r,i,o,s,c,l)}},hydrate:ts,normalize:ns};function Zo(e,t){let n=e.props&&e.props[t];v(n)&&n()}function Qo(e,t,n,r,i,a,o,s,c){let{p:l,o:{createElement:u}}=c,d=u(`div`),f=e.suspense=es(e,i,r,t,d,n,a,o,s,c);l(null,f.pendingBranch=e.ssContent,d,null,r,f,a,o),f.deps>0?(Zo(e,`onPending`),Zo(e,`onFallback`),l(null,e.ssFallback,t,n,r,null,a,o),as(f,e.ssFallback)):f.resolve(!1,!0)}function $o(e,t,n,r,i,a,o,s,{p:c,um:l,o:{createElement:u}}){let d=t.suspense=e.suspense;d.vnode=t,t.el=e.el;let f=t.ssContent,p=t.ssFallback,{activeBranch:m,pendingBranch:h,isInFallback:g,isHydrating:_}=d;if(h)d.pendingBranch=f,_s(h,f)?(c(h,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0?d.resolve():g&&(_||(c(m,p,n,r,i,null,a,o,s),as(d,p)))):(d.pendingId=Yo++,_?(d.isHydrating=!1,d.activeBranch=h):l(h,i,d),d.deps=0,d.effects.length=0,d.hiddenContainer=u(`div`),g?(c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0?d.resolve():(c(m,p,n,r,i,null,a,o,s),as(d,p))):m&&_s(m,f)?(c(m,f,n,r,i,d,a,o,s),d.resolve(!0)):(c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0&&d.resolve()));else if(m&&_s(m,f))c(m,f,n,r,i,d,a,o,s),as(d,f);else if(Zo(t,`onPending`),d.pendingBranch=f,d.pendingId=f.shapeFlag&512?f.component.suspenseId:Yo++,c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0)d.resolve();else{let{timeout:e,pendingId:t}=d;e>0?setTimeout(()=>{d.pendingId===t&&d.fallback(p)},e):e===0&&d.fallback(p)}}function es(e,t,n,r,i,a,o,s,c,l,u=!1){let{p:d,m:f,um:p,n:m,o:{parentNode:h,remove:g}}=l,_,v=os(e);v&&t&&t.pendingBranch&&(_=t.pendingId,t.deps++);let y=e.props?fe(e.props.timeout):void 0,b=a,x={vnode:e,parent:t,parentComponent:n,namespace:o,container:r,hiddenContainer:i,deps:0,pendingId:Yo++,timeout:typeof y==`number`?y:-1,activeBranch:null,isFallbackMountPending:!1,pendingBranch:null,isInFallback:!u,isHydrating:u,isUnmounted:!1,effects:[],resolve(e=!1,n=!1){let{vnode:r,activeBranch:i,pendingBranch:o,pendingId:s,effects:c,parentComponent:l,container:u,isInFallback:d}=x,g=!1;if(x.isHydrating)x.isHydrating=!1;else if(!e){g=i&&o.transition&&o.transition.mode===`out-in`;let e=!1;g&&(i.transition.afterLeave=()=>{s===x.pendingId&&(f(o,u,a===b&&!e?m(i):a,0),nr(c),d&&r.ssFallback&&(r.ssFallback.el=null))}),i&&!x.isFallbackMountPending&&(h(i.el)===u&&(a=m(i),e=!0),p(i,l,x,!0),!g&&d&&r.ssFallback&&Io(()=>r.ssFallback.el=null,x)),g||f(o,u,a,0)}x.isFallbackMountPending=!1,as(x,o),x.pendingBranch=null,x.isInFallback=!1;let y=x.parent,S=!1;for(;y;){if(y.pendingBranch){for(let e=0;e<c.length;e++)y.effects.push(c[e]);S=!0;break}y=y.parent}!S&&!g&&nr(c),x.effects=[],v&&t&&t.pendingBranch&&_===t.pendingId&&(t.deps--,t.deps===0&&!n&&t.resolve()),Zo(r,`onResolve`)},fallback(e){if(!x.pendingBranch)return;let{vnode:t,activeBranch:n,parentComponent:r,container:i,namespace:a}=x;Zo(t,`onFallback`);let o=m(n),l=()=>{x.isFallbackMountPending=!1,x.isInFallback&&(d(null,e,i,o,r,null,a,s,c),as(x,e))},u=e.transition&&e.transition.mode===`out-in`;u&&(x.isFallbackMountPending=!0,n.transition.afterLeave=l),x.isInFallback=!0,p(n,r,null,!0),u||l()},move(e,t,n){x.activeBranch&&f(x.activeBranch,e,t,n),x.container=e},next(){return x.activeBranch&&m(x.activeBranch)},registerDep(e,t,n){let r=!!x.pendingBranch;r&&x.deps++;let i=e.vnode.el;e.asyncDep.catch(t=>{Un(t,e,0)}).then(a=>{if(e.isUnmounted||x.isUnmounted||x.pendingId!==e.suspenseId)return;zs(),e.asyncResolved=!0;let{vnode:s}=e;Ws(e,a,!1),i&&(s.el=i);let c=!i&&e.subTree.el;t(e,s,h(i||e.subTree.el),i?null:m(e.subTree),x,o,n),c&&(s.placeholder=null,g(c)),_o(e,s.el),r&&--x.deps===0&&x.resolve()})},unmount(e,t){x.isUnmounted=!0,x.activeBranch&&p(x.activeBranch,n,e,t),x.pendingBranch&&p(x.pendingBranch,n,e,t)}};return x}function ts(e,t,n,r,i,a,o,s,c){let l=t.suspense=es(t,r,n,e.parentNode,document.createElement(`div`),null,i,a,o,s,!0),u=c(e,l.pendingBranch=t.ssContent,n,l,a,o);return l.deps===0&&l.resolve(!1,!0),u}function ns(e){let{shapeFlag:t,children:n}=e,r=t&32;e.ssContent=rs(r?n.default:n),e.ssFallback=r?rs(n.fallback):H(cs)}function rs(e){let t;if(v(e)){let n=ps&&e._c;n&&(e._d=!1,R()),e=e(),n&&(e._d=!0,t=ds,fs())}return p(e)&&(e=uo(e)),e=Es(e),t&&!e.dynamicChildren&&(e.dynamicChildren=t.filter(t=>t!==e)),e}function is(e,t){t&&t.pendingBranch?p(e)?t.effects.push(...e):t.effects.push(e):nr(e)}function as(e,t){e.activeBranch=t;let{vnode:n,parentComponent:r}=e,i=t.el;for(;!i&&t.component;)t=t.component.subTree,i=t.el;n.el=i,r&&r.subTree===n&&(r.vnode.el=i,_o(r,i))}function os(e){let t=e.props&&e.props.suspensible;return t!=null&&t!==!1}var L=Symbol.for(`v-fgt`),ss=Symbol.for(`v-txt`),cs=Symbol.for(`v-cmt`),ls=Symbol.for(`v-stc`),us=[],ds=null;function R(e=!1){us.push(ds=e?null:[])}function fs(){us.pop(),ds=us[us.length-1]||null}var ps=1;function ms(e,t=!1){ps+=e,e<0&&ds&&t&&(ds.hasOnce=!0)}function hs(e){return e.dynamicChildren=ps>0?ds||i:null,fs(),ps>0&&ds&&ds.push(e),e}function z(e,t,n,r,i,a){return hs(V(e,t,n,r,i,a,!0))}function B(e,t,n,r,i){return hs(H(e,t,n,r,i,!0))}function gs(e){return e?e.__v_isVNode===!0:!1}function _s(e,t){return e.type===t.type&&e.key===t.key}function vs(e){}var ys=({key:e})=>e??null,bs=({ref:e,ref_key:t,ref_for:n})=>(typeof e==`number`&&(e=``+e),e==null?null:y(e)||j(e)||v(e)?{i:ur,r:e,k:t,f:!!n}:e);function V(e,t=null,n=null,r=0,i=null,a=e===L?0:1,o=!1,s=!1){let c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&ys(t),ref:t&&bs(t),scopeId:dr,slotScopeIds:null,children:n,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetStart:null,targetAnchor:null,staticCount:0,shapeFlag:a,patchFlag:r,dynamicProps:i,dynamicChildren:null,appContext:null,ctx:ur};return s?(Os(c,n),a&128&&e.normalize(c)):n&&(c.shapeFlag|=y(n)?8:16),ps>0&&!o&&ds&&(c.patchFlag>0||a&6)&&c.patchFlag!==32&&ds.push(c),c}var H=xs;function xs(e,t=null,n=null,r=0,i=null,a=!1){if((!e||e===la)&&(e=cs),gs(e)){let r=Cs(e,t,!0);return n&&Os(r,n),ps>0&&!a&&ds&&(r.shapeFlag&6?ds[ds.indexOf(e)]=r:ds.push(r)),r.patchFlag=-2,r}if(ec(e)&&(e=e.__vccOpts),t){t=Ss(t);let{class:e,style:n}=t;e&&!y(e)&&(t.class=O(e)),x(n)&&(on(n)&&!p(n)&&(n=l({},n)),t.style=ge(n))}let o=y(e)?1:Jo(e)?128:Mr(e)?64:x(e)?4:v(e)?2:0;return V(e,t,n,r,i,o,a,!0)}function Ss(e){return e?on(e)||bo(e)?l({},e):e:null}function Cs(e,t,n=!1,r=!1){let{props:i,ref:a,patchFlag:o,children:s,transition:c}=e,l=t?ks(i||{},t):i,u={__v_isVNode:!0,__v_skip:!0,type:e.type,props:l,key:l&&ys(l),ref:t&&t.ref?n&&a?p(a)?a.concat(bs(t)):[a,bs(t)]:bs(t):a,scopeId:e.scopeId,slotScopeIds:e.slotScopeIds,children:s,target:e.target,targetStart:e.targetStart,targetAnchor:e.targetAnchor,staticCount:e.staticCount,shapeFlag:e.shapeFlag,patchFlag:t&&e.type!==L?o===-1?16:o|16:o,dynamicProps:e.dynamicProps,dynamicChildren:e.dynamicChildren,appContext:e.appContext,dirs:e.dirs,transition:c,component:e.component,suspense:e.suspense,ssContent:e.ssContent&&Cs(e.ssContent),ssFallback:e.ssFallback&&Cs(e.ssFallback),placeholder:e.placeholder,el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce};return c&&r&&ri(u,c.clone(u)),u}function U(e=` `,t=0){return H(ss,null,e,t)}function ws(e,t){let n=H(ls,null,e);return n.staticCount=t,n}function Ts(e=``,t=!1){return t?(R(),B(cs,null,e)):H(cs,null,e)}function Es(e){return e==null||typeof e==`boolean`?H(cs):p(e)?H(L,null,e.slice()):gs(e)?Ds(e):H(ss,null,String(e))}function Ds(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:Cs(e)}function Os(e,t){let n=0,{shapeFlag:r}=e;if(t==null)t=null;else if(p(t))n=16;else if(typeof t==`object`){if(r&65){let n=t.default;n&&(n._c&&(n._d=!1),Os(e,n()),n._c&&(n._d=!0));return}{n=32;let r=t._;!r&&!bo(t)?t._ctx=ur:r===3&&ur&&(ur.slots._===1?t._=1:(t._=2,e.patchFlag|=1024))}}else if(v(t)){if(r&65){Os(e,{default:t});return}t={default:t,_ctx:ur},n=32}else t=String(t),r&64?(n=16,t=[U(t)]):n=8;e.children=t,e.shapeFlag|=n}function ks(...e){let t={};for(let n=0;n<e.length;n++){let r=e[n];for(let e in r)if(e===`class`)t.class!==r.class&&(t.class=O([t.class,r.class]));else if(e===`style`)t.style=ge([t.style,r.style]);else if(s(e)){let n=t[e],i=r[e];i&&n!==i&&!(p(n)&&n.includes(i))?t[e]=n?[].concat(n,i):i:i==null&&n==null&&!c(e)&&(t[e]=i)}else e!==``&&(t[e]=r[e])}return t}function As(e,t,n,r=null){Hn(e,t,7,[n,r])}var js=$a(),Ms=0;function Ns(e,t,n){let i=e.type,a=(t?t.appContext:e.appContext)||js,o={uid:Ms++,vnode:e,type:i,parent:t,appContext:a,root:null,next:null,subTree:null,effect:null,update:null,job:null,scope:new Ne(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:t?t.provides:Object.create(a.provides),ids:t?t.ids:[``,0,0],accessCache:null,renderCache:[],components:null,directives:null,propsOptions:Eo(i,a),emitsOptions:so(i,a),emit:null,emitted:null,propsDefaults:r,inheritAttrs:i.inheritAttrs,ctx:r,data:r,props:r,attrs:r,slots:r,refs:r,setupState:r,setupContext:null,suspense:n,suspenseId:n?n.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return o.ctx={_:o},o.root=t?t.root:o,o.emit=ao.bind(null,o),e.ce&&e.ce(o),o}var Ps=null,Fs=()=>Ps||ur,Is,Ls;{let e=me(),t=(t,n)=>{let r;return(r=e[t])||(r=e[t]=[]),r.push(n),e=>{r.length>1?r.forEach(t=>t(e)):r[0](e)}};Is=t(`__VUE_INSTANCE_SETTERS__`,e=>Ps=e),Ls=t(`__VUE_SSR_SETTERS__`,e=>Vs=e)}var Rs=e=>{let t=Ps;return Is(e),e.scope.on(),()=>{e.scope.off(),Is(t)}},zs=()=>{Ps&&Ps.scope.off(),Is(null)};function Bs(e){return e.vnode.shapeFlag&4}var Vs=!1;function Hs(e,t=!1,n=!1){t&&Ls(t);let{props:r,children:i}=e.vnode,a=Bs(e);xo(e,r,a,t),Po(e,i,n||t);let o=a?Us(e,t):void 0;return t&&Ls(!1),o}function Us(e,t){let n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,xa);let{setup:r}=n;if(r){nt();let n=e.setupContext=r.length>1?Zs(e):null,i=Rs(e),a=Vn(r,e,0,[e.props,n]),o=S(a);if(rt(),i(),(o||e.sp)&&!Ii(e)&&oi(e),o){if(a.then(zs,zs),t)return a.then(n=>{Ls(!0);try{Ws(e,n,t)}finally{Ls(!1)}}).catch(t=>{Un(t,e,0)});e.asyncDep=a}else Ws(e,a,t)}else Ys(e,t)}function Ws(e,t,n){v(t)?e.type.__ssrInlineRender?e.ssrRender=t:e.render=t:x(t)&&(e.setupState=gn(t)),Ys(e,n)}var Gs,Ks;function qs(e){Gs=e,Ks=e=>{e.render._rc&&(e.withProxy=new Proxy(e.ctx,Sa))}}var Js=()=>!Gs;function Ys(e,t,n){let r=e.type;if(!e.render){if(!t&&Gs&&!r.render){let t=r.template||Ua(e).template;if(t){let{isCustomElement:n,compilerOptions:i}=e.appContext.config,{delimiters:a,compilerOptions:o}=r,s=l(l({isCustomElement:n,delimiters:a},i),o);r.render=Gs(t,s)}}e.render=r.render||a,Ks&&Ks(e)}{let t=Rs(e);nt();try{za(e)}finally{rt(),t()}}}var Xs={get(e,t){return pt(e,`get`,``),e[t]}};function Zs(e){return{attrs:new Proxy(e.attrs,Xs),slots:e.slots,emit:e.emit,expose:t=>{e.exposed=t||{}}}}function Qs(e){return e.exposed?e.exposeProxy||=new Proxy(gn(sn(e.exposed)),{get(t,n){if(n in t)return t[n];if(n in ya)return ya[n](e)},has(e,t){return t in e||t in ya}}):e.proxy}function $s(e,t=!0){return v(e)?e.displayName||e.name:e.name||t&&e.__name}function ec(e){return v(e)&&`__vccOpts`in e}var W=(e,t)=>Tn(e,t,Vs);function tc(e,t,n){try{ms(-1);let r=arguments.length;return r===2?x(t)&&!p(t)?gs(t)?H(e,null,[t]):H(e,t):H(e,null,t):(r>3?n=Array.prototype.slice.call(arguments,2):r===3&&gs(n)&&(n=[n]),H(e,t,n))}finally{ms(1)}}function nc(){}function rc(e,t,n,r){let i=n[r];if(i&&ic(i,e))return i;let a=t();return a.memo=e.slice(),a.cacheIndex=r,n[r]=a}function ic(e,t){let n=e.memo;if(n.length!=t.length)return!1;for(let e=0;e<n.length;e++)if(D(n[e],t[e]))return!1;return ps>0&&ds&&ds.push(e),!0}var ac=`3.5.41`,oc=a,sc=Bn,cc=sr,lc=lr,uc={createComponentInstance:Ns,setupComponent:Hs,renderComponentRoot:lo,setCurrentRenderingInstance:fr,isVNode:gs,normalizeVNode:Es,getComponentPublicInstance:Qs,ensureValidVNode:ga,pushWarningContext:In,popWarningContext:Ln},dc=void 0,fc=typeof window<`u`&&window.trustedTypes;if(fc)try{dc=fc.createPolicy(`vue`,{createHTML:e=>e})}catch{}var pc=dc?e=>dc.createHTML(e):e=>e,mc=`http://www.w3.org/2000/svg`,hc=`http://www.w3.org/1998/Math/MathML`,gc=typeof document<`u`?document:null,_c=gc&&gc.createElement(`template`),vc={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{let t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,r)=>{let i=t===`svg`?gc.createElementNS(mc,e):t===`mathml`?gc.createElementNS(hc,e):n?gc.createElement(e,{is:n}):gc.createElement(e);return e===`select`&&r&&r.multiple!=null&&i.setAttribute(`multiple`,r.multiple),i},createText:e=>gc.createTextNode(e),createComment:e=>gc.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>gc.querySelector(e),setScopeId(e,t){e.setAttribute(t,``)},insertStaticContent(e,t,n,r,i,a){let o=n?n.previousSibling:t.lastChild;if(i&&(i===a||i.nextSibling))for(;t.insertBefore(i.cloneNode(!0),n),!(i===a||!(i=i.nextSibling)););else{_c.innerHTML=pc(r===`svg`?`<svg>${e}</svg>`:r===`mathml`?`<math>${e}</math>`:e);let i=_c.content;if(r===`svg`||r===`mathml`){let e=i.firstChild;for(;e.firstChild;)i.appendChild(e.firstChild);i.removeChild(e)}t.insertBefore(i,n)}return[o?o.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},yc=`transition`,bc=`animation`,xc=Symbol(`_vtc`),Sc={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Cc=l({},Jr,Sc),wc=(e=>(e.displayName=`Transition`,e.props=Cc,e))((e,{slots:t})=>tc(Qr,Dc(e),t)),Tc=(e,t=[])=>{p(e)?e.forEach(e=>e(...t)):e&&e(...t)},Ec=e=>e?p(e)?e.some(e=>e.length>1):e.length>1:!1;function Dc(e){let t={};for(let n in e)n in Sc||(t[n]=e[n]);if(e.css===!1)return t;let{name:n=`v`,type:r,duration:i,enterFromClass:a=`${n}-enter-from`,enterActiveClass:o=`${n}-enter-active`,enterToClass:s=`${n}-enter-to`,appearFromClass:c=a,appearActiveClass:u=o,appearToClass:d=s,leaveFromClass:f=`${n}-leave-from`,leaveActiveClass:p=`${n}-leave-active`,leaveToClass:m=`${n}-leave-to`}=e,h=Oc(i),g=h&&h[0],_=h&&h[1],{onBeforeEnter:v,onEnter:y,onEnterCancelled:b,onLeave:x,onLeaveCancelled:S,onBeforeAppear:C=v,onAppear:w=y,onAppearCancelled:ee=b}=t,te=(e,t,n,r)=>{e._enterCancelled=r,jc(e,t?d:s),jc(e,t?u:o),n&&n()},T=(e,t)=>{e._isLeaving=!1,jc(e,f),jc(e,m),jc(e,p),t&&t()},ne=e=>(t,n)=>{let i=e?w:y,o=()=>te(t,e,n);Tc(i,[t,o]),Mc(()=>{jc(t,e?c:a),Ac(t,e?d:s),Ec(i)||Pc(t,r,g,o)})};return l(t,{onBeforeEnter(e){Tc(v,[e]),Ac(e,a),Ac(e,o)},onBeforeAppear(e){Tc(C,[e]),Ac(e,c),Ac(e,u)},onEnter:ne(!1),onAppear:ne(!0),onLeave(e,t){e._isLeaving=!0;let n=()=>T(e,t);Ac(e,f),e._enterCancelled?(Ac(e,p),Rc(e)):(Rc(e),Ac(e,p)),Mc(()=>{e._isLeaving&&(jc(e,f),Ac(e,m),Ec(x)||Pc(e,r,_,n))}),Tc(x,[e,n])},onEnterCancelled(e){te(e,!1,void 0,!0),Tc(b,[e])},onAppearCancelled(e){te(e,!0,void 0,!0),Tc(ee,[e])},onLeaveCancelled(e){T(e),Tc(S,[e])}})}function Oc(e){if(e==null)return null;if(x(e))return[kc(e.enter),kc(e.leave)];{let t=kc(e);return[t,t]}}function kc(e){return fe(e)}function Ac(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.add(t)),(e[xc]||(e[xc]=new Set)).add(t)}function jc(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.remove(t));let n=e[xc];n&&(n.delete(t),n.size||(e[xc]=void 0))}function Mc(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}var Nc=0;function Pc(e,t,n,r){let i=e._endId=++Nc,a=()=>{i===e._endId&&r()};if(n!=null)return setTimeout(a,n);let{type:o,timeout:s,propCount:c}=Fc(e,t);if(!o)return r();let l=o+`end`,u=0,d=()=>{e.removeEventListener(l,f),a()},f=t=>{t.target===e&&++u>=c&&d()};setTimeout(()=>{u<c&&d()},s+1),e.addEventListener(l,f)}function Fc(e,t){let n=window.getComputedStyle(e),r=e=>(n[e]||``).split(`, `),i=r(`${yc}Delay`),a=r(`${yc}Duration`),o=Ic(i,a),s=r(`${bc}Delay`),c=r(`${bc}Duration`),l=Ic(s,c),u=null,d=0,f=0;t===yc?o>0&&(u=yc,d=o,f=a.length):t===bc?l>0&&(u=bc,d=l,f=c.length):(d=Math.max(o,l),u=d>0?o>l?yc:bc:null,f=u?u===yc?a.length:c.length:0);let p=u===yc&&/\b(?:transform|all)(?:,|$)/.test(r(`${yc}Property`).toString());return{type:u,timeout:d,propCount:f,hasTransform:p}}function Ic(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max(...t.map((t,n)=>Lc(t)+Lc(e[n])))}function Lc(e){return e===`auto`?0:Number(e.slice(0,-1).replace(`,`,`.`))*1e3}function Rc(e){return(e?e.ownerDocument:document).body.offsetHeight}function zc(e,t,n){let r=e[xc];r&&(t=(t?[t,...r]:[...r]).join(` `)),t==null?e.removeAttribute(`class`):n?e.setAttribute(`class`,t):e.className=t}var Bc=Symbol(`_vod`),Vc=Symbol(`_vsh`),Hc={name:`show`,beforeMount(e,{value:t},{transition:n}){e[Bc]=e.style.display===`none`?``:e.style.display,n&&t?n.beforeEnter(e):Uc(e,t)},mounted(e,{value:t},{transition:n}){n&&t&&n.enter(e)},updated(e,{value:t,oldValue:n},{transition:r}){!t!=!n&&(r?t?(r.beforeEnter(e),Uc(e,!0),r.enter(e)):r.leave(e,()=>{Uc(e,!1)}):Uc(e,t))},beforeUnmount(e,{value:t}){Uc(e,t)}};function Uc(e,t){e.style.display=t?e[Bc]:`none`,e[Vc]=!t}function Wc(){Hc.getSSRProps=({value:e})=>{if(!e)return{style:{display:`none`}}}}var Gc=Symbol(``);function Kc(e){let t=Fs();if(!t)return;let n=t.ut=(n=e(t.proxy))=>{Array.from(document.querySelectorAll(`[data-v-owner="${t.uid}"]`)).forEach(e=>Jc(e,n))},r=()=>{let r=e(t.proxy);t.ce?Jc(t.ce,r):qc(t.subTree,r),n(r)};Qi(()=>{nr(r)}),Zi(()=>{Er(r,a,{flush:`post`});let e=new MutationObserver(r);e.observe(t.subTree.el.parentNode,{childList:!0}),ta(()=>e.disconnect())})}function qc(e,t){if(e.shapeFlag&128){let n=e.suspense;e=n.activeBranch,n.pendingBranch&&!n.isHydrating&&n.effects.push(()=>{qc(n.activeBranch,t)})}for(;e.component;)e=e.component.subTree;if(e.shapeFlag&1&&e.el)Jc(e.el,t);else if(e.type===L)e.children.forEach(e=>qc(e,t));else if(e.type===ls){let{el:n,anchor:r}=e;for(;n&&(Jc(n,t),n!==r);)n=n.nextSibling}}function Jc(e,t){if(e.nodeType===1){let n=e.style,r=``;for(let e in t){let i=je(t[e]);n.setProperty(`--${e}`,i),r+=`--${e}: ${i};`}n[Gc]=r}}var Yc=/(?:^|;)\s*display\s*:/;function Xc(e,t,n){let r=e.style,i=y(n),a=!1;if(n&&!i){if(t){if(y(t))for(let e of t.split(`;`)){let t=e.slice(0,e.indexOf(`:`)).trim();n[t]??Qc(r,t,``)}else for(let e in t)n[e]??Qc(r,e,``)}for(let i in n){i===`display`&&(a=!0);let o=n[i];o==null?Qc(r,i,``):nl(e,i,!y(t)&&t?t[i]:void 0,o)||Qc(r,i,o)}}else if(i){if(t!==n){let e=r[Gc];e&&(n+=`;`+e),r.cssText=n,a=Yc.test(n)}}else t&&e.removeAttribute(`style`);Bc in e&&(e[Bc]=a?r.display:``,e[Vc]&&(r.display=`none`))}var Zc=/\s*!important$/;function Qc(e,t,n){if(p(n))n.forEach(n=>Qc(e,t,n));else if(n??=``,t.startsWith(`--`))e.setProperty(t,n);else{let r=tl(e,t);Zc.test(n)?e.setProperty(oe(r),n.replace(Zc,``),`important`):e[r]=n}}var $c=[`Webkit`,`Moz`,`ms`],el={};function tl(e,t){let n=el[t];if(n)return n;let r=E(t);if(r!==`filter`&&r in e)return el[t]=r;r=se(r);for(let n=0;n<$c.length;n++){let i=$c[n]+r;if(i in e)return el[t]=i}return t}function nl(e,t,n,r){return e.tagName===`TEXTAREA`&&(t===`width`||t===`height`)&&y(r)&&n===r}var rl=`http://www.w3.org/1999/xlink`;function il(e,t,n,r,i,a=Ce(t)){r&&t.startsWith(`xlink:`)?n==null?e.removeAttributeNS(rl,t.slice(6,t.length)):e.setAttributeNS(rl,t,n):n==null||a&&!we(n)?e.removeAttribute(t):e.setAttribute(t,a?``:b(n)?String(n):n)}function al(e,t,n,r,i){if(t===`innerHTML`||t===`textContent`){n!=null&&(e[t]=t===`innerHTML`?pc(n):n);return}let a=e.tagName;if(t===`value`&&a!==`PROGRESS`&&!a.includes(`-`)){let r=a===`OPTION`?e.getAttribute(`value`)||``:e.value,i=n==null?e.type===`checkbox`?`on`:``:String(n);(r!==i||!(`_value`in e))&&(e.value=i),n??e.removeAttribute(t),e._value=n;return}let o=!1;if(n===``||n==null){let r=typeof e[t];r===`boolean`?n=we(n):n==null&&r===`string`?(n=``,o=!0):r===`number`&&(n=0,o=!0)}try{e[t]=n}catch{}o&&e.removeAttribute(i||t)}function ol(e,t,n,r){e.addEventListener(t,n,r)}function sl(e,t,n,r){e.removeEventListener(t,n,r)}var cl=Symbol(`_vei`);function ll(e,t,n,r,i=null){let a=e[cl]||(e[cl]={}),o=a[t];if(r&&o)o.value=r;else{let[n,s]=fl(t);r?ol(e,n,a[t]=gl(r,i),s):o&&(sl(e,n,o,s),a[t]=void 0)}}var ul=/(Once|Passive|Capture)$/,dl=/^on:?(?:Once|Passive|Capture)$/;function fl(e){let t,n;for(;(n=e.match(ul))&&!dl.test(e);)t||={},e=e.slice(0,e.length-n[1].length),t[n[1].toLowerCase()]=!0;return[e[2]===`:`?e.slice(3):oe(e.slice(2)),t]}var pl=0,ml=Promise.resolve(),hl=()=>pl||=(ml.then(()=>pl=0),Date.now());function gl(e,t){let n=e=>{if(!e._vts)e._vts=Date.now();else if(e._vts<=n.attached)return;let r=n.value;if(p(r)){let n=e.stopImmediatePropagation;e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0};let i=r.slice(),a=[e];for(let n=0;n<i.length&&!e._stopped;n++){let e=i[n];e&&Hn(e,t,5,a)}}else Hn(r,t,5,[e])};return n.value=e,n.attached=hl(),n}var _l=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,vl=(e,t,n,r,i,a)=>{let o=i===`svg`;t===`class`?zc(e,r,o):t===`style`?Xc(e,n,r):s(t)?c(t)||ll(e,t,n,r,a):(t[0]===`.`?(t=t.slice(1),!0):t[0]===`^`?(t=t.slice(1),!1):yl(e,t,r,o))?(al(e,t,r),!e.tagName.includes(`-`)&&(t===`value`||t===`checked`||t===`selected`)&&il(e,t,r,o,a,t!==`value`)):e._isVueCE&&(bl(e,t)||e._def.__asyncLoader&&(/[A-Z]/.test(t)||!y(r)))?al(e,E(t),r,a,t):(t===`true-value`?e._trueValue=r:t===`false-value`&&(e._falseValue=r),il(e,t,r,o))};function yl(e,t,n,r){if(r)return!!(t===`innerHTML`||t===`textContent`||t in e&&_l(t)&&v(n));if(t===`spellcheck`||t===`draggable`||t===`translate`||t===`autocorrect`||t===`sandbox`&&e.tagName===`IFRAME`||t===`form`||t===`list`&&e.tagName===`INPUT`||t===`type`&&e.tagName===`TEXTAREA`)return!1;if(t===`width`||t===`height`){let t=e.tagName;if(t===`IMG`||t===`VIDEO`||t===`CANVAS`||t===`SOURCE`)return!1}return _l(t)&&y(n)?!1:t in e}function bl(e,t){let n=e._def.props;if(!n)return!1;let r=E(t);return Array.isArray(n)?n.some(e=>E(e)===r):Object.keys(n).some(e=>E(e)===r)}var xl={};function Sl(e,t,n){let r=F(e,t);te(r)&&(r=l({},r,t));class i extends Tl{constructor(e){super(r,e,n)}}return i.def=r,i}var Cl=((e,t)=>Sl(e,t,gu)),wl=typeof HTMLElement<`u`?HTMLElement:class{},Tl=class e extends wl{constructor(e,t={},n=hu){super(),this._def=e,this._props=t,this._createApp=n,this._isVueCE=!0,this._instance=null,this._app=null,this._nonce=this._def.nonce,this._connected=!1,this._resolved=!1,this._patching=!1,this._dirty=!1,this._numberProps=null,this._styleChildren=new WeakSet,this._styleAnchors=new WeakMap,this._ob=null,this.shadowRoot&&n!==hu?this._root=this.shadowRoot:e.shadowRoot===!1?this._root=this:(this.attachShadow(l({},e.shadowRootOptions,{mode:`open`})),this._root=this.shadowRoot)}connectedCallback(){if(!this.isConnected)return;!this.shadowRoot&&!this._resolved&&this._parseSlots(),this._connected=!0;let t=this;for(;t&&=t.assignedSlot||t.parentNode||t.host;)if(t instanceof e){this._parent=t;break}this._instance||(this._resolved?this._mount(this._def):t&&t._pendingResolve?this._pendingResolve=t._pendingResolve.then(()=>{if(this._pendingResolve=void 0,this.isConnected)return this._resolveDef()}):this._resolveDef())}_setParent(e=this._parent){e&&(this._instance.parent=e._instance,this._inheritParentContext(e))}_inheritParentContext(e=this._parent){e&&this._app&&Object.setPrototypeOf(this._app._context.provides,e._instance.provides)}disconnectedCallback(){this._connected=!1,Qn(()=>{this._connected||(this._ob&&=(this._ob.disconnect(),null),this._app&&this._app.unmount(),this._instance&&(this._instance.ce=void 0),this._app=this._instance=null,this._teleportTargets&&=(this._teleportTargets.clear(),void 0))})}_processMutations(e){for(let t of e)this._setAttr(t.attributeName)}_resolveDef(){if(this._pendingResolve)return this._pendingResolve;for(let e=0;e<this.attributes.length;e++)this._setAttr(this.attributes[e].name);this._ob=new MutationObserver(this._processMutations.bind(this)),this._ob.observe(this,{attributes:!0});let e=(e,t=!1)=>{this._resolved=!0,this._pendingResolve=void 0;let{props:n,styles:r}=e,i;if(n&&!p(n))for(let e in n){let t=n[e];(t===Number||t&&t.type===Number)&&(e in this._props&&(this._props[e]=fe(this._props[e])),(i||=Object.create(null))[E(e)]=!0)}this._numberProps=i,this._resolveProps(e),this.shadowRoot&&this._applyStyles(r),this._mount(e)},t=this._def.__asyncLoader;if(t)return this._pendingResolve=t().then(t=>{t.configureApp=this._def.configureApp,e(this._def=t,!0)}),this._pendingResolve;e(this._def)}_mount(e){this._app=this._createApp(e),this._inheritParentContext(),e.configureApp&&e.configureApp(this._app),this._app._ceVNode=this._createVNode(),this._app.mount(this._root);let t=this._instance&&this._instance.exposed;if(t)for(let e in t)f(this,e)||Object.defineProperty(this,e,{get:()=>N(t[e])})}_resolveProps(e){let{props:t}=e,n=p(t)?t:Object.keys(t||{});for(let e of Object.keys(this))e[0]!==`_`&&n.includes(e)&&this._setProp(e,this[e]);for(let e of n.map(E))Object.defineProperty(this,e,{get(){return this._getProp(e)},set(t){this._setProp(e,t,!0,!this._patching)}})}_setAttr(e){if(e.startsWith(`data-v-`))return;let t=this.hasAttribute(e),n=t?this.getAttribute(e):xl,r=E(e);t&&this._numberProps&&this._numberProps[r]&&(n=fe(n)),this._setProp(r,n,!1,!0)}_getProp(e){return this._props[e]}_setProp(e,t,n=!0,r=!1){if(t!==this._props[e]&&(this._dirty=!0,t===xl?delete this._props[e]:(this._props[e]=t,e===`key`&&this._app&&(this._app._ceVNode.key=t)),r&&this._instance&&this._update(),n)){let n=this._ob;n&&(this._processMutations(n.takeRecords()),n.disconnect()),t===!0?this.setAttribute(oe(e),``):typeof t==`string`||typeof t==`number`?this.setAttribute(oe(e),t+``):t||this.removeAttribute(oe(e)),n&&n.observe(this,{attributes:!0})}}_update(){let e=this._createVNode();this._app&&(e.appContext=this._app._context),pu(e,this._root)}_createVNode(){let e={};this.shadowRoot||(e.onVnodeMounted=e.onVnodeUpdated=this._renderSlots.bind(this));let t=H(this._def,l(e,this._props));return this._instance||(t.ce=e=>{this._instance=e,e.ce=this,e.isCE=!0;let t=(e,t)=>{this.dispatchEvent(new CustomEvent(e,te(t[0])?l({detail:t},t[0]):{detail:t}))};e.emit=(e,...n)=>{t(e,n),oe(e)!==e&&t(oe(e),n)},this._setParent()}),t}_applyStyles(e,t,n){if(!e)return;if(t){if(t===this._def||this._styleChildren.has(t))return;this._styleChildren.add(t)}let r=this._nonce,i=this.shadowRoot,a=n?this._getStyleAnchor(n)||this._getStyleAnchor(this._def):this._getRootStyleInsertionAnchor(i),o=null;for(let s=e.length-1;s>=0;s--){let c=document.createElement(`style`);r&&c.setAttribute(`nonce`,r),c.textContent=e[s],i.insertBefore(c,o||a),o=c,s===0&&(n||this._styleAnchors.set(this._def,c),t&&this._styleAnchors.set(t,c))}}_getStyleAnchor(e){if(!e)return null;let t=this._styleAnchors.get(e);return t&&t.parentNode===this.shadowRoot?t:(t&&this._styleAnchors.delete(e),null)}_getRootStyleInsertionAnchor(e){for(let t=0;t<e.childNodes.length;t++){let n=e.childNodes[t];if(!(n instanceof HTMLStyleElement))return n}return null}_parseSlots(){let e=this._slots={},t;for(;t=this.firstChild;){let n=t.nodeType===1&&t.getAttribute(`slot`)||`default`;(e[n]||(e[n]=[])).push(t),this.removeChild(t)}}_renderSlots(){let e=this._getSlots(),t=this._instance.type.__scopeId;for(let n=0;n<e.length;n++){let r=e[n],i=r.getAttribute(`name`)||`default`,a=this._slots[i],o=r.parentNode;if(a)for(let e of a){if(t&&e.nodeType===1){let n=t+`-s`,r=document.createTreeWalker(e,1);e.setAttribute(n,``);let i;for(;i=r.nextNode();)i.setAttribute(n,``)}o.insertBefore(e,r)}else for(;r.firstChild;)o.insertBefore(r.firstChild,r);o.removeChild(r)}}_getSlots(){let e=[this];this._teleportTargets&&e.push(...this._teleportTargets);let t=new Set;for(let n of e){let e=n.querySelectorAll(`slot`);for(let n=0;n<e.length;n++)t.add(e[n])}return Array.from(t)}_injectChildStyle(e,t){this._applyStyles(e.styles,e,t)}_beginPatch(){this._patching=!0,this._dirty=!1}_endPatch(){this._patching=!1,this._dirty&&this._instance&&this._update()}_hasShadowRoot(){return this._def.shadowRoot!==!1}_removeChildStyle(e){}};function El(e){let t=Fs();return t&&t.ce||null}function Dl(){let e=El();return e&&e.shadowRoot}function Ol(e=`$style`){{let t=Fs();if(!t)return r;let n=t.type.__cssModules;return n&&n[e]||r}}var kl=new WeakMap,Al=new WeakMap,jl=Symbol(`_moveCb`),Ml=Symbol(`_enterCb`),Nl=(e=>(delete e.props.mode,e))({name:`TransitionGroup`,props:l({},Cc,{tag:String,moveClass:String}),setup(e,{slots:t}){let n=Fs(),r=Kr(),i,a;return $i(()=>{if(!i.length)return;let t=e.moveClass||`${e.name||`v`}-move`;if(!Rl(i[0].el,n.vnode.el,t)){i=[];return}i.forEach(Pl),i.forEach(Fl);let r=i.filter(Il);Rc(n.vnode.el),r.forEach(e=>{let n=e.el,r=n.style;Ac(n,t),r.transform=r.webkitTransform=r.transitionDuration=``;let i=n[jl]=e=>{e&&e.target!==n||(!e||e.propertyName.endsWith(`transform`))&&(n.removeEventListener(`transitionend`,i),n[jl]=null,jc(n,t))};n.addEventListener(`transitionend`,i)}),i=[]}),()=>{let o=A(e),s=Dc(o),c=o.tag||L;if(i=[],a)for(let e=0;e<a.length;e++){let t=a[e];t.el&&t.el instanceof Element&&!t.el[Vc]&&(i.push(t),ri(t,ei(t,s,r,n)),kl.set(t,Ll(t.el)))}a=t.default?ii(t.default()):[];for(let e=0;e<a.length;e++){let t=a[e];t.key!=null&&ri(t,ei(t,s,r,n))}return H(c,null,a)}}});function Pl(e){let t=e.el;t[jl]&&t[jl](),t[Ml]&&t[Ml]()}function Fl(e){Al.set(e,Ll(e.el))}function Il(e){let t=kl.get(e),n=Al.get(e),r=t.left-n.left,i=t.top-n.top;if(r||i){let t=e.el,n=t.style,a=t.getBoundingClientRect(),o=1,s=1;return t.offsetWidth&&(o=a.width/t.offsetWidth),t.offsetHeight&&(s=a.height/t.offsetHeight),(!Number.isFinite(o)||o===0)&&(o=1),(!Number.isFinite(s)||s===0)&&(s=1),Math.abs(o-1)<.01&&(o=1),Math.abs(s-1)<.01&&(s=1),n.transform=n.webkitTransform=`translate(${r/o}px,${i/s}px)`,n.transitionDuration=`0s`,e}}function Ll(e){let t=e.getBoundingClientRect();return{left:t.left,top:t.top}}function Rl(e,t,n){let r=e.cloneNode(),i=e[xc];i&&i.forEach(e=>{e.split(/\s+/).forEach(e=>e&&r.classList.remove(e))}),n.split(/\s+/).forEach(e=>e&&r.classList.add(e)),r.style.display=`none`;let a=t.nodeType===1?t:t.parentNode;a.appendChild(r);let{hasTransform:o}=Fc(r);return a.removeChild(r),o}var zl=e=>{let t=e.props[`onUpdate:modelValue`]||!1;return p(t)?e=>le(t,e):t};function Bl(e){e.target.composing=!0}function Vl(e){let t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event(`input`)))}var Hl=Symbol(`_assign`),Ul=Symbol(`_initialValue`);function Wl(e,t,n){return t&&(e=e.trim()),n&&(e=de(e)),e}var Gl={created(e,{modifiers:{lazy:t,trim:n,number:r}},i){e.parentNode&&(e.type===`text`?e[Ul]=e.defaultValue.replace(/[\r\n]/g,``):e.type===`textarea`&&(e[Ul]=e.defaultValue.replace(/\r\n?/g,`
`))),e[Hl]=zl(i);let a=r||i.props&&i.props.type===`number`;ol(e,t?`change`:`input`,t=>{t.target.composing||e[Hl](Wl(e.value,n,a))}),(n||a)&&ol(e,`change`,()=>{e.value=Wl(e.value,n,a)}),t||(ol(e,`compositionstart`,Bl),ol(e,`compositionend`,Vl),ol(e,`change`,Vl))},mounted(e,{value:t,modifiers:{trim:n,number:r}}){let i=t??``,a=e[Ul];delete e[Ul],a!==void 0&&(e.type===`text`||e.type===`textarea`)&&e.value!==a?e[Hl](Wl(e.value,n,r)):e.value=i},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:r,trim:i,number:a}},o){if(e[Hl]=zl(o),e.composing)return;let s=(a||e.type===`number`)&&!/^0\d/.test(e.value)?de(e.value):e.value,c=t??``;if(s===c)return;let l=e.getRootNode();(l instanceof Document||l instanceof ShadowRoot)&&l.activeElement===e&&e.type!==`range`&&(r&&t===n||i&&e.value.trim()===c)||(e.value=c)}},Kl={deep:!0,created(e,t,n){e[Hl]=zl(n),ol(e,`change`,()=>{let t=e._modelValue,n=Zl(e),r=e.checked,i=e[Hl];if(p(t)){let e=De(t,n),a=e!==-1;if(r&&!a)i(t.concat(n));else if(!r&&a){let n=[...t];n.splice(e,1),i(n)}}else if(h(t)){let e=new Set(t);r?e.add(n):e.delete(n),i(e)}else i(Ql(e,r))})},mounted:ql,beforeUpdate(e,t,n){e[Hl]=zl(n),ql(e,t,n)}};function ql(e,{value:t,oldValue:n},r){e._modelValue=t;let i;if(p(t))i=De(t,r.props.value)>-1;else if(h(t))i=t.has(r.props.value);else{if(t===n)return;i=Ee(t,Ql(e,!0))}e.checked!==i&&(e.checked=i)}var Jl={created(e,{value:t},n){e.checked=Ee(t,n.props.value),e[Hl]=zl(n),ol(e,`change`,()=>{e[Hl](Zl(e))})},beforeUpdate(e,{value:t,oldValue:n},r){e[Hl]=zl(r),t!==n&&(e.checked=Ee(t,r.props.value))}},Yl={deep:!0,created(e,{value:t,modifiers:{number:n}},r){e._modelValue=t,ol(e,`change`,()=>{let t=Array.prototype.filter.call(e.options,e=>e.selected).map(e=>n?de(Zl(e)):Zl(e));e[Hl](e.multiple?h(e._modelValue)?new Set(t):t:t[0]),e._assigning=!0,Qn(()=>{e._assigning=!1})}),e[Hl]=zl(r)},mounted(e,{value:t}){Xl(e,t)},beforeUpdate(e,{value:t},n){e._modelValue=t,e[Hl]=zl(n)},updated(e,{value:t}){e._assigning||Xl(e,t)}};function Xl(e,t){let n=e.multiple,r=p(t);if(!(n&&!r&&!h(t))){for(let i=0,a=e.options.length;i<a;i++){let a=e.options[i],o=Zl(a);if(n){if(r){let e=typeof o;a.selected=e===`string`||e===`number`?t.some(e=>String(e)===String(o)):De(t,o)>-1}else a.selected=t.has(o)}else if(Ee(Zl(a),t)){e.selectedIndex!==i&&(e.selectedIndex=i);return}}!n&&e.selectedIndex!==-1&&(e.selectedIndex=-1)}}function Zl(e){return`_value`in e?e._value:e.value}function Ql(e,t){let n=t?`_trueValue`:`_falseValue`;return n in e?e[n]:t}var $l={created(e,t,n){tu(e,t,n,null,`created`)},mounted(e,t,n){tu(e,t,n,null,`mounted`)},beforeUpdate(e,t,n,r){tu(e,t,n,r,`beforeUpdate`)},updated(e,t,n,r){tu(e,t,n,r,`updated`)}};function eu(e,t){switch(e){case`SELECT`:return Yl;case`TEXTAREA`:return Gl;default:switch(t){case`checkbox`:return Kl;case`radio`:return Jl;default:return Gl}}}function tu(e,t,n,r,i){let a=eu(e.tagName,n.props&&n.props.type)[i];a&&a(e,t,n,r)}function nu(){Gl.getSSRProps=({value:e})=>({value:e}),Jl.getSSRProps=({value:e},t)=>{if(t.props&&Ee(t.props.value,e))return{checked:!0}},Kl.getSSRProps=({value:e},t)=>{if(p(e)){if(t.props&&De(e,t.props.value)>-1)return{checked:!0}}else if(h(e)){if(t.props&&e.has(t.props.value))return{checked:!0}}else if(e)return{checked:!0}},$l.getSSRProps=(e,t)=>{if(typeof t.type!=`string`)return;let n=eu(t.type.toUpperCase(),t.props&&t.props.type);if(n.getSSRProps)return n.getSSRProps(e,t)}}var ru=[`ctrl`,`shift`,`alt`,`meta`],iu={stop:e=>e.stopPropagation(),prevent:e=>e.preventDefault(),self:e=>e.target!==e.currentTarget,ctrl:e=>!e.ctrlKey,shift:e=>!e.shiftKey,alt:e=>!e.altKey,meta:e=>!e.metaKey,left:e=>`button`in e&&e.button!==0,middle:e=>`button`in e&&e.button!==1,right:e=>`button`in e&&e.button!==2,exact:(e,t)=>ru.some(n=>e[`${n}Key`]&&!t.includes(n))},au=(e,t)=>{if(!e)return e;let n=e._withMods||={},r=t.join(`.`);return n[r]||(n[r]=((n,...r)=>{for(let e=0;e<t.length;e++){let r=iu[t[e]];if(r&&r(n,t))return}return e(n,...r)}))},ou={esc:`escape`,space:` `,up:`arrow-up`,left:`arrow-left`,right:`arrow-right`,down:`arrow-down`,delete:`backspace`},su=(e,t)=>{let n=e._withKeys||={},r=t.join(`.`);return n[r]||(n[r]=(n=>{if(!(`key`in n))return;let r=oe(n.key);if(t.some(e=>e===r||ou[e]===r))return e(n)}))},cu=l({patchProp:vl},vc),lu,uu=!1;function du(){return lu||=Lo(cu)}function fu(){return lu=uu?lu:Ro(cu),uu=!0,lu}var pu=((...e)=>{du().render(...e)}),mu=((...e)=>{fu().hydrate(...e)}),hu=((...e)=>{let t=du().createApp(...e),{mount:n}=t;return t.mount=e=>{let r=vu(e);if(!r)return;let i=t._component;!v(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent=``);let a=n(r,!1,_u(r));return r instanceof Element&&(r.removeAttribute(`v-cloak`),r.setAttribute(`data-v-app`,``)),a},t}),gu=((...e)=>{let t=fu().createApp(...e),{mount:n}=t;return t.mount=e=>{let t=vu(e);if(t)return n(t,!0,_u(t))},t});function _u(e){if(e instanceof SVGElement)return`svg`;if(typeof MathMLElement==`function`&&e instanceof MathMLElement)return`mathml`}function vu(e){return y(e)?document.querySelector(e):e}var yu=!1,bu=()=>{yu||(yu=!0,nu(),Wc())},xu=t({BaseTransition:()=>Qr,BaseTransitionPropsValidators:()=>Jr,Comment:()=>cs,DeprecationTypes:()=>null,EffectScope:()=>Ne,ErrorCodes:()=>zn,ErrorTypeStrings:()=>sc,Fragment:()=>L,KeepAlive:()=>Bi,ReactiveEffect:()=>ze,Static:()=>ls,Suspense:()=>Xo,Teleport:()=>Vr,Text:()=>ss,TrackOpTypes:()=>En,Transition:()=>wc,TransitionGroup:()=>Nl,TriggerOpTypes:()=>Dn,VueElement:()=>Tl,assertNumber:()=>Rn,callWithAsyncErrorHandling:()=>Hn,callWithErrorHandling:()=>Vn,camelize:()=>E,capitalize:()=>se,cloneVNode:()=>Cs,compatUtils:()=>null,compile:()=>Su,computed:()=>W,createApp:()=>hu,createBlock:()=>B,createCommentVNode:()=>Ts,createElementBlock:()=>z,createElementVNode:()=>V,createHydrationRenderer:()=>Ro,createPropsRestProxy:()=>Ia,createRenderer:()=>Lo,createSSRApp:()=>gu,createSlots:()=>ha,createStaticVNode:()=>ws,createTextVNode:()=>U,createVNode:()=>H,customRef:()=>vn,defineAsyncComponent:()=>Li,defineComponent:()=>F,defineCustomElement:()=>Sl,defineEmits:()=>wa,defineExpose:()=>Ta,defineModel:()=>Oa,defineOptions:()=>Ea,defineProps:()=>Ca,defineSSRCustomElement:()=>Cl,defineSlots:()=>Da,devtools:()=>cc,effect:()=>Qe,effectScope:()=>Pe,getCurrentInstance:()=>Fs,getCurrentScope:()=>Fe,getCurrentWatcher:()=>jn,getTransitionRawChildren:()=>ii,guardReactiveProps:()=>Ss,h:()=>tc,handleError:()=>Un,hasInjectionContext:()=>br,hydrate:()=>mu,hydrateOnIdle:()=>Ai,hydrateOnInteraction:()=>Pi,hydrateOnMediaQuery:()=>Ni,hydrateOnVisible:()=>Mi,initCustomFormatter:()=>nc,initDirectivesForSSR:()=>bu,inject:()=>yr,isMemoSame:()=>ic,isProxy:()=>on,isReactive:()=>nn,isReadonly:()=>rn,isRef:()=>j,isRuntimeOnly:()=>Js,isShallow:()=>an,isVNode:()=>gs,markRaw:()=>sn,mergeDefaults:()=>Pa,mergeModels:()=>Fa,mergeProps:()=>ks,nextTick:()=>Qn,nodeOps:()=>vc,normalizeClass:()=>O,normalizeProps:()=>xe,normalizeStyle:()=>ge,onActivated:()=>Hi,onBeforeMount:()=>Xi,onBeforeUnmount:()=>ea,onBeforeUpdate:()=>Qi,onDeactivated:()=>Ui,onErrorCaptured:()=>aa,onMounted:()=>Zi,onRenderTracked:()=>ia,onRenderTriggered:()=>ra,onScopeDispose:()=>Ie,onServerPrefetch:()=>na,onUnmounted:()=>ta,onUpdated:()=>$i,onWatcherCleanup:()=>Mn,openBlock:()=>R,patchProp:()=>vl,popScopeId:()=>mr,provide:()=>vr,proxyRefs:()=>gn,pushScopeId:()=>pr,queuePostFlushCb:()=>nr,reactive:()=>Zt,readonly:()=>$t,ref:()=>M,registerRuntimeCompiler:()=>qs,render:()=>pu,renderList:()=>ma,renderSlot:()=>I,resolveComponent:()=>ca,resolveDirective:()=>da,resolveDynamicComponent:()=>ua,resolveFilter:()=>null,resolveTransitionHooks:()=>ei,setBlockTracking:()=>ms,setDevtoolsHook:()=>lc,setTransitionHooks:()=>ri,shallowReactive:()=>Qt,shallowReadonly:()=>en,shallowRef:()=>un,ssrContextKey:()=>xr,ssrUtils:()=>uc,stop:()=>$e,toDisplayString:()=>k,toHandlerKey:()=>ce,toHandlers:()=>_a,toRaw:()=>A,toRef:()=>Sn,toRefs:()=>yn,toValue:()=>mn,transformVNodeArgs:()=>vs,triggerRef:()=>pn,unref:()=>N,useAttrs:()=>ja,useCssModule:()=>Ol,useCssVars:()=>Kc,useHost:()=>El,useId:()=>ai,useModel:()=>ro,useSSRContext:()=>Sr,useShadowRoot:()=>Dl,useSlots:()=>Aa,useTemplateRef:()=>si,useTransitionState:()=>Kr,vModelCheckbox:()=>Kl,vModelDynamic:()=>$l,vModelRadio:()=>Jl,vModelSelect:()=>Yl,vModelText:()=>Gl,vShow:()=>Hc,version:()=>ac,warn:()=>oc,watch:()=>Er,watchEffect:()=>Cr,watchPostEffect:()=>wr,watchSyncEffect:()=>Tr,withAsyncContext:()=>La,withCtx:()=>P,withDefaults:()=>ka,withDirectives:()=>gr,withKeys:()=>su,withMemo:()=>rc,withModifiers:()=>au,withScopeId:()=>hr}),Su=()=>{};function Cu(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function wu(e){if(Array.isArray(e))return e}function Tu(e){if(Array.isArray(e))return Cu(e)}function Eu(e,t){if(!(e instanceof t))throw TypeError(`Cannot call a class as a function`)}function Du(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,`value`in r&&(r.writable=!0),Object.defineProperty(e,Ru(r.key),r)}}function Ou(e,t,n){return t&&Du(e.prototype,t),n&&Du(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function ku(e,t){var n=typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(!n){if(Array.isArray(e)||(n=Bu(e))||t&&e&&typeof e.length==`number`){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw TypeError(`Invalid attempt to iterate non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||n.return==null||n.return()}finally{if(s)throw a}}}}function G(e,t,n){return(t=Ru(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function Au(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function ju(e,t){var n=e==null?null:typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(n!=null){var r,i,a,o,s=[],c=!0,l=!1;try{if(a=(n=n.call(e)).next,t===0){if(Object(n)!==n)return;c=!1}else for(;!(c=(r=a.call(n)).done)&&(s.push(r.value),s.length!==t);c=!0);}catch(e){l=!0,i=e}finally{try{if(!c&&n.return!=null&&(o=n.return(),Object(o)!==o))return}finally{if(l)throw i}}return s}}function Mu(){throw TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Nu(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Pu(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function K(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Pu(Object(n),!0).forEach(function(t){G(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Pu(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function Fu(e,t){return wu(e)||ju(e,t)||Bu(e,t)||Mu()}function Iu(e){return Tu(e)||Au(e)||Bu(e)||Nu()}function Lu(e,t){if(typeof e!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(typeof r!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function Ru(e){var t=Lu(e,`string`);return typeof t==`symbol`?t:t+``}function zu(e){"@babel/helpers - typeof";return zu=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},zu(e)}function Bu(e,t){if(e){if(typeof e==`string`)return Cu(e,t);var n={}.toString.call(e).slice(8,-1);return n===`Object`&&e.constructor&&(n=e.constructor.name),n===`Map`||n===`Set`?Array.from(e):n===`Arguments`||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?Cu(e,t):void 0}}var Vu=function(){},Hu={},Uu={},Wu=null,Gu={mark:Vu,measure:Vu};try{typeof window<`u`&&(Hu=window),typeof document<`u`&&(Uu=document),typeof MutationObserver<`u`&&(Wu=MutationObserver),typeof performance<`u`&&(Gu=performance)}catch{}var Ku=(Hu.navigator||{}).userAgent,qu=Ku===void 0?``:Ku,Ju=Hu,Yu=Uu,Xu=Wu,Zu=Gu;Ju.document;var Qu=!!Yu.documentElement&&!!Yu.head&&typeof Yu.addEventListener==`function`&&typeof Yu.createElement==`function`,$u=~qu.indexOf(`MSIE`)||~qu.indexOf(`Trident/`),ed,td=/fa(k|kd|s|r|l|t|d|dr|dl|dt|b|slr|slpr|wsb|tl|ns|nds|es|gt|jr|jfr|jdr|usb|ufsb|udsb|cr|ss|sr|sl|st|sds|sdr|sdl|sdt|sldr|slpdr|pr|ms|vs)?[\-\ ]/,nd=/Font ?Awesome ?([567 ]*)(Solid|Regular|Light|Thin|Duotone|Brands|Free|Pro|Sharp Duotone|Sharp|Kit|Notdog Duo|Notdog|Chisel|Etch|Graphite|Thumbprint|Jelly Fill|Jelly Duo|Jelly|Utility|Utility Fill|Utility Duo|Slab Press|Slab|Slab Duo|Slab Press Duo|Pixel|Mosaic|Vellum|Whiteboard)?.*/i,rd={classic:{fa:`solid`,fas:`solid`,"fa-solid":`solid`,far:`regular`,"fa-regular":`regular`,fal:`light`,"fa-light":`light`,fat:`thin`,"fa-thin":`thin`,fab:`brands`,"fa-brands":`brands`},duotone:{fa:`solid`,fad:`solid`,"fa-solid":`solid`,"fa-duotone":`solid`,fadr:`regular`,"fa-regular":`regular`,fadl:`light`,"fa-light":`light`,fadt:`thin`,"fa-thin":`thin`},sharp:{fa:`solid`,fass:`solid`,"fa-solid":`solid`,fasr:`regular`,"fa-regular":`regular`,fasl:`light`,"fa-light":`light`,fast:`thin`,"fa-thin":`thin`},"sharp-duotone":{fa:`solid`,fasds:`solid`,"fa-solid":`solid`,fasdr:`regular`,"fa-regular":`regular`,fasdl:`light`,"fa-light":`light`,fasdt:`thin`,"fa-thin":`thin`},slab:{"fa-regular":`regular`,faslr:`regular`},"slab-press":{"fa-regular":`regular`,faslpr:`regular`},"slab-duo":{"fa-regular":`regular`,fasldr:`regular`},"slab-press-duo":{"fa-regular":`regular`,faslpdr:`regular`},thumbprint:{"fa-light":`light`,fatl:`light`},vellum:{"fa-solid":`solid`,favs:`solid`},pixel:{"fa-regular":`regular`,fapr:`regular`},mosaic:{"fa-solid":`solid`,fams:`solid`},whiteboard:{"fa-semibold":`semibold`,fawsb:`semibold`},notdog:{"fa-solid":`solid`,fans:`solid`},"notdog-duo":{"fa-solid":`solid`,fands:`solid`},etch:{"fa-solid":`solid`,faes:`solid`},graphite:{"fa-thin":`thin`,fagt:`thin`},jelly:{"fa-regular":`regular`,fajr:`regular`},"jelly-fill":{"fa-regular":`regular`,fajfr:`regular`},"jelly-duo":{"fa-regular":`regular`,fajdr:`regular`},chisel:{"fa-regular":`regular`,facr:`regular`},utility:{"fa-semibold":`semibold`,fausb:`semibold`},"utility-duo":{"fa-semibold":`semibold`,faudsb:`semibold`},"utility-fill":{"fa-semibold":`semibold`,faufsb:`semibold`}},id={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},ad=[`fa-classic`,`fa-duotone`,`fa-sharp`,`fa-sharp-duotone`,`fa-thumbprint`,`fa-whiteboard`,`fa-notdog`,`fa-notdog-duo`,`fa-chisel`,`fa-etch`,`fa-graphite`,`fa-jelly`,`fa-jelly-fill`,`fa-jelly-duo`,`fa-slab`,`fa-slab-press`,`fa-slab-press-duo`,`fa-slab-duo`,`fa-mosaic`,`fa-pixel`,`fa-vellum`,`fa-utility`,`fa-utility-duo`,`fa-utility-fill`],od=`classic`,sd=`duotone`,cd=`sharp`,ld=`sharp-duotone`,ud=`chisel`,dd=`etch`,fd=`graphite`,pd=`jelly`,md=`jelly-duo`,hd=`jelly-fill`,gd=`mosaic`,_d=`notdog`,vd=`notdog-duo`,yd=`pixel`,bd=`slab`,xd=`slab-duo`,Sd=`slab-press`,Cd=`slab-press-duo`,wd=`thumbprint`,Td=`utility`,Ed=`utility-duo`,Dd=`utility-fill`,Od=`vellum`,kd=`whiteboard`,Ad=`Classic`,jd=`Duotone`,Md=`Sharp`,Nd=`Sharp Duotone`,Pd=`Chisel`,Fd=`Etch`,Id=`Graphite`,Ld=`Jelly`,Rd=`Jelly Duo`,zd=`Jelly Fill`,Bd=`Mosaic`,Vd=`Notdog`,Hd=`Notdog Duo`,Ud=`Pixel`,Wd=`Slab`,Gd=`Slab Duo`,Kd=`Slab Press`,qd=`Slab Press Duo`,Jd=`Thumbprint`,Yd=`Utility`,Xd=`Utility Duo`,Zd=`Utility Fill`,Qd=`Vellum`,$d=`Whiteboard`,ef=[od,sd,cd,ld,ud,dd,fd,pd,md,hd,gd,_d,vd,yd,bd,xd,Sd,Cd,wd,Td,Ed,Dd,Od,kd];ed={},G(G(G(G(G(G(G(G(G(G(ed,od,Ad),sd,jd),cd,Md),ld,Nd),ud,Pd),dd,Fd),fd,Id),pd,Ld),md,Rd),hd,zd),G(G(G(G(G(G(G(G(G(G(ed,gd,Bd),_d,Vd),vd,Hd),yd,Ud),bd,Wd),xd,Gd),Sd,Kd),Cd,qd),wd,Jd),Td,Yd),G(G(G(G(ed,Ed,Xd),Dd,Zd),Od,Qd),kd,$d);var tf={classic:{900:`fas`,400:`far`,normal:`far`,300:`fal`,100:`fat`},duotone:{900:`fad`,400:`fadr`,300:`fadl`,100:`fadt`},sharp:{900:`fass`,400:`fasr`,300:`fasl`,100:`fast`},"sharp-duotone":{900:`fasds`,400:`fasdr`,300:`fasdl`,100:`fasdt`},slab:{400:`faslr`},"slab-press":{400:`faslpr`},"slab-duo":{400:`fasldr`},"slab-press-duo":{400:`faslpdr`},vellum:{900:`favs`},mosaic:{900:`fams`},pixel:{400:`fapr`},whiteboard:{600:`fawsb`},thumbprint:{300:`fatl`},notdog:{900:`fans`},"notdog-duo":{900:`fands`},etch:{900:`faes`},graphite:{100:`fagt`},chisel:{400:`facr`},jelly:{400:`fajr`},"jelly-fill":{400:`fajfr`},"jelly-duo":{400:`fajdr`},utility:{600:`fausb`},"utility-duo":{600:`faudsb`},"utility-fill":{600:`faufsb`}},nf={"Font Awesome 7 Free":{900:`fas`,400:`far`},"Font Awesome 7 Pro":{900:`fas`,400:`far`,normal:`far`,300:`fal`,100:`fat`},"Font Awesome 7 Brands":{400:`fab`,normal:`fab`},"Font Awesome 7 Duotone":{900:`fad`,400:`fadr`,normal:`fadr`,300:`fadl`,100:`fadt`},"Font Awesome 7 Sharp":{900:`fass`,400:`fasr`,normal:`fasr`,300:`fasl`,100:`fast`},"Font Awesome 7 Sharp Duotone":{900:`fasds`,400:`fasdr`,normal:`fasdr`,300:`fasdl`,100:`fasdt`},"Font Awesome 7 Jelly":{400:`fajr`,normal:`fajr`},"Font Awesome 7 Jelly Fill":{400:`fajfr`,normal:`fajfr`},"Font Awesome 7 Jelly Duo":{400:`fajdr`,normal:`fajdr`},"Font Awesome 7 Slab":{400:`faslr`,normal:`faslr`},"Font Awesome 7 Slab Press":{400:`faslpr`,normal:`faslpr`},"Font Awesome 7 Slab Duo":{400:`fasldr`,normal:`fasldr`},"Font Awesome 7 Slab Press Duo":{400:`faslpdr`,normal:`faslpdr`},"Font Awesome 7 Pixel":{400:`fapr`,normal:`fapr`},"Font Awesome 7 Mosaic":{900:`fams`,normal:`fams`},"Font Awesome 7 Vellum":{900:`favs`,normal:`favs`},"Font Awesome 7 Thumbprint":{300:`fatl`,normal:`fatl`},"Font Awesome 7 Notdog":{900:`fans`,normal:`fans`},"Font Awesome 7 Notdog Duo":{900:`fands`,normal:`fands`},"Font Awesome 7 Etch":{900:`faes`,normal:`faes`},"Font Awesome 7 Graphite":{100:`fagt`,normal:`fagt`},"Font Awesome 7 Chisel":{400:`facr`,normal:`facr`},"Font Awesome 7 Whiteboard":{600:`fawsb`,normal:`fawsb`},"Font Awesome 7 Utility":{600:`fausb`,normal:`fausb`},"Font Awesome 7 Utility Duo":{600:`faudsb`,normal:`faudsb`},"Font Awesome 7 Utility Fill":{600:`faufsb`,normal:`faufsb`}},rf=new Map([[`classic`,{defaultShortPrefixId:`fas`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`,`brands`],futureStyleIds:[],defaultFontWeight:900}],[`duotone`,{defaultShortPrefixId:`fad`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`sharp`,{defaultShortPrefixId:`fass`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`sharp-duotone`,{defaultShortPrefixId:`fasds`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`chisel`,{defaultShortPrefixId:`facr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`etch`,{defaultShortPrefixId:`faes`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`graphite`,{defaultShortPrefixId:`fagt`,defaultStyleId:`thin`,styleIds:[`thin`],futureStyleIds:[],defaultFontWeight:100}],[`jelly`,{defaultShortPrefixId:`fajr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`jelly-duo`,{defaultShortPrefixId:`fajdr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`jelly-fill`,{defaultShortPrefixId:`fajfr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`mosaic`,{defaultShortPrefixId:`fams`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`notdog`,{defaultShortPrefixId:`fans`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`notdog-duo`,{defaultShortPrefixId:`fands`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`pixel`,{defaultShortPrefixId:`fapr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab`,{defaultShortPrefixId:`faslr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-duo`,{defaultShortPrefixId:`fasldr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-press`,{defaultShortPrefixId:`faslpr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-press-duo`,{defaultShortPrefixId:`faslpdr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`thumbprint`,{defaultShortPrefixId:`fatl`,defaultStyleId:`light`,styleIds:[`light`],futureStyleIds:[],defaultFontWeight:300}],[`utility`,{defaultShortPrefixId:`fausb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`utility-duo`,{defaultShortPrefixId:`faudsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`utility-fill`,{defaultShortPrefixId:`faufsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`vellum`,{defaultShortPrefixId:`favs`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`whiteboard`,{defaultShortPrefixId:`fawsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}]]),af={chisel:{regular:`facr`},classic:{brands:`fab`,light:`fal`,regular:`far`,solid:`fas`,thin:`fat`},duotone:{light:`fadl`,regular:`fadr`,solid:`fad`,thin:`fadt`},etch:{solid:`faes`},graphite:{thin:`fagt`},jelly:{regular:`fajr`},"jelly-duo":{regular:`fajdr`},"jelly-fill":{regular:`fajfr`},mosaic:{solid:`fams`},notdog:{solid:`fans`},"notdog-duo":{solid:`fands`},pixel:{regular:`fapr`},sharp:{light:`fasl`,regular:`fasr`,solid:`fass`,thin:`fast`},"sharp-duotone":{light:`fasdl`,regular:`fasdr`,solid:`fasds`,thin:`fasdt`},slab:{regular:`faslr`},"slab-duo":{regular:`fasldr`},"slab-press":{regular:`faslpr`},"slab-press-duo":{regular:`faslpdr`},thumbprint:{light:`fatl`},utility:{semibold:`fausb`},"utility-duo":{semibold:`faudsb`},"utility-fill":{semibold:`faufsb`},vellum:{solid:`favs`},whiteboard:{semibold:`fawsb`}},of=[`fak`,`fa-kit`,`fakd`,`fa-kit-duotone`],sf={kit:{fak:`kit`,"fa-kit":`kit`},"kit-duotone":{fakd:`kit-duotone`,"fa-kit-duotone":`kit-duotone`}},cf=[`kit`];G(G({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var lf={kit:{"fa-kit":`fak`},"kit-duotone":{"fa-kit-duotone":`fakd`}},uf={"Font Awesome Kit":{400:`fak`,normal:`fak`},"Font Awesome Kit Duotone":{400:`fakd`,normal:`fakd`}},df={kit:{fak:`fa-kit`},"kit-duotone":{fakd:`fa-kit-duotone`}},ff={kit:{kit:`fak`},"kit-duotone":{"kit-duotone":`fakd`}},pf,mf={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},hf=[`fa-classic`,`fa-duotone`,`fa-sharp`,`fa-sharp-duotone`,`fa-thumbprint`,`fa-whiteboard`,`fa-notdog`,`fa-notdog-duo`,`fa-chisel`,`fa-etch`,`fa-graphite`,`fa-jelly`,`fa-jelly-fill`,`fa-jelly-duo`,`fa-slab`,`fa-slab-press`,`fa-slab-press-duo`,`fa-slab-duo`,`fa-mosaic`,`fa-pixel`,`fa-vellum`,`fa-utility`,`fa-utility-duo`,`fa-utility-fill`];pf={},G(G(G(G(G(G(G(G(G(G(pf,`classic`,`Classic`),`duotone`,`Duotone`),`sharp`,`Sharp`),`sharp-duotone`,`Sharp Duotone`),`chisel`,`Chisel`),`etch`,`Etch`),`graphite`,`Graphite`),`jelly`,`Jelly`),`jelly-duo`,`Jelly Duo`),`jelly-fill`,`Jelly Fill`),G(G(G(G(G(G(G(G(G(G(pf,`mosaic`,`Mosaic`),`notdog`,`Notdog`),`notdog-duo`,`Notdog Duo`),`pixel`,`Pixel`),`slab`,`Slab`),`slab-duo`,`Slab Duo`),`slab-press`,`Slab Press`),`slab-press-duo`,`Slab Press Duo`),`thumbprint`,`Thumbprint`),`utility`,`Utility`),G(G(G(G(pf,`utility-duo`,`Utility Duo`),`utility-fill`,`Utility Fill`),`vellum`,`Vellum`),`whiteboard`,`Whiteboard`),G(G({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var gf={classic:{"fa-brands":`fab`,"fa-duotone":`fad`,"fa-light":`fal`,"fa-regular":`far`,"fa-solid":`fas`,"fa-thin":`fat`},duotone:{"fa-regular":`fadr`,"fa-light":`fadl`,"fa-thin":`fadt`},sharp:{"fa-solid":`fass`,"fa-regular":`fasr`,"fa-light":`fasl`,"fa-thin":`fast`},"sharp-duotone":{"fa-solid":`fasds`,"fa-regular":`fasdr`,"fa-light":`fasdl`,"fa-thin":`fasdt`},slab:{"fa-regular":`faslr`},"slab-press":{"fa-regular":`faslpr`},"slab-duo":{"fa-regular":`fasldr`},"slab-press-duo":{"fa-regular":`faslpdr`},pixel:{"fa-regular":`fapr`},mosaic:{"fa-solid":`fams`},vellum:{"fa-solid":`favs`},whiteboard:{"fa-semibold":`fawsb`},thumbprint:{"fa-light":`fatl`},notdog:{"fa-solid":`fans`},"notdog-duo":{"fa-solid":`fands`},etch:{"fa-solid":`faes`},graphite:{"fa-thin":`fagt`},jelly:{"fa-regular":`fajr`},"jelly-fill":{"fa-regular":`fajfr`},"jelly-duo":{"fa-regular":`fajdr`},chisel:{"fa-regular":`facr`},utility:{"fa-semibold":`fausb`},"utility-duo":{"fa-semibold":`faudsb`},"utility-fill":{"fa-semibold":`faufsb`}},_f={classic:[`fas`,`far`,`fal`,`fat`,`fad`],duotone:[`fadr`,`fadl`,`fadt`],sharp:[`fass`,`fasr`,`fasl`,`fast`],"sharp-duotone":[`fasds`,`fasdr`,`fasdl`,`fasdt`],slab:[`faslr`],"slab-press":[`faslpr`],"slab-duo":[`fasldr`],"slab-press-duo":[`faslpdr`],pixel:[`fapr`],mosaic:[`fams`],vellum:[`favs`],whiteboard:[`fawsb`],thumbprint:[`fatl`],notdog:[`fans`],"notdog-duo":[`fands`],etch:[`faes`],graphite:[`fagt`],jelly:[`fajr`],"jelly-fill":[`fajfr`],"jelly-duo":[`fajdr`],chisel:[`facr`],utility:[`fausb`],"utility-duo":[`faudsb`],"utility-fill":[`faufsb`]},vf={classic:{fab:`fa-brands`,fad:`fa-duotone`,fal:`fa-light`,far:`fa-regular`,fas:`fa-solid`,fat:`fa-thin`},duotone:{fadr:`fa-regular`,fadl:`fa-light`,fadt:`fa-thin`},sharp:{fass:`fa-solid`,fasr:`fa-regular`,fasl:`fa-light`,fast:`fa-thin`},"sharp-duotone":{fasds:`fa-solid`,fasdr:`fa-regular`,fasdl:`fa-light`,fasdt:`fa-thin`},slab:{faslr:`fa-regular`},"slab-press":{faslpr:`fa-regular`},"slab-duo":{fasldr:`fa-regular`},"slab-press-duo":{faslpdr:`fa-regular`},pixel:{fapr:`fa-regular`},mosaic:{fams:`fa-solid`},vellum:{favs:`fa-solid`},whiteboard:{fawsb:`fa-semibold`},thumbprint:{fatl:`fa-light`},notdog:{fans:`fa-solid`},"notdog-duo":{fands:`fa-solid`},etch:{faes:`fa-solid`},graphite:{fagt:`fa-thin`},jelly:{fajr:`fa-regular`},"jelly-fill":{fajfr:`fa-regular`},"jelly-duo":{fajdr:`fa-regular`},chisel:{facr:`fa-regular`},utility:{fausb:`fa-semibold`},"utility-duo":{faudsb:`fa-semibold`},"utility-fill":{faufsb:`fa-semibold`}},yf=`fa.fas.far.fal.fat.fad.fadr.fadl.fadt.fab.fass.fasr.fasl.fast.fasds.fasdr.fasdl.fasdt.faslr.faslpr.fasldr.faslpdr.fapr.fams.favs.fawsb.fatl.fans.fands.faes.fagt.fajr.fajfr.fajdr.facr.fausb.faudsb.faufsb`.split(`.`).concat(hf,[`fa-solid`,`fa-regular`,`fa-light`,`fa-thin`,`fa-duotone`,`fa-brands`,`fa-semibold`]),bf=[`solid`,`regular`,`light`,`thin`,`duotone`,`brands`,`semibold`],xf=[1,2,3,4,5,6,7,8,9,10],Sf=xf.concat([11,12,13,14,15,16,17,18,19,20]),Cf=[].concat(Iu(Object.keys(_f)),bf,[`aw`,`fw`,`pull-left`,`pull-right`],[`2xs`,`xs`,`sm`,`lg`,`xl`,`2xl`,`beat`,`beat-fade`,`border`,`bounce`,`buzz`,`canvas-square`,`canvas-roomy`,`fade`,`flip-360`,`flip-both`,`flip-horizontal`,`flip-vertical`,`flip`,`float`,`inverse`,`jello`,`layers`,`layers-bottom-left`,`layers-bottom-right`,`layers-counter`,`layers-text`,`layers-top-left`,`layers-top-right`,`li`,`pull-end`,`pull-start`,`pulse`,`rotate-180`,`rotate-270`,`rotate-90`,`rotate-by`,`shake`,`spin-pulse`,`spin-reverse`,`spin`,`spin-snap`,`spin-snap-4`,`spin-snap-8`,`stack-1x`,`stack-2x`,`stack`,`swing`,`ul`,`wag`,`width-auto`,`width-fixed`,mf.GROUP,mf.SWAP_OPACITY,mf.PRIMARY,mf.SECONDARY],xf.map(function(e){return`${e}x`}),Sf.map(function(e){return`w-${e}`})),wf={"Font Awesome 5 Free":{900:`fas`,400:`far`},"Font Awesome 5 Pro":{900:`fas`,400:`far`,normal:`far`,300:`fal`},"Font Awesome 5 Brands":{400:`fab`,normal:`fab`},"Font Awesome 5 Duotone":{900:`fad`}},Tf=`___FONT_AWESOME___`,Ef=16,Df=`fa`,Of=`svg-inline--fa`,kf=`data-fa-i2svg`,Af=`data-fa-pseudo-element`,jf=`data-fa-pseudo-element-pending`,Mf=`data-prefix`,Nf=`data-icon`,Pf=`fontawesome-i2svg`,Ff=`async`,If=[`HTML`,`HEAD`,`STYLE`,`SCRIPT`],Lf=[`::before`,`::after`,`:before`,`:after`],Rf=function(){try{return!0}catch{return!1}}();function zf(e){return new Proxy(e,{get:function(e,t){return t in e?e[t]:e[od]}})}var Bf=K({},rd);Bf[od]=K(K(K(K({},{"fa-duotone":`duotone`}),rd[od]),sf.kit),sf[`kit-duotone`]);var Vf=zf(Bf),Hf=K({},af);Hf[od]=K(K(K(K({},{duotone:`fad`}),Hf[od]),ff.kit),ff[`kit-duotone`]);var Uf=zf(Hf),Wf=K({},vf);Wf[od]=K(K({},Wf[od]),df.kit);var Gf=zf(Wf),Kf=K({},gf);Kf[od]=K(K({},Kf[od]),lf.kit),zf(Kf);var qf=td,Jf=`fa-layers-text`,Yf=nd;zf(K({},tf));var Xf=[`class`,`data-prefix`,`data-icon`,`data-fa-transform`,`data-fa-mask`],Zf=id,Qf=[].concat(Iu(cf),Iu(Cf)),$f=Ju.FontAwesomeConfig||{};function ep(e){var t=Yu.querySelector(`script[`+e+`]`);if(t)return t.getAttribute(e)}function tp(e){return e===``?!0:e===`false`?!1:e===`true`||e}Yu&&typeof Yu.querySelector==`function`&&[[`data-family-prefix`,`familyPrefix`],[`data-css-prefix`,`cssPrefix`],[`data-family-default`,`familyDefault`],[`data-style-default`,`styleDefault`],[`data-replacement-class`,`replacementClass`],[`data-auto-replace-svg`,`autoReplaceSvg`],[`data-auto-add-css`,`autoAddCss`],[`data-search-pseudo-elements`,`searchPseudoElements`],[`data-search-pseudo-elements-warnings`,`searchPseudoElementsWarnings`],[`data-search-pseudo-elements-full-scan`,`searchPseudoElementsFullScan`],[`data-observe-mutations`,`observeMutations`],[`data-mutate-approach`,`mutateApproach`],[`data-keep-original-source`,`keepOriginalSource`],[`data-measure-performance`,`measurePerformance`],[`data-show-missing-icons`,`showMissingIcons`]].forEach(function(e){var t=Fu(e,2),n=t[0],r=t[1],i=tp(ep(n));i!=null&&($f[r]=i)});var np={styleDefault:`solid`,familyDefault:od,cssPrefix:Df,replacementClass:Of,autoReplaceSvg:!0,autoAddCss:!0,searchPseudoElements:!1,searchPseudoElementsWarnings:!0,searchPseudoElementsFullScan:!1,observeMutations:!0,mutateApproach:`async`,keepOriginalSource:!0,measurePerformance:!1,showMissingIcons:!0};$f.familyPrefix&&($f.cssPrefix=$f.familyPrefix);var rp=K(K({},np),$f);rp.autoReplaceSvg||(rp.observeMutations=!1);var q={};Object.keys(np).forEach(function(e){Object.defineProperty(q,e,{enumerable:!0,set:function(t){rp[e]=t,ip.forEach(function(e){return e(q)})},get:function(){return rp[e]}})}),Object.defineProperty(q,"familyPrefix",{enumerable:!0,set:function(e){rp.cssPrefix=e,ip.forEach(function(e){return e(q)})},get:function(){return rp.cssPrefix}}),Ju.FontAwesomeConfig=q;var ip=[];function ap(e){return ip.push(e),function(){ip.splice(ip.indexOf(e),1)}}var op=Ef,sp={size:16,x:0,y:0,rotate:0,flipX:!1,flipY:!1};function cp(e){if(!(!e||!Qu)){var t=Yu.createElement(`style`);t.setAttribute(`type`,`text/css`),t.innerHTML=e;for(var n=Yu.head.childNodes,r=null,i=n.length-1;i>-1;i--){var a=n[i],o=(a.tagName||``).toUpperCase();[`STYLE`,`LINK`].indexOf(o)>-1&&(r=a)}return Yu.head.insertBefore(t,r),e}}var lp=`0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`;function up(){for(var e=12,t=``;e-->0;)t+=lp[Math.random()*62|0];return t}function dp(e){for(var t=[],n=(e||[]).length>>>0;n--;)t[n]=e[n];return t}function fp(e){return e.classList?dp(e.classList):(e.getAttribute(`class`)||``).split(` `).filter(function(e){return e})}function pp(e){return`${e}`.replace(/&/g,`&amp;`).replace(/"/g,`&quot;`).replace(/'/g,`&#39;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`)}function mp(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}="${pp(e[n])}" `},``).trim()}function hp(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}: ${e[n].trim()};`},``)}function gp(e){return e.size!==sp.size||e.x!==sp.x||e.y!==sp.y||e.rotate!==sp.rotate||e.flipX||e.flipY}function _p(e){var t=e.transform,n=e.containerWidth,r=e.iconWidth;return{outer:{transform:`translate(${n/2} 256)`},inner:{transform:`${`translate(${t.x*32}, ${t.y*32}) `} ${`scale(${t.size/16*(t.flipX?-1:1)}, ${t.size/16*(t.flipY?-1:1)}) `} ${`rotate(${t.rotate} 0 0)`}`},path:{transform:`translate(${r/2*-1} -256)`}}}function vp(e){var t=e.transform,n=e.width,r=n===void 0?Ef:n,i=e.height,a=i===void 0?Ef:i,o=e.startCentered,s=o!==void 0&&o,c=``;return c+=s&&$u?`translate(${t.x/op-r/2}em, ${t.y/op-a/2}em) `:s?`translate(calc(-50% + ${t.x/op}em), calc(-50% + ${t.y/op}em)) `:`translate(${t.x/op}em, ${t.y/op}em) `,c+=`scale(${t.size/op*(t.flipX?-1:1)}, ${t.size/op*(t.flipY?-1:1)}) `,c+=`rotate(${t.rotate}deg) `,c}var yp=`:root, :host {
  --fa-font-solid: normal 900 1em/1 'Font Awesome 7 Free';
  --fa-font-regular: normal 400 1em/1 'Font Awesome 7 Free';
  --fa-font-light: normal 300 1em/1 'Font Awesome 7 Pro';
  --fa-font-thin: normal 100 1em/1 'Font Awesome 7 Pro';
  --fa-font-duotone: normal 900 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-regular: normal 400 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-light: normal 300 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-thin: normal 100 1em/1 'Font Awesome 7 Duotone';
  --fa-font-brands: normal 400 1em/1 'Font Awesome 7 Brands';
  --fa-font-sharp-solid: normal 900 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-regular: normal 400 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-light: normal 300 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-thin: normal 100 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-duotone-solid: normal 900 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-regular: normal 400 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-light: normal 300 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-thin: normal 100 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-slab-regular: normal 400 1em/1 'Font Awesome 7 Slab';
  --fa-font-slab-press-regular: normal 400 1em/1 'Font Awesome 7 Slab Press';
  --fa-font-slab-duo-regular: normal 400 1em/1 'Font Awesome 7 Slab Duo';
  --fa-font-slab-press-duo-regular: normal 400 1em/1 'Font Awesome 7 Slab Press Duo';
  --fa-font-pixel-regular: normal 400 1em/1 'Font Awesome 7 Pixel';
  --fa-font-mosaic-solid: normal 900 1em/1 'Font Awesome 7 Mosaic';
  --fa-font-vellum-solid: normal 900 1em/1 'Font Awesome 7 Vellum';
  --fa-font-whiteboard-semibold: normal 600 1em/1 'Font Awesome 7 Whiteboard';
  --fa-font-thumbprint-light: normal 300 1em/1 'Font Awesome 7 Thumbprint';
  --fa-font-notdog-solid: normal 900 1em/1 'Font Awesome 7 Notdog';
  --fa-font-notdog-duo-solid: normal 900 1em/1 'Font Awesome 7 Notdog Duo';
  --fa-font-etch-solid: normal 900 1em/1 'Font Awesome 7 Etch';
  --fa-font-graphite-thin: normal 100 1em/1 'Font Awesome 7 Graphite';
  --fa-font-jelly-regular: normal 400 1em/1 'Font Awesome 7 Jelly';
  --fa-font-jelly-fill-regular: normal 400 1em/1 'Font Awesome 7 Jelly Fill';
  --fa-font-jelly-duo-regular: normal 400 1em/1 'Font Awesome 7 Jelly Duo';
  --fa-font-chisel-regular: normal 400 1em/1 'Font Awesome 7 Chisel';
  --fa-font-utility-semibold: normal 600 1em/1 'Font Awesome 7 Utility';
  --fa-font-utility-duo-semibold: normal 600 1em/1 'Font Awesome 7 Utility Duo';
  --fa-font-utility-fill-semibold: normal 600 1em/1 'Font Awesome 7 Utility Fill';
}

.svg-inline--fa {
  box-sizing: content-box;
  display: var(--fa-display, inline-block);
  height: 1em;
  overflow: visible;
  vertical-align: -0.125em;
  width: var(--fa-width, 1.25em);
}
.svg-inline--fa.fa-2xs {
  vertical-align: 0.1em;
}
.svg-inline--fa.fa-xs {
  vertical-align: 0em;
}
.svg-inline--fa.fa-sm {
  vertical-align: -0.0714285714em;
}
.svg-inline--fa.fa-lg {
  vertical-align: -0.2em;
}
.svg-inline--fa.fa-xl {
  vertical-align: -0.25em;
}
.svg-inline--fa.fa-2xl {
  vertical-align: -0.3125em;
}
.svg-inline--fa.fa-pull-left,
.svg-inline--fa .fa-pull-start {
  float: inline-start;
  margin-inline-end: var(--fa-pull-margin, 0.3em);
}
.svg-inline--fa.fa-pull-right,
.svg-inline--fa .fa-pull-end {
  float: inline-end;
  margin-inline-start: var(--fa-pull-margin, 0.3em);
}
.svg-inline--fa.fa-li {
  width: var(--fa-li-width, 2em);
  inset-inline-start: calc(-1 * var(--fa-li-width, 2em));
  inset-block-start: 0.25em; /* syncing vertical alignment with Web Font rendering */
}

.fa-layers-counter, .fa-layers-text {
  display: inline-block;
  position: absolute;
  text-align: center;
}

.fa-layers {
  display: inline-block;
  height: 1em;
  position: relative;
  text-align: center;
  vertical-align: -0.125em;
  width: var(--fa-width, 1.25em);
}
.fa-layers .svg-inline--fa {
  inset: 0;
  margin: auto;
  position: absolute;
  transform-origin: center center;
}

.fa-layers-text {
  left: 50%;
  top: 50%;
  transform: translate(-50%, -50%);
  transform-origin: center center;
}

.fa-layers-counter {
  background-color: var(--fa-counter-background-color, #ff253a);
  border-radius: var(--fa-counter-border-radius, 1em);
  box-sizing: border-box;
  color: var(--fa-inverse, #fff);
  line-height: var(--fa-counter-line-height, 1);
  max-width: var(--fa-counter-max-width, 5em);
  min-width: var(--fa-counter-min-width, 1.5em);
  overflow: hidden;
  padding: var(--fa-counter-padding, 0.25em 0.5em);
  right: var(--fa-right, 0);
  text-overflow: ellipsis;
  top: var(--fa-top, 0);
  transform: scale(var(--fa-counter-scale, 0.25));
  transform-origin: top right;
}

.fa-layers-bottom-right {
  bottom: var(--fa-bottom, 0);
  right: var(--fa-right, 0);
  top: auto;
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: bottom right;
}

.fa-layers-bottom-left {
  bottom: var(--fa-bottom, 0);
  left: var(--fa-left, 0);
  right: auto;
  top: auto;
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: bottom left;
}

.fa-layers-top-right {
  top: var(--fa-top, 0);
  right: var(--fa-right, 0);
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: top right;
}

.fa-layers-top-left {
  left: var(--fa-left, 0);
  right: auto;
  top: var(--fa-top, 0);
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: top left;
}

.fa-1x {
  font-size: 1em;
}

.fa-2x {
  font-size: 2em;
}

.fa-3x {
  font-size: 3em;
}

.fa-4x {
  font-size: 4em;
}

.fa-5x {
  font-size: 5em;
}

.fa-6x {
  font-size: 6em;
}

.fa-7x {
  font-size: 7em;
}

.fa-8x {
  font-size: 8em;
}

.fa-9x {
  font-size: 9em;
}

.fa-10x {
  font-size: 10em;
}

.fa-2xs {
  font-size: calc(10 / 16 * 1em); /* converts a 10px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 10 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 10 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-xs {
  font-size: calc(12 / 16 * 1em); /* converts a 12px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 12 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 12 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-sm {
  font-size: calc(14 / 16 * 1em); /* converts a 14px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 14 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 14 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-lg {
  font-size: calc(20 / 16 * 1em); /* converts a 20px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 20 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 20 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-xl {
  font-size: calc(24 / 16 * 1em); /* converts a 24px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 24 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 24 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-2xl {
  font-size: calc(32 / 16 * 1em); /* converts a 32px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 32 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 32 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-width-auto {
  --fa-width: auto;
}

.fa-fw,
.fa-width-fixed {
  --fa-width: 1.25em;
}

.fa-canvas-square {
  padding-block: 0.125em;
  margin-block-end: -0.125em;
}

.fa-canvas-roomy {
  padding-block: 0.25em;
  padding-inline: 0.125em;
  margin-block-end: -0.25em;
  box-sizing: content-box;
}

.fa-ul {
  list-style-type: none;
  margin-inline-start: var(--fa-li-margin, 2.5em);
  padding-inline-start: 0;
}
.fa-ul > li {
  position: relative;
}

.fa-li {
  inset-inline-start: calc(-1 * var(--fa-li-width, 2em));
  position: absolute;
  text-align: center;
  width: var(--fa-li-width, 2em);
  line-height: inherit;
}

/* Heads Up: Bordered Icons will not be supported in the future!
  - This feature will be deprecated in the next major release of Font Awesome (v8)!
  - You may continue to use it in this version *v7), but it will not be supported in Font Awesome v8.
*/
/* Notes:
* --@{v.$css-prefix}-border-width = 1/16 by default (to render as ~1px based on a 16px default font-size)
* --@{v.$css-prefix}-border-padding =
  ** 3/16 for vertical padding (to give ~2px of vertical whitespace around an icon considering it's vertical alignment)
  ** 4/16 for horizontal padding (to give ~4px of horizontal whitespace around an icon)
*/
.fa-border {
  border-color: var(--fa-border-color, #eee);
  border-radius: var(--fa-border-radius, 0.1em);
  border-style: var(--fa-border-style, solid);
  border-width: var(--fa-border-width, 0.0625em);
  box-sizing: var(--fa-border-box-sizing, content-box);
  padding: var(--fa-border-padding, 0.1875em 0.25em);
}

.fa-pull-left,
.fa-pull-start {
  float: inline-start;
  margin-inline-end: var(--fa-pull-margin, 0.3em);
}

.fa-pull-right,
.fa-pull-end {
  float: inline-end;
  margin-inline-start: var(--fa-pull-margin, 0.3em);
}

.fa-beat {
  animation-name: fa-beat;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-bounce {
  animation-name: fa-bounce;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, cubic-bezier(0.28, 0.84, 0.42, 1));
}

.fa-fade {
  animation-name: fa-fade;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-beat-fade {
  animation-name: fa-beat-fade;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-flip {
  animation-name: fa-flip;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1.5s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-flip-360 {
  animation-name: fa-flip-360;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-shake {
  animation-name: fa-shake;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.75s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-spin {
  animation-name: fa-spin;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 2s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-reverse {
  --fa-animation-direction: reverse;
}

.fa-pulse,
.fa-spin-pulse {
  animation-name: fa-spin;
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, steps(8));
}

.fa-spin-snap {
  animation-name: fa-spin-snap;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 3s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-snap-4 {
  animation-name: fa-spin-snap-4;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 2.4s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-snap-8 {
  animation-name: fa-spin-snap-8;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 4s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-buzz {
  animation-name: fa-buzz;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.6s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-wag {
  animation-name: fa-wag;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.9s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
  transform-origin: bottom center;
}

.fa-float {
  animation-name: fa-float;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 3s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
  will-change: transform;
}

.fa-swing {
  animation-name: fa-swing;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1.2s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
  transform-origin: top center;
}

.fa-jello {
  animation-name: fa-jello;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.9s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
}

@media (prefers-reduced-motion: reduce) {
  .fa-beat,
  .fa-bounce,
  .fa-fade,
  .fa-beat-fade,
  .fa-flip,
  .fa-flip-360,
  .fa-pulse,
  .fa-shake,
  .fa-spin,
  .fa-spin-pulse,
  .fa-buzz,
  .fa-float,
  .fa-jello,
  .fa-spin-snap,
  .fa-spin-snap-4,
  .fa-spin-snap-8,
  .fa-swing,
  .fa-wag {
    animation: none !important;
    transition: none !important;
  }
}
@keyframes fa-beat {
  0% {
    transform: scale(1);
  }
  25% {
    transform: scale(calc(1.25 * var(--fa-beat-scale, 1.25)));
  }
  45% {
    transform: scale(calc(1.22 * var(--fa-beat-scale, 1.22)));
  }
  65% {
    transform: scale(calc(1.25 * var(--fa-beat-scale, 1.25)));
  }
  90% {
    transform: scale(1);
  }
}
@keyframes fa-bounce {
  0% {
    transform: scale(1, 1) translateY(0);
    animation-timing-function: var(--fa-animation-timing);
  }
  14% {
    transform: scale(var(--fa-bounce-start-scale-x, 1.06), var(--fa-bounce-start-scale-y, 0.94)) translateY(var(--fa-bounce-anticipation, 3px));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  32% {
    transform: scale(var(--fa-bounce-jump-scale-x, 0.94), var(--fa-bounce-jump-scale-y, 1.12)) translateY(calc(-1 * var(--fa-bounce-height, 0.5em)));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  52% {
    transform: scale(1, 1) translateY(calc(-1 * var(--fa-bounce-height, 0.5em) * 1.1));
    animation-timing-function: cubic-bezier(0.5, 0, 1, 0.5);
  }
  70% {
    transform: scale(var(--fa-bounce-land-scale-x, 1.06), var(--fa-bounce-land-scale-y, 0.92)) translateY(0);
    animation-timing-function: cubic-bezier(0.33, 0.33, 0.66, 1);
  }
  85% {
    transform: scale(0.98, 1.04) translateY(calc(-2px * var(--fa-bounce-rebound, 1)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: scale(1, 1) translateY(0);
  }
}
@keyframes fa-fade {
  0% {
    opacity: 1;
    transform: scale(1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  40% {
    opacity: var(--fa-fade-opacity, 0.4);
    transform: scale(0.98);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  100% {
    opacity: 1;
    transform: scale(1);
  }
}
@keyframes fa-beat-fade {
  0% {
    opacity: var(--fa-beat-fade-opacity, 0.4);
    transform: scale(1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  25% {
    opacity: calc(var(--fa-beat-fade-opacity, 0.4) + 0.4);
    transform: scale(var(--fa-beat-fade-scale, 1.28));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  45% {
    opacity: 1;
    transform: scale(var(--fa-beat-fade-scale, 1.25));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  65% {
    opacity: calc(var(--fa-beat-fade-opacity, 0.4) + 0.4);
    transform: scale(var(--fa-beat-fade-scale, 1.28));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  100% {
    opacity: var(--fa-beat-fade-opacity, 0.4);
    transform: scale(1);
  }
}
@keyframes fa-flip {
  0% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  8% {
    transform: perspective(2em) scale(var(--fa-flip-anticipation-scale, 0.95)) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  35% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.6));
    animation-timing-function: linear;
  }
  65% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.5));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  92% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * var(--fa-flip-overshoot, 1.04)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), var(--fa-flip-angle, -360deg));
  }
}
@keyframes fa-flip-360 {
  0% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  8% {
    transform: perspective(2em) scale(var(--fa-flip-anticipation-scale, 0.95)) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  50% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.6));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  80% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * var(--fa-flip-overshoot, 1.04)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), var(--fa-flip-angle, -360deg));
  }
}
@keyframes fa-shake {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  8% {
    transform: rotate(35deg) translateX(1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  20% {
    transform: rotate(-22deg) translateX(-1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  35% {
    transform: rotate(15deg) translateX(1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  50% {
    transform: rotate(-9deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  65% {
    transform: rotate(5deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  78% {
    transform: rotate(-3deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  90% {
    transform: rotate(1deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-spin {
  0% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  12% {
    transform: rotate(60deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  16.67% {
    transform: rotate(60deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  28.67% {
    transform: rotate(120deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  33.33% {
    transform: rotate(120deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  45.33% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  62% {
    transform: rotate(240deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  66.67% {
    transform: rotate(240deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  78.67% {
    transform: rotate(300deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  83.33% {
    transform: rotate(300deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  95.33% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap-4 {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  15% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  25% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  40% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  65% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  75% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  90% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap-8 {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  9% {
    transform: rotate(45deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  12.5% {
    transform: rotate(45deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  21.5% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  25% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  34% {
    transform: rotate(135deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  37.5% {
    transform: rotate(135deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  46.5% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  59% {
    transform: rotate(225deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  62.5% {
    transform: rotate(225deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  71.5% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  75% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  84% {
    transform: rotate(315deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  87.5% {
    transform: rotate(315deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  96.5% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-buzz {
  0% {
    transform: translateX(0) rotate(0deg);
    animation-timing-function: cubic-bezier(0.1, 0, 0.9, 1);
  }
  5% {
    transform: translateX(var(--fa-buzz-distance, 4px)) rotate(0.5deg);
  }
  10% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px))) rotate(-0.5deg);
  }
  15% {
    transform: translateX(var(--fa-buzz-distance, 4px)) rotate(0.3deg);
  }
  20% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px))) rotate(-0.3deg);
  }
  25% {
    transform: translateX(calc(var(--fa-buzz-distance, 4px) * 0.7)) rotate(0.2deg);
  }
  30% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px) * 0.7)) rotate(-0.2deg);
  }
  35% {
    transform: translateX(calc(var(--fa-buzz-distance, 4px) * 0.4)) rotate(0.1deg);
  }
  40% {
    transform: translateX(0) rotate(0deg);
  }
  100% {
    transform: translateX(0) rotate(0deg);
  }
}
@keyframes fa-wag {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  12% {
    transform: rotate(var(--fa-wag-angle, 12deg));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  24% {
    transform: rotate(2deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  36% {
    transform: rotate(calc(var(--fa-wag-angle, 12deg) * 0.85));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  48% {
    transform: rotate(1deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  58% {
    transform: rotate(calc(var(--fa-wag-angle, 12deg) * 0.6));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  68% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-float {
  0% {
    transform: translateY(0) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  15% {
    transform: translateY(calc(-0.4 * var(--fa-float-height, 6px))) translateX(var(--fa-float-drift, 1px)) rotate(var(--fa-float-tilt, 1deg)) scale(1, 1);
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  35% {
    transform: translateY(calc(-1 * var(--fa-float-height, 6px))) translateX(0) rotate(0deg) scale(var(--fa-float-stretch-x, 0.98), var(--fa-float-stretch-y, 1.03));
    animation-timing-function: cubic-bezier(0.5, 0, 0.5, 0);
  }
  50% {
    transform: translateY(calc(-0.92 * var(--fa-float-height, 6px))) translateX(calc(-0.5 * var(--fa-float-drift, 1px))) rotate(calc(-0.5 * var(--fa-float-tilt, 1deg))) scale(0.995, 1.01);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  70% {
    transform: translateY(calc(-0.3 * var(--fa-float-height, 6px))) translateX(calc(-1 * var(--fa-float-drift, 1px))) rotate(calc(-1 * var(--fa-float-tilt, 1deg))) scale(1, 1);
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  90% {
    transform: translateY(calc(0.05 * var(--fa-float-height, 6px))) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: translateY(0) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
  }
}
@keyframes fa-swing {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  8% {
    transform: rotate(var(--fa-swing-angle, 22deg));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  18% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.85));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  28% {
    transform: rotate(calc(var(--fa-swing-angle, 22deg) * 0.65));
    animation-timing-function: cubic-bezier(0.35, 0, 0.65, 1);
  }
  38% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.45));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  48% {
    transform: rotate(calc(var(--fa-swing-angle, 22deg) * 0.25));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  56% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.1));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  64% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-jello {
  0% {
    transform: scale(1, 1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  12% {
    transform: scale(var(--fa-jello-scale-x, 1.15), calc(2 - var(--fa-jello-scale-x, 1.15)));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  24% {
    transform: scale(calc(2 - var(--fa-jello-scale-y, 1.12)), var(--fa-jello-scale-y, 1.12));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  36% {
    transform: scale(calc(1 + (var(--fa-jello-scale-x, 1.15) - 1) * 0.5), calc(2 - (1 + (var(--fa-jello-scale-x, 1.15) - 1) * 0.5)));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  48% {
    transform: scale(calc(2 - (1 + (var(--fa-jello-scale-y, 1.12) - 1) * 0.3)), calc(1 + (var(--fa-jello-scale-y, 1.12) - 1) * 0.3));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  58% {
    transform: scale(1.02, 0.98);
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  68% {
    transform: scale(1, 1);
  }
  100% {
    transform: scale(1, 1);
  }
}
.fa-rotate-90 {
  transform: rotate(90deg);
}

.fa-rotate-180 {
  transform: rotate(180deg);
}

.fa-rotate-270 {
  transform: rotate(270deg);
}

.fa-flip-horizontal {
  transform: scale(-1, 1);
}

.fa-flip-vertical {
  transform: scale(1, -1);
}

.fa-flip-both,
.fa-flip-horizontal.fa-flip-vertical {
  transform: scale(-1, -1);
}

.fa-rotate-by {
  transform: rotate(var(--fa-rotate-angle, 0));
}

.svg-inline--fa .fa-primary {
  fill: var(--fa-primary-color, currentColor);
  opacity: var(--fa-primary-opacity, 1);
}

.svg-inline--fa .fa-secondary {
  fill: var(--fa-secondary-color, currentColor);
  opacity: var(--fa-secondary-opacity, 0.4);
}

.svg-inline--fa.fa-swap-opacity .fa-primary {
  opacity: var(--fa-secondary-opacity, 0.4);
}

.svg-inline--fa.fa-swap-opacity .fa-secondary {
  opacity: var(--fa-primary-opacity, 1);
}

.svg-inline--fa mask .fa-primary,
.svg-inline--fa mask .fa-secondary {
  fill: black;
}

.svg-inline--fa.fa-inverse {
  fill: var(--fa-inverse, #fff);
}

.fa-stack {
  display: inline-block;
  height: 2em;
  line-height: 2em;
  position: relative;
  vertical-align: middle;
  width: 2.5em;
}

.fa-inverse {
  color: var(--fa-inverse, #fff);
}

.svg-inline--fa.fa-stack-1x {
  --fa-width: 1.25em;
  height: 1em;
  width: var(--fa-width);
}
.svg-inline--fa.fa-stack-2x {
  --fa-width: 2.5em;
  height: 2em;
  width: var(--fa-width);
}

.fa-stack-1x,
.fa-stack-2x {
  inset: 0;
  margin: auto;
  position: absolute;
  z-index: var(--fa-stack-z-index, auto);
}`;function bp(){var e=Df,t=Of,n=q.cssPrefix,r=q.replacementClass,i=yp;if(n!==e||r!==t){var a=RegExp(`\\.${e}\\-`,`g`),o=RegExp(`\\--${e}\\-`,`g`),s=RegExp(`\\.${t}`,`g`);i=i.replace(a,`.${n}-`).replace(o,`--${n}-`).replace(s,`.${r}`)}return i}var xp=!1;function Sp(){q.autoAddCss&&!xp&&(cp(bp()),xp=!0)}var Cp={mixout:function(){return{dom:{css:bp,insertCss:Sp}}},hooks:function(){return{beforeDOMElementCreation:function(){Sp()},beforeI2svg:function(){Sp()}}}},wp=Ju||{};wp[Tf]||(wp[Tf]={}),wp[Tf].styles||(wp[Tf].styles={}),wp[Tf].hooks||(wp[Tf].hooks={}),wp[Tf].shims||(wp[Tf].shims=[]);var Tp=wp[Tf],Ep=[],Dp=function(){Yu.removeEventListener(`DOMContentLoaded`,Dp),Op=1,Ep.map(function(e){return e()})},Op=!1;Qu&&(Op=(Yu.documentElement.doScroll?/^loaded|^c/:/^loaded|^i|^c/).test(Yu.readyState),Op||Yu.addEventListener(`DOMContentLoaded`,Dp));function kp(e){Qu&&(Op?setTimeout(e,0):Ep.push(e))}function Ap(e){var t=e.tag,n=e.attributes,r=n===void 0?{}:n,i=e.children,a=i===void 0?[]:i;return typeof e==`string`?pp(e):`<${t} ${mp(r)}>${a.map(Ap).join(``)}</${t}>`}function jp(e,t,n){if(e&&e[t]&&e[t][n])return{prefix:t,iconName:n,icon:e[t][n]}}var Mp=function(e,t){return function(n,r,i,a){return e.call(t,n,r,i,a)}},Np=function(e,t,n,r){var i=Object.keys(e),a=i.length,o=r===void 0?t:Mp(t,r),s,c,l;for(n===void 0?(s=1,l=e[i[0]]):(s=0,l=n);s<a;s++)c=i[s],l=o(l,e[c],c,e);return l};function Pp(e){return Iu(e).length===1?e.codePointAt(0).toString(16):null}function Fp(e){return Object.keys(e).reduce(function(t,n){var r=e[n];return r.icon?t[r.iconName]=r.icon:t[n]=r,t},{})}function Ip(e,t){var n=(arguments.length>2&&arguments[2]!==void 0?arguments[2]:{}).skipHooks,r=n!==void 0&&n,i=Fp(t);typeof Tp.hooks.addPack==`function`&&!r?Tp.hooks.addPack(e,Fp(t)):Tp.styles[e]=K(K({},Tp.styles[e]||{}),i),e===`fas`&&Ip(`fa`,t)}var Lp=Tp.styles,Rp=Tp.shims,zp=Object.keys(Gf),Bp=zp.reduce(function(e,t){return e[t]=Object.keys(Gf[t]),e},{}),Vp=null,Hp={},Up={},Wp={},Gp={},Kp={};function qp(e){return~Qf.indexOf(e)}function Jp(e,t){var n=t.split(`-`),r=n[0],i=n.slice(1).join(`-`);return r===e&&i!==``&&!qp(i)?i:null}var Yp=function(){var e=function(e){return Np(Lp,function(t,n,r){return t[r]=Np(n,e,{}),t},{})};Hp=e(function(e,t,n){return t[3]&&(e[t[3]]=n),t[2]&&t[2].filter(function(e){return typeof e==`number`}).forEach(function(t){e[t.toString(16)]=n}),e}),Up=e(function(e,t,n){return e[n]=n,t[2]&&t[2].filter(function(e){return typeof e==`string`}).forEach(function(t){e[t]=n}),e}),Kp=e(function(e,t,n){var r=t[2];return e[n]=n,r.forEach(function(t){e[t]=n}),e});var t=`far`in Lp||q.autoFetchSvg,n=Np(Rp,function(e,n){var r=n[0],i=n[1],a=n[2];return i===`far`&&!t&&(i=`fas`),typeof r==`string`&&(e.names[r]={prefix:i,iconName:a}),typeof r==`number`&&(e.unicodes[r.toString(16)]={prefix:i,iconName:a}),e},{names:{},unicodes:{}});Wp=n.names,Gp=n.unicodes,Vp=im(q.styleDefault,{family:q.familyDefault})};ap(function(e){Vp=im(e.styleDefault,{family:q.familyDefault})}),Yp();function Xp(e,t){return(Hp[e]||{})[t]}function Zp(e,t){return(Up[e]||{})[t]}function Qp(e,t){return(Kp[e]||{})[t]}function $p(e){return Wp[e]||{prefix:null,iconName:null}}function em(e){var t=Gp[e],n=Xp(`fas`,e);return t||(n?{prefix:`fas`,iconName:n}:null)||{prefix:null,iconName:null}}function tm(){return Vp}var nm=function(){return{prefix:null,iconName:null,rest:[]}};function rm(e){var t=od,n=zp.reduce(function(e,t){return e[t]=`${q.cssPrefix}-${t}`,e},{});return ef.forEach(function(r){(e.includes(n[r])||e.some(function(e){return Bp[r].includes(e)}))&&(t=r)}),t}function im(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).family,n=t===void 0?od:t,r=Vf[n][e];if(n===sd&&!e)return`fad`;var i=Uf[n][e]||Uf[n][r],a=e in Tp.styles?e:null;return i||a||null}function am(e){var t=[],n=null;return e.forEach(function(e){var r=Jp(q.cssPrefix,e);r?n=r:e&&t.push(e)}),{iconName:n,rest:t}}function om(e){return e.sort().filter(function(e,t,n){return n.indexOf(e)===t})}var sm=yf.concat(of);function cm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).skipLookups,n=t!==void 0&&t,r=null,i=om(e.filter(function(e){return sm.includes(e)})),a=om(e.filter(function(e){return!sm.includes(e)})),o=Fu(i.filter(function(e){return r=e,!ad.includes(e)}),1)[0],s=o===void 0?null:o,c=rm(i),l=K(K({},am(a)),{},{prefix:im(s,{family:c})});return K(K(K({},l),fm({values:e,family:c,styles:Lp,config:q,canonical:l,givenPrefix:r})),lm(n,r,l))}function lm(e,t,n){var r=n.prefix,i=n.iconName;if(e||!r||!i)return{prefix:r,iconName:i};var a=t===`fa`?$p(i):{},o=Qp(r,i);return i=a.iconName||o||i,r=a.prefix||r,r===`far`&&!Lp.far&&Lp.fas&&!q.autoFetchSvg&&(r=`fas`),{prefix:r,iconName:i}}var um=ef.filter(function(e){return e!==od||e!==sd}),dm=Object.keys(vf).filter(function(e){return e!==od}).map(function(e){return Object.keys(vf[e])}).flat();function fm(e){var t=e.values,n=e.family,r=e.canonical,i=e.givenPrefix,a=i===void 0?``:i,o=e.styles,s=o===void 0?{}:o,c=e.config,l=c===void 0?{}:c,u=n===sd,d=t.includes(`fa-duotone`)||t.includes(`fad`),f=l.familyDefault===`duotone`,p=r.prefix===`fad`||r.prefix===`fa-duotone`;return!u&&(d||f||p)&&(r.prefix=`fad`),(t.includes(`fa-brands`)||t.includes(`fab`))&&(r.prefix=`fab`),!r.prefix&&um.includes(n)&&(Object.keys(s).find(function(e){return dm.includes(e)})||l.autoFetchSvg)&&(r.prefix=rf.get(n).defaultShortPrefixId,r.iconName=Qp(r.prefix,r.iconName)||r.iconName),(r.prefix===`fa`||a===`fa`)&&(r.prefix=tm()||`fas`),r}var pm=function(){function e(){Eu(this,e),this.definitions={}}return Ou(e,[{key:`add`,value:function(){var e=this,t=[...arguments].reduce(this._pullDefinitions,{});Object.keys(t).forEach(function(n){e.definitions[n]=K(K({},e.definitions[n]||{}),t[n]),Ip(n,t[n]);var r=Gf[od][n];r&&Ip(r,t[n]),Yp()})}},{key:`reset`,value:function(){this.definitions={}}},{key:`_pullDefinitions`,value:function(e,t){var n=t.prefix&&t.iconName&&t.icon?{0:t}:t;return Object.keys(n).map(function(t){var r=n[t],i=r.prefix,a=r.iconName,o=r.icon,s=o[2];e[i]||(e[i]={}),s.length>0&&s.forEach(function(t){typeof t==`string`&&(e[i][t]=o)}),e[i][a]=o}),e}}])}(),mm=[],hm={},gm={},_m=Object.keys(gm);function vm(e,t){var n=t.mixoutsTo;return mm=e,hm={},Object.keys(gm).forEach(function(e){_m.indexOf(e)===-1&&delete gm[e]}),mm.forEach(function(e){var t=e.mixout?e.mixout():{};if(Object.keys(t).forEach(function(e){typeof t[e]==`function`&&(n[e]=t[e]),zu(t[e])===`object`&&Object.keys(t[e]).forEach(function(r){n[e]||(n[e]={}),n[e][r]=t[e][r]})}),e.hooks){var r=e.hooks();Object.keys(r).forEach(function(e){hm[e]||(hm[e]=[]),hm[e].push(r[e])})}e.provides&&e.provides(gm)}),n}function ym(e,t){var n=[...arguments].slice(2);return(hm[e]||[]).forEach(function(e){t=e.apply(null,[t].concat(n))}),t}function bm(e){var t=[...arguments].slice(1);(hm[e]||[]).forEach(function(e){e.apply(null,t)})}function xm(){var e=arguments[0],t=Array.prototype.slice.call(arguments,1);return gm[e]?gm[e].apply(null,t):void 0}function Sm(e){e.prefix===`fa`&&(e.prefix=`fas`);var t=e.iconName,n=e.prefix||tm();if(t)return t=Qp(n,t)||t,jp(Cm.definitions,n,t)||jp(Tp.styles,n,t)}var Cm=new pm,wm={noAuto:function(){q.autoReplaceSvg=!1,q.observeMutations=!1,bm(`noAuto`)},config:q,dom:{i2svg:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return Qu?(bm(`beforeI2svg`,e),xm(`pseudoElements2svg`,e),xm(`i2svg`,e)):Promise.reject(Error(`Operation requires a DOM of some kind.`))},watch:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},t=e.autoReplaceSvgRoot;q.autoReplaceSvg===!1&&(q.autoReplaceSvg=!0),q.observeMutations=!0,kp(function(){Tm({autoReplaceSvgRoot:t}),bm(`watch`,e)})}},parse:{icon:function(e){if(e===null)return null;if(zu(e)===`object`&&e.prefix&&e.iconName)return{prefix:e.prefix,iconName:Qp(e.prefix,e.iconName)||e.iconName};if(Array.isArray(e)&&e.length===2){var t=e[1].indexOf(`fa-`)===0?e[1].slice(3):e[1],n=im(e[0]);return{prefix:n,iconName:Qp(n,t)||t}}if(typeof e==`string`&&(e.indexOf(`${q.cssPrefix}-`)>-1||e.match(qf))){var r=cm(e.split(` `),{skipLookups:!0});return{prefix:r.prefix||tm(),iconName:Qp(r.prefix,r.iconName)||r.iconName}}if(typeof e==`string`){var i=tm();return{prefix:i,iconName:Qp(i,e)||e}}}},library:Cm,findIconDefinition:Sm,toHtml:Ap},Tm=function(){var e=(arguments.length>0&&arguments[0]!==void 0?arguments[0]:{}).autoReplaceSvgRoot,t=e===void 0?Yu:e;(Object.keys(Tp.styles).length>0||q.autoFetchSvg)&&Qu&&q.autoReplaceSvg&&wm.dom.i2svg({node:t})};function Em(e,t){return Object.defineProperty(e,"abstract",{get:t}),Object.defineProperty(e,"html",{get:function(){return e.abstract.map(function(e){return Ap(e)})}}),Object.defineProperty(e,"node",{get:function(){if(Qu){var t=Yu.createElement(`div`);return t.innerHTML=e.html,t.children}}}),e}function Dm(e){var t=e.children,n=e.main,r=e.mask,i=e.attributes,a=e.styles,o=e.transform;if(gp(o)&&n.found&&!r.found){var s={x:n.width/n.height/2,y:.5};i.style=hp(K(K({},a),{},{"transform-origin":`${s.x+o.x/16}em ${s.y+o.y/16}em`}))}return[{tag:`svg`,attributes:i,children:t}]}function Om(e){var t=e.prefix,n=e.iconName,r=e.children,i=e.attributes,a=e.symbol,o=a===!0?`${t}-${q.cssPrefix}-${n}`:a;return[{tag:`svg`,attributes:{style:`display: none;`},children:[{tag:`symbol`,attributes:K(K({},i),{},{id:o}),children:r}]}]}function km(e){return[`aria-label`,`aria-labelledby`,`title`,`role`].some(function(t){return t in e})}function Am(e){var t=e.icons,n=t.main,r=t.mask,i=e.prefix,a=e.iconName,o=e.transform,s=e.symbol,c=e.maskId,l=e.extra,u=e.watchable,d=u!==void 0&&u,f=r.found?r:n,p=f.width,m=f.height,h=[q.replacementClass,a?`${q.cssPrefix}-${a}`:``].filter(function(e){return l.classes.indexOf(e)===-1}).filter(function(e){return e!==``||!!e}).concat(l.classes).join(` `),g={children:[],attributes:K(K({},l.attributes),{},{"data-prefix":i,"data-icon":a,class:h,role:l.attributes.role||`img`,viewBox:`0 0 ${p} ${m}`})};!km(l.attributes)&&!l.attributes[`aria-hidden`]&&(g.attributes[`aria-hidden`]=`true`),d&&(g.attributes[kf]=``);var _=K(K({},g),{},{prefix:i,iconName:a,main:n,mask:r,maskId:c,transform:o,symbol:s,styles:K({},l.styles)}),v=r.found&&n.found?xm(`generateAbstractMask`,_)||{children:[],attributes:{}}:xm(`generateAbstractIcon`,_)||{children:[],attributes:{}},y=v.children,b=v.attributes;return _.children=y,_.attributes=b,s?Om(_):Dm(_)}function jm(e){var t=e.content,n=e.width,r=e.height,i=e.transform,a=e.extra,o=e.watchable,s=o!==void 0&&o,c=K(K({},a.attributes),{},{class:a.classes.join(` `)});s&&(c[kf]=``);var l=K({},a.styles);gp(i)&&(l.transform=vp({transform:i,startCentered:!0,width:n,height:r}),l[`-webkit-transform`]=l.transform);var u=hp(l);u.length>0&&(c.style=u);var d=[];return d.push({tag:`span`,attributes:c,children:[t]}),d}function Mm(e){var t=e.content,n=e.extra,r=K(K({},n.attributes),{},{class:n.classes.join(` `)}),i=hp(n.styles);i.length>0&&(r.style=i);var a=[];return a.push({tag:`span`,attributes:r,children:[t]}),a}var Nm=Tp.styles;function Pm(e){var t=e[0],n=e[1],r=Fu(e.slice(4),1)[0],i=null;return i=Array.isArray(r)?{tag:`g`,attributes:{class:`${q.cssPrefix}-${Zf.GROUP}`},children:[{tag:`path`,attributes:{class:`${q.cssPrefix}-${Zf.SECONDARY}`,fill:`currentColor`,d:r[0]}},{tag:`path`,attributes:{class:`${q.cssPrefix}-${Zf.PRIMARY}`,fill:`currentColor`,d:r[1]}}]}:{tag:`path`,attributes:{fill:`currentColor`,d:r}},{found:!0,width:t,height:n,icon:i}}var Fm={found:!1,width:512,height:512};function Im(e,t){!Rf&&!q.showMissingIcons&&e&&console.error(`Icon with name "${e}" and prefix "${t}" is missing.`)}function Lm(e,t){var n=t;return t===`fa`&&q.styleDefault!==null&&(t=tm()),new Promise(function(r,i){if(n===`fa`){var a=$p(e)||{};e=a.iconName||e,t=a.prefix||t}if(e&&t&&Nm[t]&&Nm[t][e]){var o=Nm[t][e];return r(Pm(o))}Im(e,t),r(K(K({},Fm),{},{icon:q.showMissingIcons&&e&&xm(`missingIconAbstract`)||{}}))})}var Rm=function(){},zm=q.measurePerformance&&Zu&&Zu.mark&&Zu.measure?Zu:{mark:Rm,measure:Rm},Bm=`FA "7.3.1"`,Vm=function(e){return zm.mark(`${Bm} ${e} begins`),function(){return Hm(e)}},Hm=function(e){zm.mark(`${Bm} ${e} ends`),zm.measure(`${Bm} ${e}`,`${Bm} ${e} begins`,`${Bm} ${e} ends`)},Um={begin:Vm,end:Hm},Wm=function(){};function Gm(e){return typeof(e.getAttribute?e.getAttribute(kf):null)==`string`}function Km(e){var t=e.getAttribute?e.getAttribute(Mf):null,n=e.getAttribute?e.getAttribute(Nf):null;return t&&n}function qm(e){return e&&e.classList&&e.classList.contains&&e.classList.contains(q.replacementClass)}function Jm(){return q.autoReplaceSvg===!0?$m.replace:$m[q.autoReplaceSvg]||$m.replace}function Ym(e){return Yu.createElementNS(`http://www.w3.org/2000/svg`,e)}function Xm(e){return Yu.createElement(e)}function Zm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).ceFn,n=t===void 0?e.tag===`svg`?Ym:Xm:t;if(typeof e==`string`)return Yu.createTextNode(e);var r=n(e.tag);return Object.keys(e.attributes||[]).forEach(function(t){r.setAttribute(t,e.attributes[t])}),(e.children||[]).forEach(function(e){r.appendChild(Zm(e,{ceFn:n}))}),r}function Qm(e){var t=` ${e.outerHTML} `;return t=`${t}Font Awesome fontawesome.com `,t}var $m={replace:function(e){var t=e[0];if(t.parentNode){if(e[1].forEach(function(e){t.parentNode.insertBefore(Zm(e),t)}),t.getAttribute(kf)===null&&q.keepOriginalSource){var n=Yu.createComment(Qm(t));t.parentNode.replaceChild(n,t)}else t.remove()}},nest:function(e){var t=e[0],n=e[1];if(~fp(t).indexOf(q.replacementClass))return $m.replace(e);var r=RegExp(`${q.cssPrefix}-.*`);if(delete n[0].attributes.id,n[0].attributes.class){var i=n[0].attributes.class.split(` `).reduce(function(e,t){return t===q.replacementClass||t.match(r)?e.toSvg.push(t):e.toNode.push(t),e},{toNode:[],toSvg:[]});n[0].attributes.class=i.toSvg.join(` `),i.toNode.length===0?t.removeAttribute(`class`):t.setAttribute(`class`,i.toNode.join(` `))}var a=n.map(function(e){return Ap(e)}).join(`
`);t.setAttribute(kf,``),t.innerHTML=a}};function eh(e){e()}function th(e,t){var n=typeof t==`function`?t:Wm;if(e.length===0)n();else{var r=eh;q.mutateApproach===Ff&&(r=Ju.requestAnimationFrame||eh),r(function(){var t=Jm(),r=Um.begin(`mutate`);e.map(t),r(),n()})}}var nh=!1;function rh(){nh=!0}function ih(){nh=!1}var ah=null;function oh(e){if(Xu&&q.observeMutations){var t=e.treeCallback,n=t===void 0?Wm:t,r=e.nodeCallback,i=r===void 0?Wm:r,a=e.pseudoElementsCallback,o=a===void 0?Wm:a,s=e.observeMutationsRoot,c=s===void 0?Yu:s;ah=new Xu(function(e){if(!nh){var t=tm();dp(e).forEach(function(e){if(e.type===`childList`&&e.addedNodes.length>0&&!Gm(e.addedNodes[0])&&(q.searchPseudoElements&&o(e.target),n(e.target)),e.type===`attributes`&&e.target.parentNode&&q.searchPseudoElements&&o([e.target],!0),e.type===`attributes`&&Gm(e.target)&&~Xf.indexOf(e.attributeName)){if(e.attributeName===`class`&&Km(e.target)){var r=cm(fp(e.target)),a=r.prefix,s=r.iconName;e.target.setAttribute(Mf,a||t),s&&e.target.setAttribute(Nf,s)}else qm(e.target)&&i(e.target)}})}}),Qu&&ah.observe(c,{childList:!0,attributes:!0,characterData:!0,subtree:!0})}}function sh(){ah&&ah.disconnect()}function ch(e){var t=e.getAttribute(`style`),n=[];return t&&(n=t.split(`;`).reduce(function(e,t){var n=t.split(`:`),r=n[0],i=n.slice(1);return r&&i.length>0&&(e[r]=i.join(`:`).trim()),e},{})),n}function lh(e){var t=e.getAttribute(`data-prefix`),n=e.getAttribute(`data-icon`),r=e.innerText===void 0?``:e.innerText.trim(),i=cm(fp(e));return i.prefix||=tm(),t&&n&&(i.prefix=t,i.iconName=n),i.iconName&&i.prefix?i:(i.prefix&&r.length>0&&(i.iconName=Zp(i.prefix,e.innerText)||Xp(i.prefix,Pp(e.innerText))),!i.iconName&&q.autoFetchSvg&&e.firstChild&&e.firstChild.nodeType===Node.TEXT_NODE&&(i.iconName=e.firstChild.data),i)}function uh(e){return dp(e.attributes).reduce(function(e,t){return e.name!==`class`&&e.name!==`style`&&(e[t.name]=t.value),e},{})}function dh(){return{iconName:null,prefix:null,transform:sp,symbol:!1,mask:{iconName:null,prefix:null,rest:[]},maskId:null,extra:{classes:[],styles:{},attributes:{}}}}function fh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{styleParser:!0},n=lh(e),r=n.iconName,i=n.prefix,a=n.rest,o=uh(e),s=ym(`parseNodeAttributes`,{},e);return K({iconName:r,prefix:i,transform:sp,mask:{iconName:null,prefix:null,rest:[]},maskId:null,symbol:!1,extra:{classes:a,styles:t.styleParser?ch(e):[],attributes:o}},s)}var ph=Tp.styles;function mh(e){var t=q.autoReplaceSvg===`nest`?fh(e,{styleParser:!1}):fh(e);return~t.extra.classes.indexOf(Jf)?xm(`generateLayersText`,e,t):xm(`generateSvgReplacementMutation`,e,t)}function hh(){return[].concat(Iu(of),Iu(yf))}function gh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(!Qu)return Promise.resolve();var n=Yu.documentElement.classList,r=function(e){return n.add(`${Pf}-${e}`)},i=function(e){return n.remove(`${Pf}-${e}`)},a=q.autoFetchSvg?hh():ad.concat(Object.keys(ph));a.includes(`fa`)||a.push(`fa`);var o=[`.${Jf}:not([${kf}])`].concat(a.map(function(e){return`.${e}:not([${kf}])`})).join(`, `);if(o.length===0)return Promise.resolve();var s=[];try{s=dp(e.querySelectorAll(o))}catch{}if(s.length>0)r(`pending`),i(`complete`);else return Promise.resolve();var c=Um.begin(`onTree`),l=s.reduce(function(e,t){try{var n=mh(t);n&&e.push(n)}catch(e){Rf||e.name===`MissingIcon`&&console.error(e)}return e},[]);return new Promise(function(e,n){Promise.all(l).then(function(n){th(n,function(){r(`active`),r(`complete`),i(`pending`),typeof t==`function`&&t(),c(),e()})}).catch(function(e){c(),n(e)})})}function _h(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;mh(e).then(function(e){e&&th([e],t)})}function vh(e){return function(t){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},r=(t||{}).icon?t:Sm(t||{}),i=n.mask;return i&&=(i||{}).icon?i:Sm(i||{}),e(r,K(K({},n),{},{mask:i}))}}var yh=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?sp:n,i=t.symbol,a=i!==void 0&&i,o=t.mask,s=o===void 0?null:o,c=t.maskId,l=c===void 0?null:c,u=t.classes,d=u===void 0?[]:u,f=t.attributes,p=f===void 0?{}:f,m=t.styles,h=m===void 0?{}:m;if(e){var g=e.prefix,_=e.iconName,v=e.icon;return Em(K({type:`icon`},e),function(){return bm(`beforeDOMElementCreation`,{iconDefinition:e,params:t}),Am({icons:{main:Pm(v),mask:s?Pm(s.icon):{found:!1,width:null,height:null,icon:{}}},prefix:g,iconName:_,transform:K(K({},sp),r),symbol:a,maskId:l,extra:{attributes:p,styles:h,classes:d}})})}},bh={mixout:function(){return{icon:vh(yh)}},hooks:function(){return{mutationObserverCallbacks:function(e){return e.treeCallback=gh,e.nodeCallback=_h,e}}},provides:function(e){e.i2svg=function(e){var t=e.node,n=t===void 0?Yu:t,r=e.callback;return gh(n,r===void 0?function(){}:r)},e.generateSvgReplacementMutation=function(e,t){var n=t.iconName,r=t.prefix,i=t.transform,a=t.symbol,o=t.mask,s=t.maskId,c=t.extra;return new Promise(function(t,l){Promise.all([Lm(n,r),o.iconName?Lm(o.iconName,o.prefix):Promise.resolve({found:!1,width:512,height:512,icon:{}})]).then(function(o){var l=Fu(o,2),u=l[0],d=l[1];t([e,Am({icons:{main:u,mask:d},prefix:r,iconName:n,transform:i,symbol:a,maskId:s,extra:c,watchable:!0})])}).catch(l)})},e.generateAbstractIcon=function(e){var t=e.children,n=e.attributes,r=e.main,i=e.transform,a=e.styles,o=hp(a);o.length>0&&(n.style=o);var s;return gp(i)&&(s=xm(`generateAbstractTransformGrouping`,{main:r,transform:i,containerWidth:r.width,iconWidth:r.width})),t.push(s||r.icon),{children:t,attributes:n}}}},xh={mixout:function(){return{layer:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.classes,r=n===void 0?[]:n;return Em({type:`layer`},function(){bm(`beforeDOMElementCreation`,{assembler:e,params:t});var n=[];return e(function(e){Array.isArray(e)?e.map(function(e){n=n.concat(e.abstract)}):n=n.concat(e.abstract)}),[{tag:`span`,attributes:{class:[`${q.cssPrefix}-layers`].concat(Iu(r)).join(` `)},children:n}]})}}}},Sh={mixout:function(){return{counter:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.title,r=n===void 0?null:n,i=t.classes,a=i===void 0?[]:i,o=t.attributes,s=o===void 0?{}:o,c=t.styles,l=c===void 0?{}:c;return Em({type:`counter`,content:e},function(){return bm(`beforeDOMElementCreation`,{content:e,params:t}),Mm({content:e.toString(),title:r,extra:{attributes:s,styles:l,classes:[`${q.cssPrefix}-layers-counter`].concat(Iu(a))}})})}}}},Ch={mixout:function(){return{text:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?sp:n,i=t.classes,a=i===void 0?[]:i,o=t.attributes,s=o===void 0?{}:o,c=t.styles,l=c===void 0?{}:c;return Em({type:`text`,content:e},function(){return bm(`beforeDOMElementCreation`,{content:e,params:t}),jm({content:e,transform:K(K({},sp),r),extra:{attributes:s,styles:l,classes:[`${q.cssPrefix}-layers-text`].concat(Iu(a))}})})}}},provides:function(e){e.generateLayersText=function(e,t){var n=t.transform,r=t.extra,i=null,a=null;if($u){var o=parseInt(getComputedStyle(e).fontSize,10),s=e.getBoundingClientRect();i=s.width/o,a=s.height/o}return Promise.resolve([e,jm({content:e.innerHTML,width:i,height:a,transform:n,extra:r,watchable:!0})])}}},wh=RegExp(`"`,`ug`),Th=[1105920,1112319],Eh=K(K(K(K({},{FontAwesome:{normal:`fas`,400:`fas`}}),nf),wf),uf),Dh=Object.keys(Eh).reduce(function(e,t){return e[t.toLowerCase()]=Eh[t],e},{}),Oh=Object.keys(Dh).reduce(function(e,t){var n=Dh[t];return e[t]=n[900]||Iu(Object.entries(n))[0][1],e},{});function kh(e){return Pp(Iu(e.replace(wh,``))[0]||``)}function Ah(e){var t=e.getPropertyValue(`font-feature-settings`).includes(`ss01`),n=e.getPropertyValue(`content`).replace(wh,``),r=n.codePointAt(0),i=r>=Th[0]&&r<=Th[1],a=n.length===2&&n[0]===n[1];return i||a||t}function jh(e,t){var n=e.replace(/^['"]|['"]$/g,``).toLowerCase(),r=parseInt(t),i=isNaN(r)?`normal`:r;return(Dh[n]||{})[i]||Oh[n]}function Mh(e,t){var n=`${jf}${t.replace(`:`,`-`)}`;return new Promise(function(r,i){if(e.getAttribute(n)!==null)return r();var a=dp(e.children).filter(function(e){return e.getAttribute(Af)===t})[0],o=Ju.getComputedStyle(e,t),s=o.getPropertyValue(`font-family`),c=s.match(Yf),l=o.getPropertyValue(`font-weight`),u=o.getPropertyValue(`content`);if(a&&!c)return e.removeChild(a),r();if(c&&u!==`none`&&u!==``){var d=o.getPropertyValue(`content`),f=jh(s,l),p=kh(d),m=c[0].startsWith(`FontAwesome`),h=Ah(o),g=Xp(f,p),_=g;if(m){var v=em(p);v.iconName&&v.prefix&&(g=v.iconName,f=v.prefix)}if(g&&!h&&(!a||a.getAttribute(Mf)!==f||a.getAttribute(Nf)!==_)){e.setAttribute(n,_),a&&e.removeChild(a);var y=dh(),b=y.extra;b.attributes[Af]=t,Lm(g,f).then(function(i){var a=Am(K(K({},y),{},{icons:{main:i,mask:nm()},prefix:f,iconName:_,extra:b,watchable:!0})),o=Yu.createElementNS(`http://www.w3.org/2000/svg`,`svg`);t===`::before`?e.insertBefore(o,e.firstChild):e.appendChild(o),o.outerHTML=a.map(function(e){return Ap(e)}).join(`
`),e.removeAttribute(n),r()}).catch(i)}else r()}else r()})}function Nh(e){return Promise.all([Mh(e,`::before`),Mh(e,`::after`)])}function Ph(e){return e.parentNode!==document.head&&!~If.indexOf(e.tagName.toUpperCase())&&!e.getAttribute(Af)&&(!e.parentNode||e.parentNode.tagName!==`svg`)}var Fh=function(e){return!!e&&Lf.some(function(t){return e.includes(t)})},Ih=function(e){if(!e)return[];var t=new Set,n=e.split(/,(?![^()]*\))/).map(function(e){return e.trim()});n=n.flatMap(function(e){return e.includes(`(`)?e:e.split(`,`).map(function(e){return e.trim()})});var r=ku(n),i;try{for(r.s();!(i=r.n()).done;){var a=i.value;if(Fh(a)){var o=Lf.reduce(function(e,t){return e.replace(t,``)},a);o!==``&&o!==`*`&&t.add(o)}}}catch(e){r.e(e)}finally{r.f()}return t};function Lh(e){var t=arguments.length>1&&arguments[1]!==void 0&&arguments[1];if(Qu){var n;if(t)n=e;else if(q.searchPseudoElementsFullScan)n=e.querySelectorAll(`*`);else{var r=new Set,i=ku(document.styleSheets),a;try{for(i.s();!(a=i.n()).done;){var o=a.value;try{var s=ku(o.cssRules),c;try{for(s.s();!(c=s.n()).done;){var l=c.value,u=ku(Ih(l.selectorText)),d;try{for(u.s();!(d=u.n()).done;){var f=d.value;r.add(f)}}catch(e){u.e(e)}finally{u.f()}}}catch(e){s.e(e)}finally{s.f()}}catch(e){q.searchPseudoElementsWarnings&&console.warn(`Font Awesome: cannot parse stylesheet: ${o.href} (${e.message})
If it declares any Font Awesome CSS pseudo-elements, they will not be rendered as SVG icons. Add crossorigin="anonymous" to the <link>, enable searchPseudoElementsFullScan for slower but more thorough DOM parsing, or suppress this warning by setting searchPseudoElementsWarnings to false.`)}}}catch(e){i.e(e)}finally{i.f()}if(!r.size)return;var p=Array.from(r).join(`, `);try{n=e.querySelectorAll(p)}catch{}}return new Promise(function(e,t){var r=dp(n).filter(Ph).map(Nh),i=Um.begin(`searchPseudoElements`);rh(),Promise.all(r).then(function(){i(),ih(),e()}).catch(function(){i(),ih(),t()})})}}var Rh={hooks:function(){return{mutationObserverCallbacks:function(e){return e.pseudoElementsCallback=Lh,e}}},provides:function(e){e.pseudoElements2svg=function(e){var t=e.node,n=t===void 0?Yu:t;q.searchPseudoElements&&Lh(n)}}},zh=!1,Bh={mixout:function(){return{dom:{unwatch:function(){rh(),zh=!0}}}},hooks:function(){return{bootstrap:function(){oh(ym(`mutationObserverCallbacks`,{}))},noAuto:function(){sh()},watch:function(e){var t=e.observeMutationsRoot;zh?ih():oh(ym(`mutationObserverCallbacks`,{observeMutationsRoot:t}))}}}},Vh=function(e){return e.toLowerCase().split(` `).reduce(function(e,t){var n=t.toLowerCase().split(`-`),r=n[0],i=n.slice(1).join(`-`);if(r&&i===`h`)return e.flipX=!0,e;if(r&&i===`v`)return e.flipY=!0,e;if(i=parseFloat(i),isNaN(i))return e;switch(r){case`grow`:e.size+=i;break;case`shrink`:e.size-=i;break;case`left`:e.x-=i;break;case`right`:e.x+=i;break;case`up`:e.y-=i;break;case`down`:e.y+=i;break;case`rotate`:e.rotate+=i}return e},{size:16,x:0,y:0,flipX:!1,flipY:!1,rotate:0})},Hh={mixout:function(){return{parse:{transform:function(e){return Vh(e)}}}},hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-transform`);return n&&(e.transform=Vh(n)),e}}},provides:function(e){e.generateAbstractTransformGrouping=function(e){var t=e.main,n=e.transform,r=e.containerWidth,i=e.iconWidth,a={outer:{transform:`translate(${r/2} 256)`},inner:{transform:`${`translate(${n.x*32}, ${n.y*32}) `} ${`scale(${n.size/16*(n.flipX?-1:1)}, ${n.size/16*(n.flipY?-1:1)}) `} ${`rotate(${n.rotate} 0 0)`}`},path:{transform:`translate(${i/2*-1} -256)`}};return{tag:`g`,attributes:K({},a.outer),children:[{tag:`g`,attributes:K({},a.inner),children:[{tag:t.icon.tag,children:t.icon.children,attributes:K(K({},t.icon.attributes),a.path)}]}]}}}},Uh={x:0,y:0,width:`100%`,height:`100%`};function Wh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return e.attributes&&(e.attributes.fill||t)&&(e.attributes.fill=`black`),e}function Gh(e){return e.tag===`g`?e.children:[e]}vm([Cp,bh,xh,Sh,Ch,Rh,Bh,Hh,{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-mask`),r=n?cm(n.split(` `).map(function(e){return e.trim()})):nm();return r.prefix||=tm(),e.mask=r,e.maskId=t.getAttribute(`data-fa-mask-id`),e}}},provides:function(e){e.generateAbstractMask=function(e){var t=e.children,n=e.attributes,r=e.main,i=e.mask,a=e.maskId,o=e.transform,s=r.width,c=r.icon,l=i.width,u=i.icon,d=_p({transform:o,containerWidth:l,iconWidth:s}),f={tag:`rect`,attributes:K(K({},Uh),{},{fill:`white`})},p=c.children?{children:c.children.map(Wh)}:{},m={tag:`g`,attributes:K({},d.inner),children:[Wh(K({tag:c.tag,attributes:K(K({},c.attributes),d.path)},p))]},h={tag:`g`,attributes:K({},d.outer),children:[m]},g=`mask-${a||up()}`,_=`clip-${a||up()}`,v={tag:`mask`,attributes:K(K({},Uh),{},{id:g,maskUnits:`userSpaceOnUse`,maskContentUnits:`userSpaceOnUse`}),children:[f,h]},y={tag:`defs`,children:[{tag:`clipPath`,attributes:{id:_},children:Gh(u)},v]};return t.push(y,{tag:`rect`,attributes:K({fill:`currentColor`,"clip-path":`url(#${_})`,mask:`url(#${g})`},Uh)}),{children:t,attributes:n}}}},{provides:function(e){var t=!1;Ju.matchMedia&&(t=Ju.matchMedia(`(prefers-reduced-motion: reduce)`).matches),e.missingIconAbstract=function(){var e=[],n={fill:`currentColor`},r={attributeType:`XML`,repeatCount:`indefinite`,dur:`2s`};e.push({tag:`path`,attributes:K(K({},n),{},{d:`M156.5,447.7l-12.6,29.5c-18.7-9.5-35.9-21.2-51.5-34.9l22.7-22.7C127.6,430.5,141.5,440,156.5,447.7z M40.6,272H8.5 c1.4,21.2,5.4,41.7,11.7,61.1L50,321.2C45.1,305.5,41.8,289,40.6,272z M40.6,240c1.4-18.8,5.2-37,11.1-54.1l-29.5-12.6 C14.7,194.3,10,216.7,8.5,240H40.6z M64.3,156.5c7.8-14.9,17.2-28.8,28.1-41.5L69.7,92.3c-13.7,15.6-25.5,32.8-34.9,51.5 L64.3,156.5z M397,419.6c-13.9,12-29.4,22.3-46.1,30.4l11.9,29.8c20.7-9.9,39.8-22.6,56.9-37.6L397,419.6z M115,92.4 c13.9-12,29.4-22.3,46.1-30.4l-11.9-29.8c-20.7,9.9-39.8,22.6-56.8,37.6L115,92.4z M447.7,355.5c-7.8,14.9-17.2,28.8-28.1,41.5 l22.7,22.7c13.7-15.6,25.5-32.9,34.9-51.5L447.7,355.5z M471.4,272c-1.4,18.8-5.2,37-11.1,54.1l29.5,12.6 c7.5-21.1,12.2-43.5,13.6-66.8H471.4z M321.2,462c-15.7,5-32.2,8.2-49.2,9.4v32.1c21.2-1.4,41.7-5.4,61.1-11.7L321.2,462z M240,471.4c-18.8-1.4-37-5.2-54.1-11.1l-12.6,29.5c21.1,7.5,43.5,12.2,66.8,13.6V471.4z M462,190.8c5,15.7,8.2,32.2,9.4,49.2h32.1 c-1.4-21.2-5.4-41.7-11.7-61.1L462,190.8z M92.4,397c-12-13.9-22.3-29.4-30.4-46.1l-29.8,11.9c9.9,20.7,22.6,39.8,37.6,56.9 L92.4,397z M272,40.6c18.8,1.4,36.9,5.2,54.1,11.1l12.6-29.5C317.7,14.7,295.3,10,272,8.5V40.6z M190.8,50 c15.7-5,32.2-8.2,49.2-9.4V8.5c-21.2,1.4-41.7,5.4-61.1,11.7L190.8,50z M442.3,92.3L419.6,115c12,13.9,22.3,29.4,30.5,46.1 l29.8-11.9C470,128.5,457.3,109.4,442.3,92.3z M397,92.4l22.7-22.7c-15.6-13.7-32.8-25.5-51.5-34.9l-12.6,29.5 C370.4,72.1,384.4,81.5,397,92.4z`})});var i=K(K({},r),{},{attributeName:`opacity`}),a={tag:`circle`,attributes:K(K({},n),{},{cx:`256`,cy:`364`,r:`28`}),children:[]};return t||a.children.push({tag:`animate`,attributes:K(K({},r),{},{attributeName:`r`,values:`28;14;28;28;14;28;`})},{tag:`animate`,attributes:K(K({},i),{},{values:`1;0;1;1;0;1;`})}),e.push(a),e.push({tag:`path`,attributes:K(K({},n),{},{opacity:`1`,d:`M263.7,312h-16c-6.6,0-12-5.4-12-12c0-71,77.4-63.9,77.4-107.8c0-20-17.8-40.2-57.4-40.2c-29.1,0-44.3,9.6-59.2,28.7 c-3.9,5-11.1,6-16.2,2.4l-13.1-9.2c-5.6-3.9-6.9-11.8-2.6-17.2c21.2-27.2,46.4-44.7,91.2-44.7c52.3,0,97.4,29.8,97.4,80.2 c0,67.6-77.4,63.5-77.4,107.8C275.7,306.6,270.3,312,263.7,312z`}),children:t?[]:[{tag:`animate`,attributes:K(K({},i),{},{values:`1;0;0;0;0;1;`})}]}),t||e.push({tag:`path`,attributes:K(K({},n),{},{opacity:`0`,d:`M232.5,134.5l7,168c0.3,6.4,5.6,11.5,12,11.5h9c6.4,0,11.7-5.1,12-11.5l7-168c0.3-6.8-5.2-12.5-12-12.5h-23 C237.7,122,232.2,127.7,232.5,134.5z`}),children:[{tag:`animate`,attributes:K(K({},i),{},{values:`0;0;1;1;0;0;`})}]}),{tag:`g`,attributes:{class:`missing`},children:e}}}},{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-symbol`);return e.symbol=n===null?!1:n===``||n,e}}}}],{mixoutsTo:wm}),wm.noAuto,wm.config,wm.library,wm.dom;var Kh=wm.parse;wm.findIconDefinition,wm.toHtml;var qh=wm.icon;wm.layer,wm.text,wm.counter;function Jh(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function Yh(e){if(Array.isArray(e))return Jh(e)}function Xh(e,t,n){return(t=ag(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function Zh(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function Qh(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function $h(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function eg(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?$h(Object(n),!0).forEach(function(t){Xh(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):$h(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function tg(e,t){if(e==null)return{};var n,r,i=ng(e,t);if(Object.getOwnPropertySymbols){var a=Object.getOwnPropertySymbols(e);for(r=0;r<a.length;r++)n=a[r],t.indexOf(n)===-1&&{}.propertyIsEnumerable.call(e,n)&&(i[n]=e[n])}return i}function ng(e,t){if(e==null)return{};var n={};for(var r in e)if({}.hasOwnProperty.call(e,r)){if(t.indexOf(r)!==-1)continue;n[r]=e[r]}return n}function rg(e){return Yh(e)||Zh(e)||sg(e)||Qh()}function ig(e,t){if(typeof e!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(typeof r!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function ag(e){var t=ig(e,`string`);return typeof t==`symbol`?t:t+``}function og(e){"@babel/helpers - typeof";return og=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},og(e)}function sg(e,t){if(e){if(typeof e==`string`)return Jh(e,t);var n={}.toString.call(e).slice(8,-1);return n===`Object`&&e.constructor&&(n=e.constructor.name),n===`Map`||n===`Set`?Array.from(e):n===`Arguments`||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?Jh(e,t):void 0}}function cg(e,t){return Array.isArray(t)&&t.length>0||!Array.isArray(t)&&t?Xh({},e,t):{}}function lg(e){var t,n=(t={"fa-spin":e.spin,"fa-pulse":e.pulse,"fa-fw":e.fixedWidth,"fa-border":e.border,"fa-li":e.listItem,"fa-inverse":e.inverse,"fa-flip":e.flip===!0,"fa-flip-horizontal":e.flip===`horizontal`||e.flip===`both`,"fa-flip-vertical":e.flip===`vertical`||e.flip===`both`},Xh(Xh(Xh(Xh(Xh(Xh(Xh(Xh(Xh(Xh(t,`fa-${e.size}`,e.size!==null),`fa-rotate-${e.rotation}`,e.rotation!==null),`fa-rotate-by`,e.rotateBy),`fa-pull-${e.pull}`,e.pull!==null),`fa-swap-opacity`,e.swapOpacity),`fa-bounce`,e.bounce),`fa-shake`,e.shake),`fa-beat`,e.beat),`fa-fade`,e.fade),`fa-beat-fade`,e.beatFade),Xh(Xh(Xh(Xh(Xh(Xh(Xh(Xh(Xh(Xh(t,`fa-flash`,e.flash),`fa-spin-pulse`,e.spinPulse),`fa-spin-reverse`,e.spinReverse),`fa-width-auto`,e.widthAuto),`fa-canvas-square`,e.canvasSquare),`fa-canvas-roomy`,e.canvasRoomy),`fa-flip-360`,e.flip360),`fa-buzz`,e.buzz),`fa-float`,e.float),`fa-jello`,e.jello),Xh(Xh(Xh(Xh(Xh(t,`fa-spin-snap`,e.spinSnap),`fa-spin-snap-4`,e.spinSnap4),`fa-spin-snap-8`,e.spinSnap8),`fa-swing`,e.swing),`fa-wag`,e.wag));return Object.keys(n).map(function(e){return n[e]?e:null}).filter(function(e){return e})}var ug=typeof globalThis<`u`?globalThis:typeof window<`u`?window:typeof global<`u`?global:typeof self<`u`?self:{},dg={exports:{}};(function(e){(function(t){var n=function(e,t,r){if(!l(t)||d(t)||f(t)||p(t)||c(t))return t;var i,a=0,o=0;if(u(t))for(i=[],o=t.length;a<o;a++)i.push(n(e,t[a],r));else for(var s in i={},t)Object.prototype.hasOwnProperty.call(t,s)&&(i[e(s,r)]=n(e,t[s],r));return i},r=function(e,t){t||={};var n=t.separator||`_`,r=t.split||/(?=[A-Z])/;return e.split(r).join(n)},i=function(e){return m(e)?e:(e=e.replace(/[\-_\s]+(.)?/g,function(e,t){return t?t.toUpperCase():``}),e.substr(0,1).toLowerCase()+e.substr(1))},a=function(e){var t=i(e);return t.substr(0,1).toUpperCase()+t.substr(1)},o=function(e,t){return r(e,t).toLowerCase()},s=Object.prototype.toString,c=function(e){return typeof e==`function`},l=function(e){return e===Object(e)},u=function(e){return s.call(e)==`[object Array]`},d=function(e){return s.call(e)==`[object Date]`},f=function(e){return s.call(e)==`[object RegExp]`},p=function(e){return s.call(e)==`[object Boolean]`},m=function(e){return e-=0,e===e},h=function(e,t){var n=t&&`process`in t?t.process:t;return typeof n==`function`?function(t,r){return n(t,e,r)}:e},g={camelize:i,decamelize:o,pascalize:a,depascalize:o,camelizeKeys:function(e,t){return n(h(i,t),e)},decamelizeKeys:function(e,t){return n(h(o,t),e,t)},pascalizeKeys:function(e,t){return n(h(a,t),e)},depascalizeKeys:function(){return this.decamelizeKeys.apply(this,arguments)}};e.exports?e.exports=g:t.humps=g})(ug)})(dg);var fg=dg.exports,pg=[`gradientFill`],mg=[`class`,`style`],hg=[`type`,`stops`,`id`];function gg(e){return e.split(`;`).map(function(e){return e.trim()}).filter(function(e){return e}).reduce(function(e,t){var n=t.indexOf(`:`),r=fg.camelize(t.slice(0,n));return e[r]=t.slice(n+1).trim(),e},{})}function _g(e){return e.split(/\s+/).reduce(function(e,t){return e[t]=!0,e},{})}function vg(e,t){return tc(`stop`,eg({key:`${t}-${e.offset}`,offset:e.offset,"stop-color":e.color},e.opacity!==void 0&&{"stop-opacity":e.opacity}))}function yg(e){if(typeof e==`string`)return e;var t=(e.children||[]).map(yg);return e.tag===`path`&&e.attributes&&`fill`in e.attributes?eg(eg({},e),{},{attributes:eg(eg({},e.attributes),{},{fill:void 0}),children:t}):eg(eg({},e),{},{children:t})}function bg(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{};if(typeof e==`string`)return e;var r=t.gradientFill,i=r===void 0?null:r,a=tg(t,pg),o=i||`fill`in n?yg(e):e,s=(o.children||[]).map(function(e){return bg(e,{},{})}),c=Object.keys(o.attributes||{}).reduce(function(e,t){var n=o.attributes[t];switch(t){case`class`:e.class=_g(n);break;case`style`:e.style=gg(n);break;default:e.attrs[t]=n}return e},{attrs:{},class:{},style:{}});n.class;var l=n.style,u=l===void 0?{}:l,d=tg(n,mg);if(i&&i.id&&(i.type===`linear`||i.type===`radial`)){var f=i.type,p=i.stops,m=p===void 0?[]:p,h=i.id,g=tg(i,hg),_=tc(f===`linear`?`linearGradient`:`radialGradient`,eg(eg({},g),{},{id:h}),m.map(vg));return tc(o.tag,eg(eg(eg(eg({},a),{},{class:c.class,style:eg(eg({},c.style),u)},c.attrs),d),{},{fill:`url(#${h})`}),[_].concat(rg(s)))}return tc(e.tag,eg(eg(eg({},a),{},{class:c.class,style:eg(eg({},c.style),u)},c.attrs),d),s)}var xg=!1;try{xg=!0}catch{}function Sg(){if(!xg&&console&&typeof console.error==`function`){var e;(e=console).error.apply(e,arguments)}}function Cg(e){if(e&&og(e)===`object`&&e.prefix&&e.iconName&&e.icon)return e;if(Kh.icon)return Kh.icon(e);if(e===null)return null;if(og(e)===`object`&&e.prefix&&e.iconName)return e;if(Array.isArray(e)&&e.length===2)return{prefix:e[0],iconName:e[1]};if(typeof e==`string`)return{prefix:`fas`,iconName:e}}var wg=F({name:`FontAwesomeIcon`,props:{border:{type:Boolean,default:!1},fixedWidth:{type:Boolean,default:!1},flip:{type:[Boolean,String],default:!1,validator:function(e){return[!0,!1,`horizontal`,`vertical`,`both`].indexOf(e)>-1}},icon:{type:[Object,Array,String],required:!0},mask:{type:[Object,Array,String],default:null},maskId:{type:String,default:null},listItem:{type:Boolean,default:!1},pull:{type:String,default:null,validator:function(e){return[`right`,`left`].indexOf(e)>-1}},pulse:{type:Boolean,default:!1},rotation:{type:[String,Number],default:null,validator:function(e){return[90,180,270].indexOf(Number.parseInt(e,10))>-1}},rotateBy:{type:Boolean,default:!1},swapOpacity:{type:Boolean,default:!1},size:{type:String,default:null,validator:function(e){return[`2xs`,`xs`,`sm`,`lg`,`xl`,`2xl`,`1x`,`2x`,`3x`,`4x`,`5x`,`6x`,`7x`,`8x`,`9x`,`10x`].indexOf(e)>-1}},spin:{type:Boolean,default:!1},transform:{type:[String,Object],default:null},symbol:{type:[Boolean,String],default:!1},title:{type:String,default:null},titleId:{type:String,default:null},inverse:{type:Boolean,default:!1},bounce:{type:Boolean,default:!1},shake:{type:Boolean,default:!1},beat:{type:Boolean,default:!1},fade:{type:Boolean,default:!1},beatFade:{type:Boolean,default:!1},flash:{type:Boolean,default:!1},spinPulse:{type:Boolean,default:!1},spinReverse:{type:Boolean,default:!1},widthAuto:{type:Boolean,default:!1},canvasSquare:{type:Boolean,default:!1},canvasRoomy:{type:Boolean,default:!1},gradientFill:{type:Object,default:null,validator:function(e){return typeof e.id!=`string`||!e.id?(console.warn(`FontAwesomeIcon: gradientFill.id must be a non-empty string`),!1):e.type!==`linear`&&e.type!==`radial`?(console.warn(`FontAwesomeIcon: gradientFill.type must be "linear" or "radial"`),!1):!0}},flip360:{type:Boolean,default:!1},buzz:{type:Boolean,default:!1},float:{type:Boolean,default:!1},jello:{type:Boolean,default:!1},spinSnap:{type:Boolean,default:!1},spinSnap4:{type:Boolean,default:!1},spinSnap8:{type:Boolean,default:!1},swing:{type:Boolean,default:!1},wag:{type:Boolean,default:!1}},setup:function(e,t){var n=t.attrs,r=W(function(){return Cg(e.icon)}),i=W(function(){return cg(`classes`,lg(e))}),a=W(function(){return cg(`transform`,typeof e.transform==`string`?Kh.transform(e.transform):e.transform)}),o=W(function(){return cg(`mask`,Cg(e.mask))}),s=W(function(){var t=eg(eg(eg(eg({},i.value),a.value),o.value),{},{symbol:e.symbol,maskId:e.maskId});return t.title=e.title,t.titleId=e.titleId,qh(r.value,t)});Er(s,function(e){if(!e)return Sg(`Could not find one or more icon(s)`,r.value,o.value)},{immediate:!0}),e.gradientFill&&e.symbol&&Sg(`gradientFill is not supported when symbol is true and will be ignored`);var c=W(function(){return s.value?bg(s.value.abstract[0],{gradientFill:e.symbol?null:e.gradientFill},n):null});return function(){return c.value}}}),Tg=typeof window<`u`,Eg,Dg=e=>Eg=e,Og=Symbol();function kg(e){return e&&typeof e==`object`&&Object.prototype.toString.call(e)===`[object Object]`&&typeof e.toJSON!=`function`}var Ag=typeof window==`object`&&window.window===window?window:typeof self==`object`&&self.self===self?self:typeof global==`object`&&global.global===global?global:typeof globalThis==`object`?globalThis:{HTMLElement:null};function jg(e,{autoBom:t=!1}={}){return t&&/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(e.type)?new Blob([`﻿`,e],{type:e.type}):e}function Mg(e,t,n){let r=new XMLHttpRequest;r.open(`GET`,e),r.responseType=`blob`,r.onload=function(){Lg(r.response,t,n)},r.onerror=function(){console.error(`could not download file`)},r.send()}function Ng(e){let t=new XMLHttpRequest;t.open(`HEAD`,e,!1);try{t.send()}catch{}return t.status>=200&&t.status<=299}function Pg(e){try{e.dispatchEvent(new MouseEvent(`click`))}catch{let t=new MouseEvent(`click`,{bubbles:!0,cancelable:!0,view:window,detail:0,screenX:80,screenY:20,clientX:80,clientY:20,ctrlKey:!1,altKey:!1,shiftKey:!1,metaKey:!1,button:0,relatedTarget:null});e.dispatchEvent(t)}}var Fg=typeof navigator==`object`?navigator:{userAgent:``},Ig=/Macintosh/.test(Fg.userAgent)&&/AppleWebKit/.test(Fg.userAgent)&&!/Safari/.test(Fg.userAgent),Lg=Tg?typeof HTMLAnchorElement<`u`&&`download`in HTMLAnchorElement.prototype&&!Ig?Rg:`msSaveOrOpenBlob`in Fg?zg:Bg:()=>{};function Rg(e,t=`download`,n){let r=document.createElement(`a`);r.download=t,r.rel=`noopener`,typeof e==`string`?(r.href=e,r.origin===location.origin?Pg(r):Ng(r.href)?Mg(e,t,n):(r.target=`_blank`,Pg(r))):(r.href=URL.createObjectURL(e),setTimeout(function(){URL.revokeObjectURL(r.href)},4e4),setTimeout(function(){Pg(r)},0))}function zg(e,t=`download`,n){if(typeof e==`string`){if(Ng(e))Mg(e,t,n);else{let t=document.createElement(`a`);t.href=e,t.target=`_blank`,setTimeout(function(){Pg(t)})}}else navigator.msSaveOrOpenBlob(jg(e,n),t)}function Bg(e,t,n,r){if(r||=open(``,`_blank`),r&&(r.document.title=r.document.body.innerText=`downloading...`),typeof e==`string`)return Mg(e,t,n);let i=e.type===`application/octet-stream`,a=/constructor/i.test(String(Ag.HTMLElement))||`safari`in Ag,o=/CriOS\/[\d]+/.test(navigator.userAgent);if((o||i&&a||Ig)&&typeof FileReader<`u`){let t=new FileReader;t.onloadend=function(){let e=t.result;if(typeof e!=`string`)throw r=null,Error(`Wrong reader.result type`);e=o?e:e.replace(/^data:[^;]*;/,`data:attachment/file;`),r?r.location.href=e:location.assign(e),r=null},t.readAsDataURL(e)}else{let t=URL.createObjectURL(e);r?r.location.assign(t):location.href=t,r=null,setTimeout(function(){URL.revokeObjectURL(t)},4e4)}}var{assign:Vg}=Object;function Hg(){let e=Pe(!0),t=e.run(()=>M({})),n=[],r=[],i=sn({install(e){Dg(i),i._a=e,e.provide(Og,i),e.config.globalProperties.$pinia=i,r.forEach(e=>n.push(e)),r=[]},use(e){return this._a?n.push(e):r.push(e),this},_p:n,_a:null,_e:e,_s:new Map,state:t});return i}var Ug=()=>{};function Wg(e,t,n,r=Ug){e.add(t);let i=()=>{e.delete(t)&&r()};return!n&&Fe()&&Ie(i),i}function Gg(e,...t){e.forEach(e=>{e(...t)})}var Kg=e=>e(),qg=Symbol(),Jg=Symbol();function Yg(e,t){e instanceof Map&&t instanceof Map?t.forEach((t,n)=>e.set(n,t)):e instanceof Set&&t instanceof Set&&t.forEach(e.add,e);for(let n in t){if(!Object.hasOwn(t,n))continue;let r=t[n],i=e[n];e[n]=kg(i)&&kg(r)&&Object.hasOwn(e,n)&&!j(r)&&!nn(r)?Yg(i,r):r}return e}var Xg=Symbol();function Zg(e){return!e||typeof e!=`object`||!Object.hasOwn(e,Xg)}var{assign:Qg}=Object;function $g(e){return!!(j(e)&&e.effect)}function e_(e,t,n,r){let{state:i,actions:a,getters:o}=t,s=n.state.value[e],c;function l(){return s||(n.state.value[e]=i?i():{}),Qg(yn(n.state.value[e]),a,Object.keys(o||{}).reduce((t,r)=>(t[r]=sn(W(()=>{Dg(n);let t=n._s.get(e);return o[r].call(t,t)})),t),{}))}return c=t_(e,l,t,n,r,!0),c}function t_(e,t,n={},r,i,a){let o,s=Qg({actions:{}},n),c={deep:!0},l,u,d=new Set,f=new Set,p,m=r.state.value[e];!a&&!m&&(r.state.value[e]={});let h;function g(t){let n;l=u=!1,typeof t==`function`?(t(r.state.value[e]),n={type:`patch function`,storeId:e,events:p}):(Yg(r.state.value[e],t),n={type:`patch object`,payload:t,storeId:e,events:p});let i=h=Symbol();Qn().then(()=>{h===i&&(l=!0)}),u=!0,Gg(d,n,r.state.value[e])}let _=a?function(){let{state:e}=n,t=e?e():{};this.$patch(e=>{Qg(e,t)})}:Ug;function v(){o.stop(),d.clear(),f.clear(),r._s.delete(e)}let y=(t,n=``)=>{if(qg in t)return t[Jg]=n,t;let i=function(){Dg(r);let n=Array.from(arguments),a=new Set,o=new Set;function s(e){a.add(e)}function c(e){o.add(e)}Gg(f,{args:n,name:i[Jg],store:b,after:s,onError:c});let l;try{l=t.apply(this&&this.$id===e?this:b,n)}catch(e){throw Gg(o,e),e}return l instanceof Promise?l.then(e=>(Gg(a,e),e)).catch(e=>(Gg(o,e),Promise.reject(e))):(Gg(a,l),l)};return i[qg]=!0,i[Jg]=n,i},b=Zt({_p:r,$id:e,$onAction:Wg.bind(null,f),$patch:g,$reset:_,$subscribe(t,n={}){if(d.has(t))return Ug;let i=Wg(d,t,n.detached,()=>a()),a=o.run(()=>Er(()=>r.state.value[e],r=>{(n.flush===`sync`?u:l)&&t({storeId:e,type:`direct`,events:p},r)},Qg({},c,n)));return i},$dispose:v});r._s.set(e,b);let x=(r._a&&r._a.runWithContext||Kg)(()=>r._e.run(()=>(o=Pe()).run(()=>t({action:y}))));for(let t in x){let n=x[t];j(n)&&!$g(n)||nn(n)?a||(m&&Zg(n)&&(j(n)?n.value=m[t]:((n instanceof Set||n instanceof Map)&&n.clear(),Yg(n,m[t]))),r.state.value[e][t]=n):typeof n==`function`&&(x[t]=y(n,t),s.actions[t]=n)}return Qg(b,x),Qg(A(b),x),Object.defineProperty(b,"$state",{get:()=>r.state.value[e],set:e=>{g(t=>{Qg(t,e)})}}),r._p.forEach(e=>{let t=o.run(()=>e({store:b,app:r._a,pinia:r,options:s}));Qg(b,t)}),m&&a&&n.hydrate&&n.hydrate(b.$state,m),l=!0,u=!0,b}function n_(e,t,n){let r,i=typeof t==`function`;r=i?n:t;function a(n,a){let o=br();return n||=o?yr(Og,null):null,n&&Dg(n),n=Eg,n._s.has(e)||(i?t_(e,t,r,n):e_(e,r,n)),n._s.get(e)}return a.$id=e,a}var r_={prefix:`fab`,iconName:`github`,icon:[512,512,[],`f09b`,`M216.5 362.5c-66-8-112.5-55.5-112.5-117 0-25 9-52 24-70-6.5-16.5-5.5-51.5 2-66 20-2.5 47 8 63 22.5 19-6 39-9 63.5-9s44.5 3 62.5 8.5c15.5-14 43-24.5 63-22 7 13.5 8 48.5 1.5 65.5 16 19 24.5 44.5 24.5 70.5 0 61.5-46.5 108-113.5 116.5 17 11 28.5 35 28.5 62.5l0 52C323 491.5 335.5 500 350.5 494 441 459.5 512 369 512 257 512 115.5 397 0 255.5 0S0 115.5 0 257c0 111 70.5 203 165.5 237.5 13.5 5 26.5-4 26.5-17.5l0-40c-7 3-16 5-24 5-33 0-52.5-18-66.5-51.5-5.5-13.5-11.5-21.5-23-23-6-.5-8-3-8-6 0-6 10-10.5 20-10.5 14.5 0 27 9 40 27.5 10 14.5 20.5 21 33 21s20.5-4.5 32-16c8.5-8.5 15-16 21-21z`]},i_={prefix:`fas`,iconName:`magnifying-glass`,icon:[512,512,[128269,`search`],`f002`,`M416 208c0 45.9-14.9 88.3-40 122.7L502.6 457.4c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L330.7 376C296.3 401.1 253.9 416 208 416 93.1 416 0 322.9 0 208S93.1 0 208 0 416 93.1 416 208zM208 352a144 144 0 1 0 0-288 144 144 0 1 0 0 288z`]},a_={prefix:`fas`,iconName:`key`,icon:[512,512,[128273],`f084`,`M336 352c97.2 0 176-78.8 176-176S433.2 0 336 0 160 78.8 160 176c0 18.7 2.9 36.8 8.3 53.7L7 391c-4.5 4.5-7 10.6-7 17l0 80c0 13.3 10.7 24 24 24l80 0c13.3 0 24-10.7 24-24l0-40 40 0c13.3 0 24-10.7 24-24l0-40 40 0c6.4 0 12.5-2.5 17-7l33.3-33.3c16.9 5.4 35 8.3 53.7 8.3zM376 96a40 40 0 1 1 0 80 40 40 0 1 1 0-80z`]},o_={prefix:`fas`,iconName:`sort-up`,icon:[384,512,[`sort-asc`],`f0de`,`M32 224c-12.9 0-24.6-7.8-29.6-19.8S.2 178.5 9.4 169.4l160-160c12.5-12.5 32.8-12.5 45.3 0l160 160c9.2 9.2 11.9 22.9 6.9 34.9S364.9 224 352 224L32 224z`]},s_={prefix:`fas`,iconName:`eye`,icon:[576,512,[128065],`f06e`,`M288 32c-80.8 0-145.5 36.8-192.6 80.6-46.8 43.5-78.1 95.4-93 131.1-3.3 7.9-3.3 16.7 0 24.6 14.9 35.7 46.2 87.7 93 131.1 47.1 43.7 111.8 80.6 192.6 80.6s145.5-36.8 192.6-80.6c46.8-43.5 78.1-95.4 93-131.1 3.3-7.9 3.3-16.7 0-24.6-14.9-35.7-46.2-87.7-93-131.1-47.1-43.7-111.8-80.6-192.6-80.6zM144 256a144 144 0 1 1 288 0 144 144 0 1 1 -288 0zm144-64c0 35.3-28.7 64-64 64-11.5 0-22.3-3-31.7-8.4-1 10.9-.1 22.1 2.9 33.2 13.7 51.2 66.4 81.6 117.6 67.9s81.6-66.4 67.9-117.6c-12.2-45.7-55.5-74.8-101.1-70.8 5.3 9.3 8.4 20.1 8.4 31.7z`]},c_={prefix:`fas`,iconName:`chevron-up`,icon:[448,512,[],`f077`,`M201.4 105.4c12.5-12.5 32.8-12.5 45.3 0l192 192c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L224 173.3 54.6 342.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l192-192z`]},l_={prefix:`fas`,iconName:`circle-xmark`,icon:[512,512,[61532,`times-circle`,`xmark-circle`],`f057`,`M256 512a256 256 0 1 0 0-512 256 256 0 1 0 0 512zM167 167c9.4-9.4 24.6-9.4 33.9 0l55 55 55-55c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9l-55 55 55 55c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0l-55-55-55 55c-9.4 9.4-24.6 9.4-33.9 0s-9.4-24.6 0-33.9l55-55-55-55c-9.4-9.4-9.4-24.6 0-33.9z`]},u_={prefix:`fas`,iconName:`circle-exclamation`,icon:[512,512,[`exclamation-circle`],`f06a`,`M256 512a256 256 0 1 1 0-512 256 256 0 1 1 0 512zm0-192a32 32 0 1 0 0 64 32 32 0 1 0 0-64zm0-192c-18.2 0-32.7 15.5-31.4 33.7l7.4 104c.9 12.6 11.4 22.3 23.9 22.3 12.6 0 23-9.7 23.9-22.3l7.4-104c1.3-18.2-13.1-33.7-31.4-33.7z`]},d_={prefix:`fas`,iconName:`check`,icon:[448,512,[10003,10004],`f00c`,`M434.8 70.1c14.3 10.4 17.5 30.4 7.1 44.7l-256 352c-5.5 7.6-14 12.3-23.4 13.1s-18.5-2.7-25.1-9.3l-128-128c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0l101.5 101.5 234-321.7c10.4-14.3 30.4-17.5 44.7-7.1z`]},f_={prefix:`fas`,iconName:`sort`,icon:[384,512,[`unsorted`],`f0dc`,`M2.4 204.2c5 12 16.6 19.8 29.6 19.8l320 0c12.9 0 24.6-7.8 29.6-19.8s2.2-25.7-6.9-34.9l-160-160c-12.5-12.5-32.8-12.5-45.3 0l-160 160c-9.2 9.2-11.9 22.9-6.9 34.9zm0 103.5c-5 12-2.2 25.7 6.9 34.9l160 160c12.5 12.5 32.8 12.5 45.3 0l160-160c9.2-9.2 11.9-22.9 6.9-34.9S364.9 288 352 288L32 288c-12.9 0-24.6 7.8-29.6 19.8z`]},p_={prefix:`fas`,iconName:`xmark`,icon:[384,512,[128473,10005,10006,10060,215,`close`,`multiply`,`remove`,`times`],`f00d`,`M55.1 73.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3L147.2 256 9.9 393.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0L192.5 301.3 329.9 438.6c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L237.8 256 375.1 118.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L192.5 210.7 55.1 73.4z`]},m_={prefix:`fas`,iconName:`circle-check`,icon:[512,512,[61533,`check-circle`],`f058`,`M256 512a256 256 0 1 1 0-512 256 256 0 1 1 0 512zM374 145.7c-10.7-7.8-25.7-5.4-33.5 5.3L221.1 315.2 169 263.1c-9.4-9.4-24.6-9.4-33.9 0s-9.4 24.6 0 33.9l72 72c5 5 11.8 7.5 18.8 7s13.4-4.1 17.5-9.8L379.3 179.2c7.8-10.7 5.4-25.7-5.3-33.5z`]},h_={prefix:`fas`,iconName:`chevron-down`,icon:[448,512,[],`f078`,`M201.4 406.6c12.5 12.5 32.8 12.5 45.3 0l192-192c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 338.7 54.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l192 192z`]},g_={prefix:`fas`,iconName:`triangle-exclamation`,icon:[512,512,[9888,`exclamation-triangle`,`warning`],`f071`,`M256 0c14.7 0 28.2 8.1 35.2 21l216 400c6.7 12.4 6.4 27.4-.8 39.5S486.1 480 472 480L40 480c-14.1 0-27.2-7.4-34.4-19.5s-7.5-27.1-.8-39.5l216-400c7-12.9 20.5-21 35.2-21zm0 352a32 32 0 1 0 0 64 32 32 0 1 0 0-64zm0-192c-18.2 0-32.7 15.5-31.4 33.7l7.4 104c.9 12.5 11.4 22.3 23.9 22.3 12.6 0 23-9.7 23.9-22.3l7.4-104c1.3-18.2-13.1-33.7-31.4-33.7z`]},__={prefix:`fas`,iconName:`copy`,icon:[448,512,[],`f0c5`,`M192 0c-35.3 0-64 28.7-64 64l0 256c0 35.3 28.7 64 64 64l192 0c35.3 0 64-28.7 64-64l0-200.6c0-17.4-7.1-34.1-19.7-46.2L370.6 17.8C358.7 6.4 342.8 0 326.3 0L192 0zM64 128c-35.3 0-64 28.7-64 64L0 448c0 35.3 28.7 64 64 64l192 0c35.3 0 64-28.7 64-64l0-16-64 0 0 16-192 0 0-256 16 0 0-64-16 0z`]},v_={prefix:`fas`,iconName:`eye-slash`,icon:[576,512,[],`f070`,`M41-24.9c-9.4-9.4-24.6-9.4-33.9 0S-2.3-.3 7 9.1l528 528c9.4 9.4 24.6 9.4 33.9 0s9.4-24.6 0-33.9l-96.4-96.4c2.7-2.4 5.4-4.8 8-7.2 46.8-43.5 78.1-95.4 93-131.1 3.3-7.9 3.3-16.7 0-24.6-14.9-35.7-46.2-87.7-93-131.1-47.1-43.7-111.8-80.6-192.6-80.6-56.8 0-105.6 18.2-146 44.2L41-24.9zM204.5 138.7c23.5-16.8 52.4-26.7 83.5-26.7 79.5 0 144 64.5 144 144 0 31.1-9.9 59.9-26.7 83.5l-34.7-34.7c12.7-21.4 17-47.7 10.1-73.7-13.7-51.2-66.4-81.6-117.6-67.9-8.6 2.3-16.7 5.7-24 10l-34.7-34.7zM325.3 395.1c-11.9 3.2-24.4 4.9-37.3 4.9-79.5 0-144-64.5-144-144 0-12.9 1.7-25.4 4.9-37.3L69.4 139.2c-32.6 36.8-55 75.8-66.9 104.5-3.3 7.9-3.3 16.7 0 24.6 14.9 35.7 46.2 87.7 93 131.1 47.1 43.7 111.8 80.6 192.6 80.6 37.3 0 71.2-7.9 101.5-20.6l-64.2-64.2z`]},y_={prefix:`fas`,iconName:`sort-down`,icon:[384,512,[`sort-desc`],`f0dd`,`M32 288c-12.9 0-24.6 7.8-29.6 19.8S.2 333.5 9.4 342.6l160 160c12.5 12.5 32.8 12.5 45.3 0l160-160c9.2-9.2 11.9-22.9 6.9-34.9S364.9 288 352 288L32 288z`]};function b_(e){var t,n,r=``;if(typeof e==`string`||typeof e==`number`)r+=e;else if(typeof e==`object`){if(Array.isArray(e)){var i=e.length;for(t=0;t<i;t++)e[t]&&(n=b_(e[t]))&&(r&&(r+=` `),r+=n)}else for(n in e)e[n]&&(r&&(r+=` `),r+=n)}return r}function x_(){for(var e,t,n=0,r=``,i=arguments.length;n<i;n++)(e=arguments[n])&&(t=b_(e))&&(r&&(r+=` `),r+=t);return r}var S_=e=>typeof e==`boolean`?`${e}`:e===0?`0`:e,C_=x_,w_=(e,t)=>n=>{if(t?.variants==null)return C_(e,n?.class,n?.className);let{variants:r,defaultVariants:i}=t,a=Object.keys(r).map(e=>{let t=n?.[e],a=i?.[e];if(t===null)return null;let o=S_(t)||S_(a);return r[e][o]}),o=n&&Object.entries(n).reduce((e,t)=>{let[n,r]=t;return r===void 0||(e[n]=r),e},{});return C_(e,a,t?.compoundVariants?.reduce((e,t)=>{let{class:n,className:r,...a}=t;return Object.entries(a).every(e=>{let[t,n]=e;return Array.isArray(n)?n.includes({...i,...o}[t]):{...i,...o}[t]===n})?[...e,n,r]:e},[]),n?.class,n?.className)},T_=(e,t)=>{let n=Array(e.length+t.length);for(let t=0;t<e.length;t++)n[t]=e[t];for(let r=0;r<t.length;r++)n[e.length+r]=t[r];return n},E_=(e,t)=>({classGroupId:e,validator:t}),D_=(e=new Map,t=null,n)=>({nextPart:e,validators:t,classGroupId:n}),O_=`-`,k_=[],A_=`arbitrary..`,j_=e=>{let t=P_(e),{conflictingClassGroups:n,conflictingClassGroupModifiers:r}=e;return{getClassGroupId:e=>{if(e.startsWith(`[`)&&e.endsWith(`]`))return N_(e);let n=e.split(O_);return M_(n,+(n[0]===``&&n.length>1),t)},getConflictingClassGroupIds:(e,t)=>{if(t){let t=r[e],i=n[e];return t?i?T_(i,t):t:i||k_}return n[e]||k_}}},M_=(e,t,n)=>{if(e.length-t===0)return n.classGroupId;let r=e[t],i=n.nextPart.get(r);if(i){let n=M_(e,t+1,i);if(n)return n}let a=n.validators;if(a===null)return;let o=t===0?e.join(O_):e.slice(t).join(O_),s=a.length;for(let e=0;e<s;e++){let t=a[e];if(t.validator(o))return t.classGroupId}},N_=e=>e.slice(1,-1).indexOf(`:`)===-1?void 0:(()=>{let t=e.slice(1,-1),n=t.indexOf(`:`),r=t.slice(0,n);return r?A_+r:void 0})(),P_=e=>{let{theme:t,classGroups:n}=e;return F_(n,t)},F_=(e,t)=>{let n=D_();for(let r in e){let i=e[r];I_(i,n,r,t)}return n},I_=(e,t,n,r)=>{let i=e.length;for(let a=0;a<i;a++){let i=e[a];L_(i,t,n,r)}},L_=(e,t,n,r)=>{if(typeof e==`string`){R_(e,t,n);return}if(typeof e==`function`){z_(e,t,n,r);return}B_(e,t,n,r)},R_=(e,t,n)=>{let r=e===``?t:V_(t,e);r.classGroupId=n},z_=(e,t,n,r)=>{if(H_(e)){I_(e(r),t,n,r);return}t.validators===null&&(t.validators=[]),t.validators.push(E_(n,e))},B_=(e,t,n,r)=>{let i=Object.entries(e),a=i.length;for(let e=0;e<a;e++){let[a,o]=i[e];I_(o,V_(t,a),n,r)}},V_=(e,t)=>{let n=e,r=t.split(O_),i=r.length;for(let e=0;e<i;e++){let t=r[e],i=n.nextPart.get(t);i||(i=D_(),n.nextPart.set(t,i)),n=i}return n},H_=e=>`isThemeGetter`in e&&e.isThemeGetter===!0,U_=e=>{if(e<1)return{get:()=>void 0,set:()=>{}};let t=0,n=Object.create(null),r=Object.create(null),i=(i,a)=>{n[i]=a,t++,t>e&&(t=0,r=n,n=Object.create(null))};return{get(e){let t=n[e];if(t!==void 0)return t;if((t=r[e])!==void 0)return i(e,t),t},set(e,t){e in n?n[e]=t:i(e,t)}}},W_=`!`,G_=`:`,K_=[],q_=(e,t,n,r,i)=>({modifiers:e,hasImportantModifier:t,baseClassName:n,maybePostfixModifierPosition:r,isExternal:i}),J_=e=>{let{prefix:t,experimentalParseClassName:n}=e,r=e=>{let t=[],n=0,r=0,i=0,a,o=e.length;for(let s=0;s<o;s++){let o=e[s];if(n===0&&r===0){if(o===G_){t.push(e.slice(i,s)),i=s+1;continue}if(o===`/`){a=s;continue}}o===`[`?n++:o===`]`?n--:o===`(`?r++:o===`)`&&r--}let s=t.length===0?e:e.slice(i),c=s,l=!1;s.endsWith(W_)?(c=s.slice(0,-1),l=!0):s.startsWith(W_)&&(c=s.slice(1),l=!0);let u=a&&a>i?a-i:void 0;return q_(t,l,c,u)};if(t){let e=t+G_,n=r;r=t=>t.startsWith(e)?n(t.slice(e.length)):q_(K_,!1,t,void 0,!0)}if(n){let e=r;r=t=>n({className:t,parseClassName:e})}return r},Y_=e=>{let t=new Map;return e.orderSensitiveModifiers.forEach((e,n)=>{t.set(e,1e6+n)}),e=>{let n=[],r=[];for(let i=0;i<e.length;i++){let a=e[i],o=a[0]===`[`,s=t.has(a);o||s?(r.length>0&&(r.sort(),n.push(...r),r=[]),n.push(a)):r.push(a)}return r.length>0&&(r.sort(),n.push(...r)),n}},X_=e=>({cache:U_(e.cacheSize),parseClassName:J_(e),sortModifiers:Y_(e),postfixLookupClassGroupIds:Z_(e),...j_(e)}),Z_=e=>{let t=Object.create(null),n=e.postfixLookupClassGroups;if(n)for(let e=0;e<n.length;e++)t[n[e]]=!0;return t},Q_=/\s+/,$_=(e,t)=>{let{parseClassName:n,getClassGroupId:r,getConflictingClassGroupIds:i,sortModifiers:a,postfixLookupClassGroupIds:o}=t,s=[],c=e.trim().split(Q_),l=``;for(let e=c.length-1;e>=0;--e){let t=c[e],{isExternal:u,modifiers:d,hasImportantModifier:f,baseClassName:p,maybePostfixModifierPosition:m}=n(t);if(u){l=t+(l.length>0?` `+l:l);continue}let h=!!m,g;if(h){g=r(p.substring(0,m));let e=g&&o[g]?r(p):void 0;e&&e!==g&&(g=e,h=!1)}else g=r(p);if(!g){if(!h){l=t+(l.length>0?` `+l:l);continue}if(g=r(p),!g){l=t+(l.length>0?` `+l:l);continue}h=!1}let _=d.length===0?``:d.length===1?d[0]:a(d).join(`:`),v=f?_+W_:_,y=v+g;if(s.indexOf(y)>-1)continue;s.push(y);let b=i(g,h);for(let e=0;e<b.length;++e){let t=b[e];s.push(v+t)}l=t+(l.length>0?` `+l:l)}return l},ev=(...e)=>{let t=0,n,r,i=``;for(;t<e.length;)(n=e[t++])&&(r=tv(n))&&(i&&(i+=` `),i+=r);return i},tv=e=>{if(typeof e==`string`)return e;let t,n=``;for(let r=0;r<e.length;r++)e[r]&&(t=tv(e[r]))&&(n&&(n+=` `),n+=t);return n},nv=(e,...t)=>{let n,r,i,a,o=o=>(n=X_(t.reduce((e,t)=>t(e),e())),r=n.cache.get,i=n.cache.set,a=s,s(o)),s=e=>{let t=r(e);if(t)return t;let a=$_(e,n);return i(e,a),a};return a=o,(...e)=>a(ev(...e))},rv=[],iv=e=>{let t=t=>t[e]||rv;return t.isThemeGetter=!0,t},av=/^\[(?:(\w[\w-]*):)?(.+)\]$/i,ov=/^\((?:(\w[\w-]*):)?(.+)\)$/i,sv=/^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/,cv=/^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/,lv=/\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/,uv=/^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/,dv=/^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/,fv=/^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/,pv=e=>sv.test(e),J=e=>!!e&&!Number.isNaN(Number(e)),mv=e=>!!e&&Number.isInteger(Number(e)),hv=e=>e.endsWith(`%`)&&J(e.slice(0,-1)),gv=e=>cv.test(e),_v=()=>!0,vv=e=>lv.test(e)&&!uv.test(e),yv=()=>!1,bv=e=>dv.test(e),xv=e=>fv.test(e),Sv=e=>!Y(e)&&!X(e),Cv=e=>e.startsWith(`@container`)&&(e[10]===`/`&&e[11]!==void 0||e[11]===`s`&&e[16]!==void 0&&e.startsWith(`-size/`,10)||e[11]===`n`&&e[18]!==void 0&&e.startsWith(`-normal/`,10)),wv=e=>zv(e,Uv,yv),Y=e=>av.test(e),Tv=e=>zv(e,Wv,vv),Ev=e=>zv(e,Gv,J),Dv=e=>zv(e,qv,_v),Ov=e=>zv(e,Kv,yv),kv=e=>zv(e,Vv,yv),Av=e=>zv(e,Hv,xv),jv=e=>zv(e,Jv,bv),X=e=>ov.test(e),Mv=e=>Bv(e,Wv),Nv=e=>Bv(e,Kv),Pv=e=>Bv(e,Vv),Fv=e=>Bv(e,Uv),Iv=e=>Bv(e,Hv),Lv=e=>Bv(e,Jv,!0),Rv=e=>Bv(e,qv,!0),zv=(e,t,n)=>{let r=av.exec(e);return r?r[1]?t(r[1]):n(r[2]):!1},Bv=(e,t,n=!1)=>{let r=ov.exec(e);return r?r[1]?t(r[1]):n:!1},Vv=e=>e===`position`||e===`percentage`,Hv=e=>e===`image`||e===`url`,Uv=e=>e===`length`||e===`size`||e===`bg-size`,Wv=e=>e===`length`,Gv=e=>e===`number`,Kv=e=>e===`family-name`,qv=e=>e===`number`||e===`weight`,Jv=e=>e===`shadow`,Yv=nv(()=>{let e=iv(`color`),t=iv(`font`),n=iv(`text`),r=iv(`font-weight`),i=iv(`tracking`),a=iv(`leading`),o=iv(`breakpoint`),s=iv(`container`),c=iv(`spacing`),l=iv(`radius`),u=iv(`shadow`),d=iv(`inset-shadow`),f=iv(`text-shadow`),p=iv(`drop-shadow`),m=iv(`blur`),h=iv(`perspective`),g=iv(`aspect`),_=iv(`ease`),v=iv(`animate`),y=()=>[`auto`,`avoid`,`all`,`avoid-page`,`page`,`left`,`right`,`column`],b=()=>[`center`,`top`,`bottom`,`left`,`right`,`top-left`,`left-top`,`top-right`,`right-top`,`bottom-right`,`right-bottom`,`bottom-left`,`left-bottom`],x=()=>[...b(),X,Y],S=()=>[`auto`,`hidden`,`clip`,`visible`,`scroll`],C=()=>[`auto`,`contain`,`none`],w=()=>[X,Y,c],ee=()=>[pv,`full`,`auto`,...w()],te=()=>[mv,`none`,`subgrid`,X,Y],T=()=>[`auto`,{span:[`full`,mv,X,Y]},mv,X,Y],ne=()=>[mv,`auto`,X,Y],re=()=>[`auto`,`min`,`max`,`fr`,X,Y],ie=()=>[`start`,`end`,`center`,`between`,`around`,`evenly`,`stretch`,`baseline`,`center-safe`,`end-safe`],E=()=>[`start`,`end`,`center`,`stretch`,`center-safe`,`end-safe`],ae=()=>[`auto`,...w()],oe=()=>[pv,`auto`,`full`,`dvw`,`dvh`,`lvw`,`lvh`,`svw`,`svh`,`min`,`max`,`fit`,...w()],se=()=>[pv,`screen`,`full`,`dvw`,`lvw`,`svw`,`min`,`max`,`fit`,...w()],ce=()=>[pv,`screen`,`full`,`lh`,`dvh`,`lvh`,`svh`,`min`,`max`,`fit`,...w()],D=()=>[e,X,Y],le=()=>[...b(),Pv,kv,{position:[X,Y]}],ue=()=>[`no-repeat`,{repeat:[``,`x`,`y`,`space`,`round`]}],de=()=>[`auto`,`cover`,`contain`,Fv,wv,{size:[X,Y]}],fe=()=>[hv,Mv,Tv],pe=()=>[``,`none`,`full`,l,X,Y],me=()=>[``,J,Mv,Tv],he=()=>[`solid`,`dashed`,`dotted`,`double`],ge=()=>[`normal`,`multiply`,`screen`,`overlay`,`darken`,`lighten`,`color-dodge`,`color-burn`,`hard-light`,`soft-light`,`difference`,`exclusion`,`hue`,`saturation`,`color`,`luminosity`],_e=()=>[J,hv,Pv,kv],ve=()=>[``,`none`,m,X,Y],ye=()=>[`none`,J,X,Y],be=()=>[`none`,J,X,Y],O=()=>[J,X,Y],xe=()=>[pv,`full`,...w()];return{cacheSize:500,theme:{animate:[`spin`,`ping`,`pulse`,`bounce`],aspect:[`video`],blur:[gv],breakpoint:[gv],color:[_v],container:[gv],"drop-shadow":[gv],ease:[`in`,`out`,`in-out`],font:[Sv],"font-weight":[`thin`,`extralight`,`light`,`normal`,`medium`,`semibold`,`bold`,`extrabold`,`black`],"inset-shadow":[gv],leading:[`none`,`tight`,`snug`,`normal`,`relaxed`,`loose`],perspective:[`dramatic`,`near`,`normal`,`midrange`,`distant`,`none`],radius:[gv],shadow:[gv],spacing:[`px`,J],text:[gv],"text-shadow":[gv],tracking:[`tighter`,`tight`,`normal`,`wide`,`wider`,`widest`]},classGroups:{aspect:[{aspect:[`auto`,`square`,pv,Y,X,g]}],container:[`container`],"container-type":[{"@container":[``,`normal`,`size`,X,Y]}],"container-named":[Cv],columns:[{columns:[J,Y,X,s]}],"break-after":[{"break-after":y()}],"break-before":[{"break-before":y()}],"break-inside":[{"break-inside":[`auto`,`avoid`,`avoid-page`,`avoid-column`]}],"box-decoration":[{"box-decoration":[`slice`,`clone`]}],box:[{box:[`border`,`content`]}],display:[`block`,`inline-block`,`inline`,`flex`,`inline-flex`,`table`,`inline-table`,`table-caption`,`table-cell`,`table-column`,`table-column-group`,`table-footer-group`,`table-header-group`,`table-row-group`,`table-row`,`flow-root`,`grid`,`inline-grid`,`contents`,`list-item`,`hidden`],sr:[`sr-only`,`not-sr-only`],float:[{float:[`right`,`left`,`none`,`start`,`end`]}],clear:[{clear:[`left`,`right`,`both`,`none`,`start`,`end`]}],isolation:[`isolate`,`isolation-auto`],"object-fit":[{object:[`contain`,`cover`,`fill`,`none`,`scale-down`]}],"object-position":[{object:x()}],overflow:[{overflow:S()}],"overflow-x":[{"overflow-x":S()}],"overflow-y":[{"overflow-y":S()}],overscroll:[{overscroll:C()}],"overscroll-x":[{"overscroll-x":C()}],"overscroll-y":[{"overscroll-y":C()}],position:[`static`,`fixed`,`absolute`,`relative`,`sticky`],inset:[{inset:ee()}],"inset-x":[{"inset-x":ee()}],"inset-y":[{"inset-y":ee()}],start:[{"inset-s":ee(),start:ee()}],end:[{"inset-e":ee(),end:ee()}],"inset-bs":[{"inset-bs":ee()}],"inset-be":[{"inset-be":ee()}],top:[{top:ee()}],right:[{right:ee()}],bottom:[{bottom:ee()}],left:[{left:ee()}],visibility:[`visible`,`invisible`,`collapse`],z:[{z:[mv,`auto`,X,Y]}],basis:[{basis:[pv,`full`,`auto`,s,...w()]}],"flex-direction":[{flex:[`row`,`row-reverse`,`col`,`col-reverse`]}],"flex-wrap":[{flex:[`nowrap`,`wrap`,`wrap-reverse`]}],flex:[{flex:[J,pv,`auto`,`initial`,`none`,Y]}],grow:[{grow:[``,J,X,Y]}],shrink:[{shrink:[``,J,X,Y]}],order:[{order:[mv,`first`,`last`,`none`,X,Y]}],"grid-cols":[{"grid-cols":te()}],"col-start-end":[{col:T()}],"col-start":[{"col-start":ne()}],"col-end":[{"col-end":ne()}],"grid-rows":[{"grid-rows":te()}],"row-start-end":[{row:T()}],"row-start":[{"row-start":ne()}],"row-end":[{"row-end":ne()}],"grid-flow":[{"grid-flow":[`row`,`col`,`dense`,`row-dense`,`col-dense`]}],"auto-cols":[{"auto-cols":re()}],"auto-rows":[{"auto-rows":re()}],gap:[{gap:w()}],"gap-x":[{"gap-x":w()}],"gap-y":[{"gap-y":w()}],"justify-content":[{justify:[...ie(),`normal`]}],"justify-items":[{"justify-items":[...E(),`normal`]}],"justify-self":[{"justify-self":[`auto`,...E()]}],"align-content":[{content:[`normal`,...ie()]}],"align-items":[{items:[...E(),{baseline:[``,`last`]}]}],"align-self":[{self:[`auto`,...E(),{baseline:[``,`last`]}]}],"place-content":[{"place-content":ie()}],"place-items":[{"place-items":[...E(),`baseline`]}],"place-self":[{"place-self":[`auto`,...E()]}],p:[{p:w()}],px:[{px:w()}],py:[{py:w()}],ps:[{ps:w()}],pe:[{pe:w()}],pbs:[{pbs:w()}],pbe:[{pbe:w()}],pt:[{pt:w()}],pr:[{pr:w()}],pb:[{pb:w()}],pl:[{pl:w()}],m:[{m:ae()}],mx:[{mx:ae()}],my:[{my:ae()}],ms:[{ms:ae()}],me:[{me:ae()}],mbs:[{mbs:ae()}],mbe:[{mbe:ae()}],mt:[{mt:ae()}],mr:[{mr:ae()}],mb:[{mb:ae()}],ml:[{ml:ae()}],"space-x":[{"space-x":w()}],"space-x-reverse":[`space-x-reverse`],"space-y":[{"space-y":w()}],"space-y-reverse":[`space-y-reverse`],size:[{size:oe()}],"inline-size":[{inline:[`auto`,...se()]}],"min-inline-size":[{"min-inline":[`auto`,...se()]}],"max-inline-size":[{"max-inline":[`none`,...se()]}],"block-size":[{block:[`auto`,...ce()]}],"min-block-size":[{"min-block":[`auto`,...ce()]}],"max-block-size":[{"max-block":[`none`,...ce()]}],w:[{w:[s,`screen`,...oe()]}],"min-w":[{"min-w":[s,`screen`,`none`,...oe()]}],"max-w":[{"max-w":[s,`screen`,`none`,`prose`,{screen:[o]},...oe()]}],h:[{h:[`screen`,`lh`,...oe()]}],"min-h":[{"min-h":[`screen`,`lh`,`none`,...oe()]}],"max-h":[{"max-h":[`screen`,`lh`,...oe()]}],"font-size":[{text:[`base`,n,Mv,Tv]}],"font-smoothing":[`antialiased`,`subpixel-antialiased`],"font-style":[`italic`,`not-italic`],"font-weight":[{font:[r,Rv,Dv]}],"font-stretch":[{"font-stretch":[`ultra-condensed`,`extra-condensed`,`condensed`,`semi-condensed`,`normal`,`semi-expanded`,`expanded`,`extra-expanded`,`ultra-expanded`,hv,Y]}],"font-family":[{font:[Nv,Ov,t]}],"font-features":[{"font-features":[Y]}],"fvn-normal":[`normal-nums`],"fvn-ordinal":[`ordinal`],"fvn-slashed-zero":[`slashed-zero`],"fvn-figure":[`lining-nums`,`oldstyle-nums`],"fvn-spacing":[`proportional-nums`,`tabular-nums`],"fvn-fraction":[`diagonal-fractions`,`stacked-fractions`],tracking:[{tracking:[i,X,Y]}],"line-clamp":[{"line-clamp":[J,`none`,X,Ev]}],leading:[{leading:[a,...w()]}],"list-image":[{"list-image":[`none`,X,Y]}],"list-style-position":[{list:[`inside`,`outside`]}],"list-style-type":[{list:[`disc`,`decimal`,`none`,X,Y]}],"text-alignment":[{text:[`left`,`center`,`right`,`justify`,`start`,`end`]}],"placeholder-color":[{placeholder:D()}],"text-color":[{text:D()}],"text-decoration":[`underline`,`overline`,`line-through`,`no-underline`],"text-decoration-style":[{decoration:[...he(),`wavy`]}],"text-decoration-thickness":[{decoration:[J,`from-font`,`auto`,X,Tv]}],"text-decoration-color":[{decoration:D()}],"underline-offset":[{"underline-offset":[J,`auto`,X,Y]}],"text-transform":[`uppercase`,`lowercase`,`capitalize`,`normal-case`],"text-overflow":[`truncate`,`text-ellipsis`,`text-clip`],"text-wrap":[{text:[`wrap`,`nowrap`,`balance`,`pretty`]}],indent:[{indent:w()}],"tab-size":[{tab:[mv,X,Y]}],"vertical-align":[{align:[`baseline`,`top`,`middle`,`bottom`,`text-top`,`text-bottom`,`sub`,`super`,X,Y]}],whitespace:[{whitespace:[`normal`,`nowrap`,`pre`,`pre-line`,`pre-wrap`,`break-spaces`]}],break:[{break:[`normal`,`words`,`all`,`keep`]}],wrap:[{wrap:[`break-word`,`anywhere`,`normal`]}],hyphens:[{hyphens:[`none`,`manual`,`auto`]}],content:[{content:[`none`,X,Y]}],"bg-attachment":[{bg:[`fixed`,`local`,`scroll`]}],"bg-clip":[{"bg-clip":[`border`,`padding`,`content`,`text`]}],"bg-origin":[{"bg-origin":[`border`,`padding`,`content`]}],"bg-position":[{bg:le()}],"bg-repeat":[{bg:ue()}],"bg-size":[{bg:de()}],"bg-image":[{bg:[`none`,{linear:[{to:[`t`,`tr`,`r`,`br`,`b`,`bl`,`l`,`tl`]},mv,X,Y],radial:[``,X,Y],conic:[mv,X,Y]},Iv,Av]}],"bg-color":[{bg:D()}],"gradient-from-pos":[{from:fe()}],"gradient-via-pos":[{via:fe()}],"gradient-to-pos":[{to:fe()}],"gradient-from":[{from:D()}],"gradient-via":[{via:D()}],"gradient-to":[{to:D()}],rounded:[{rounded:pe()}],"rounded-s":[{"rounded-s":pe()}],"rounded-e":[{"rounded-e":pe()}],"rounded-t":[{"rounded-t":pe()}],"rounded-r":[{"rounded-r":pe()}],"rounded-b":[{"rounded-b":pe()}],"rounded-l":[{"rounded-l":pe()}],"rounded-ss":[{"rounded-ss":pe()}],"rounded-se":[{"rounded-se":pe()}],"rounded-ee":[{"rounded-ee":pe()}],"rounded-es":[{"rounded-es":pe()}],"rounded-tl":[{"rounded-tl":pe()}],"rounded-tr":[{"rounded-tr":pe()}],"rounded-br":[{"rounded-br":pe()}],"rounded-bl":[{"rounded-bl":pe()}],"border-w":[{border:me()}],"border-w-x":[{"border-x":me()}],"border-w-y":[{"border-y":me()}],"border-w-s":[{"border-s":me()}],"border-w-e":[{"border-e":me()}],"border-w-bs":[{"border-bs":me()}],"border-w-be":[{"border-be":me()}],"border-w-t":[{"border-t":me()}],"border-w-r":[{"border-r":me()}],"border-w-b":[{"border-b":me()}],"border-w-l":[{"border-l":me()}],"divide-x":[{"divide-x":me()}],"divide-x-reverse":[`divide-x-reverse`],"divide-y":[{"divide-y":me()}],"divide-y-reverse":[`divide-y-reverse`],"border-style":[{border:[...he(),`hidden`,`none`]}],"divide-style":[{divide:[...he(),`hidden`,`none`]}],"border-color":[{border:D()}],"border-color-x":[{"border-x":D()}],"border-color-y":[{"border-y":D()}],"border-color-s":[{"border-s":D()}],"border-color-e":[{"border-e":D()}],"border-color-bs":[{"border-bs":D()}],"border-color-be":[{"border-be":D()}],"border-color-t":[{"border-t":D()}],"border-color-r":[{"border-r":D()}],"border-color-b":[{"border-b":D()}],"border-color-l":[{"border-l":D()}],"divide-color":[{divide:D()}],"outline-style":[{outline:[...he(),`none`,`hidden`]}],"outline-offset":[{"outline-offset":[J,X,Y]}],"outline-w":[{outline:[``,J,Mv,Tv]}],"outline-color":[{outline:D()}],shadow:[{shadow:[``,`none`,u,Lv,jv]}],"shadow-color":[{shadow:D()}],"inset-shadow":[{"inset-shadow":[`none`,d,Lv,jv]}],"inset-shadow-color":[{"inset-shadow":D()}],"ring-w":[{ring:me()}],"ring-w-inset":[`ring-inset`],"ring-color":[{ring:D()}],"ring-offset-w":[{"ring-offset":[J,Tv]}],"ring-offset-color":[{"ring-offset":D()}],"inset-ring-w":[{"inset-ring":me()}],"inset-ring-color":[{"inset-ring":D()}],"text-shadow":[{"text-shadow":[`none`,f,Lv,jv]}],"text-shadow-color":[{"text-shadow":D()}],opacity:[{opacity:[J,X,Y]}],"mix-blend":[{"mix-blend":[...ge(),`plus-darker`,`plus-lighter`]}],"bg-blend":[{"bg-blend":ge()}],"mask-clip":[{"mask-clip":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]},`mask-no-clip`],"mask-composite":[{mask:[`add`,`subtract`,`intersect`,`exclude`]}],"mask-image-linear-pos":[{"mask-linear":[J]}],"mask-image-linear-from-pos":[{"mask-linear-from":_e()}],"mask-image-linear-to-pos":[{"mask-linear-to":_e()}],"mask-image-linear-from-color":[{"mask-linear-from":D()}],"mask-image-linear-to-color":[{"mask-linear-to":D()}],"mask-image-t-from-pos":[{"mask-t-from":_e()}],"mask-image-t-to-pos":[{"mask-t-to":_e()}],"mask-image-t-from-color":[{"mask-t-from":D()}],"mask-image-t-to-color":[{"mask-t-to":D()}],"mask-image-r-from-pos":[{"mask-r-from":_e()}],"mask-image-r-to-pos":[{"mask-r-to":_e()}],"mask-image-r-from-color":[{"mask-r-from":D()}],"mask-image-r-to-color":[{"mask-r-to":D()}],"mask-image-b-from-pos":[{"mask-b-from":_e()}],"mask-image-b-to-pos":[{"mask-b-to":_e()}],"mask-image-b-from-color":[{"mask-b-from":D()}],"mask-image-b-to-color":[{"mask-b-to":D()}],"mask-image-l-from-pos":[{"mask-l-from":_e()}],"mask-image-l-to-pos":[{"mask-l-to":_e()}],"mask-image-l-from-color":[{"mask-l-from":D()}],"mask-image-l-to-color":[{"mask-l-to":D()}],"mask-image-x-from-pos":[{"mask-x-from":_e()}],"mask-image-x-to-pos":[{"mask-x-to":_e()}],"mask-image-x-from-color":[{"mask-x-from":D()}],"mask-image-x-to-color":[{"mask-x-to":D()}],"mask-image-y-from-pos":[{"mask-y-from":_e()}],"mask-image-y-to-pos":[{"mask-y-to":_e()}],"mask-image-y-from-color":[{"mask-y-from":D()}],"mask-image-y-to-color":[{"mask-y-to":D()}],"mask-image-radial":[{"mask-radial":[X,Y]}],"mask-image-radial-from-pos":[{"mask-radial-from":_e()}],"mask-image-radial-to-pos":[{"mask-radial-to":_e()}],"mask-image-radial-from-color":[{"mask-radial-from":D()}],"mask-image-radial-to-color":[{"mask-radial-to":D()}],"mask-image-radial-shape":[{"mask-radial":[`circle`,`ellipse`]}],"mask-image-radial-size":[{"mask-radial":[{closest:[`side`,`corner`],farthest:[`side`,`corner`]}]}],"mask-image-radial-pos":[{"mask-radial-at":b()}],"mask-image-conic-pos":[{"mask-conic":[J]}],"mask-image-conic-from-pos":[{"mask-conic-from":_e()}],"mask-image-conic-to-pos":[{"mask-conic-to":_e()}],"mask-image-conic-from-color":[{"mask-conic-from":D()}],"mask-image-conic-to-color":[{"mask-conic-to":D()}],"mask-mode":[{mask:[`alpha`,`luminance`,`match`]}],"mask-origin":[{"mask-origin":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]}],"mask-position":[{mask:le()}],"mask-repeat":[{mask:ue()}],"mask-size":[{mask:de()}],"mask-type":[{"mask-type":[`alpha`,`luminance`]}],"mask-image":[{mask:[`none`,X,Y]}],filter:[{filter:[``,`none`,X,Y]}],blur:[{blur:ve()}],brightness:[{brightness:[J,X,Y]}],contrast:[{contrast:[J,X,Y]}],"drop-shadow":[{"drop-shadow":[``,`none`,p,Lv,jv]}],"drop-shadow-color":[{"drop-shadow":D()}],grayscale:[{grayscale:[``,J,X,Y]}],"hue-rotate":[{"hue-rotate":[J,X,Y]}],invert:[{invert:[``,J,X,Y]}],saturate:[{saturate:[J,X,Y]}],sepia:[{sepia:[``,J,X,Y]}],"backdrop-filter":[{"backdrop-filter":[``,`none`,X,Y]}],"backdrop-blur":[{"backdrop-blur":ve()}],"backdrop-brightness":[{"backdrop-brightness":[J,X,Y]}],"backdrop-contrast":[{"backdrop-contrast":[J,X,Y]}],"backdrop-grayscale":[{"backdrop-grayscale":[``,J,X,Y]}],"backdrop-hue-rotate":[{"backdrop-hue-rotate":[J,X,Y]}],"backdrop-invert":[{"backdrop-invert":[``,J,X,Y]}],"backdrop-opacity":[{"backdrop-opacity":[J,X,Y]}],"backdrop-saturate":[{"backdrop-saturate":[J,X,Y]}],"backdrop-sepia":[{"backdrop-sepia":[``,J,X,Y]}],"border-collapse":[{border:[`collapse`,`separate`]}],"border-spacing":[{"border-spacing":w()}],"border-spacing-x":[{"border-spacing-x":w()}],"border-spacing-y":[{"border-spacing-y":w()}],"table-layout":[{table:[`auto`,`fixed`]}],caption:[{caption:[`top`,`bottom`]}],transition:[{transition:[``,`all`,`colors`,`opacity`,`shadow`,`transform`,`none`,X,Y]}],"transition-behavior":[{transition:[`normal`,`discrete`]}],duration:[{duration:[J,`initial`,X,Y]}],ease:[{ease:[`linear`,`initial`,_,X,Y]}],delay:[{delay:[J,X,Y]}],animate:[{animate:[`none`,v,X,Y]}],backface:[{backface:[`hidden`,`visible`]}],perspective:[{perspective:[h,X,Y]}],"perspective-origin":[{"perspective-origin":x()}],rotate:[{rotate:ye()}],"rotate-x":[{"rotate-x":ye()}],"rotate-y":[{"rotate-y":ye()}],"rotate-z":[{"rotate-z":ye()}],scale:[{scale:be()}],"scale-x":[{"scale-x":be()}],"scale-y":[{"scale-y":be()}],"scale-z":[{"scale-z":be()}],"scale-3d":[`scale-3d`],skew:[{skew:O()}],"skew-x":[{"skew-x":O()}],"skew-y":[{"skew-y":O()}],transform:[{transform:[X,Y,``,`none`,`gpu`,`cpu`]}],"transform-origin":[{origin:x()}],"transform-style":[{transform:[`3d`,`flat`]}],translate:[{translate:xe()}],"translate-x":[{"translate-x":xe()}],"translate-y":[{"translate-y":xe()}],"translate-z":[{"translate-z":xe()}],"translate-none":[`translate-none`],zoom:[{zoom:[mv,X,Y]}],accent:[{accent:D()}],appearance:[{appearance:[`none`,`auto`]}],"caret-color":[{caret:D()}],"color-scheme":[{scheme:[`normal`,`dark`,`light`,`light-dark`,`only-dark`,`only-light`]}],cursor:[{cursor:[`auto`,`default`,`pointer`,`wait`,`text`,`move`,`help`,`not-allowed`,`none`,`context-menu`,`progress`,`cell`,`crosshair`,`vertical-text`,`alias`,`copy`,`no-drop`,`grab`,`grabbing`,`all-scroll`,`col-resize`,`row-resize`,`n-resize`,`e-resize`,`s-resize`,`w-resize`,`ne-resize`,`nw-resize`,`se-resize`,`sw-resize`,`ew-resize`,`ns-resize`,`nesw-resize`,`nwse-resize`,`zoom-in`,`zoom-out`,X,Y]}],"field-sizing":[{"field-sizing":[`fixed`,`content`]}],"pointer-events":[{"pointer-events":[`auto`,`none`]}],resize:[{resize:[`none`,``,`y`,`x`]}],"scroll-behavior":[{scroll:[`auto`,`smooth`]}],"scrollbar-thumb-color":[{"scrollbar-thumb":D()}],"scrollbar-track-color":[{"scrollbar-track":D()}],"scrollbar-gutter":[{"scrollbar-gutter":[`auto`,`stable`,`both`]}],"scrollbar-w":[{scrollbar:[`auto`,`thin`,`none`]}],"scroll-m":[{"scroll-m":w()}],"scroll-mx":[{"scroll-mx":w()}],"scroll-my":[{"scroll-my":w()}],"scroll-ms":[{"scroll-ms":w()}],"scroll-me":[{"scroll-me":w()}],"scroll-mbs":[{"scroll-mbs":w()}],"scroll-mbe":[{"scroll-mbe":w()}],"scroll-mt":[{"scroll-mt":w()}],"scroll-mr":[{"scroll-mr":w()}],"scroll-mb":[{"scroll-mb":w()}],"scroll-ml":[{"scroll-ml":w()}],"scroll-p":[{"scroll-p":w()}],"scroll-px":[{"scroll-px":w()}],"scroll-py":[{"scroll-py":w()}],"scroll-ps":[{"scroll-ps":w()}],"scroll-pe":[{"scroll-pe":w()}],"scroll-pbs":[{"scroll-pbs":w()}],"scroll-pbe":[{"scroll-pbe":w()}],"scroll-pt":[{"scroll-pt":w()}],"scroll-pr":[{"scroll-pr":w()}],"scroll-pb":[{"scroll-pb":w()}],"scroll-pl":[{"scroll-pl":w()}],"snap-align":[{snap:[`start`,`end`,`center`,`align-none`]}],"snap-stop":[{snap:[`normal`,`always`]}],"snap-type":[{snap:[`none`,`x`,`y`,`both`]}],"snap-strictness":[{snap:[`mandatory`,`proximity`]}],touch:[{touch:[`auto`,`none`,`manipulation`]}],"touch-x":[{"touch-pan":[`x`,`left`,`right`]}],"touch-y":[{"touch-pan":[`y`,`up`,`down`]}],"touch-pz":[`touch-pinch-zoom`],select:[{select:[`none`,`text`,`all`,`auto`]}],"will-change":[{"will-change":[`auto`,`scroll`,`contents`,`transform`,X,Y]}],fill:[{fill:[`none`,...D()]}],"stroke-w":[{stroke:[J,Mv,Tv,Ev]}],stroke:[{stroke:[`none`,...D()]}],"forced-color-adjust":[{"forced-color-adjust":[`auto`,`none`]}]},conflictingClassGroups:{"container-named":[`container-type`],overflow:[`overflow-x`,`overflow-y`],overscroll:[`overscroll-x`,`overscroll-y`],inset:[`inset-x`,`inset-y`,`inset-bs`,`inset-be`,`start`,`end`,`top`,`right`,`bottom`,`left`],"inset-x":[`right`,`left`],"inset-y":[`top`,`bottom`],flex:[`basis`,`grow`,`shrink`],gap:[`gap-x`,`gap-y`],p:[`px`,`py`,`ps`,`pe`,`pbs`,`pbe`,`pt`,`pr`,`pb`,`pl`],px:[`pr`,`pl`],py:[`pt`,`pb`],m:[`mx`,`my`,`ms`,`me`,`mbs`,`mbe`,`mt`,`mr`,`mb`,`ml`],mx:[`mr`,`ml`],my:[`mt`,`mb`],size:[`w`,`h`],"font-size":[`leading`],"fvn-normal":[`fvn-ordinal`,`fvn-slashed-zero`,`fvn-figure`,`fvn-spacing`,`fvn-fraction`],"fvn-ordinal":[`fvn-normal`],"fvn-slashed-zero":[`fvn-normal`],"fvn-figure":[`fvn-normal`],"fvn-spacing":[`fvn-normal`],"fvn-fraction":[`fvn-normal`],"line-clamp":[`display`,`overflow`],rounded:[`rounded-s`,`rounded-e`,`rounded-t`,`rounded-r`,`rounded-b`,`rounded-l`,`rounded-ss`,`rounded-se`,`rounded-ee`,`rounded-es`,`rounded-tl`,`rounded-tr`,`rounded-br`,`rounded-bl`],"rounded-s":[`rounded-ss`,`rounded-es`],"rounded-e":[`rounded-se`,`rounded-ee`],"rounded-t":[`rounded-tl`,`rounded-tr`],"rounded-r":[`rounded-tr`,`rounded-br`],"rounded-b":[`rounded-br`,`rounded-bl`],"rounded-l":[`rounded-tl`,`rounded-bl`],"border-spacing":[`border-spacing-x`,`border-spacing-y`],"border-w":[`border-w-x`,`border-w-y`,`border-w-s`,`border-w-e`,`border-w-bs`,`border-w-be`,`border-w-t`,`border-w-r`,`border-w-b`,`border-w-l`],"border-w-x":[`border-w-r`,`border-w-l`],"border-w-y":[`border-w-t`,`border-w-b`],"border-color":[`border-color-x`,`border-color-y`,`border-color-s`,`border-color-e`,`border-color-bs`,`border-color-be`,`border-color-t`,`border-color-r`,`border-color-b`,`border-color-l`],"border-color-x":[`border-color-r`,`border-color-l`],"border-color-y":[`border-color-t`,`border-color-b`],translate:[`translate-x`,`translate-y`,`translate-none`],"translate-none":[`translate`,`translate-x`,`translate-y`,`translate-z`],"scroll-m":[`scroll-mx`,`scroll-my`,`scroll-ms`,`scroll-me`,`scroll-mbs`,`scroll-mbe`,`scroll-mt`,`scroll-mr`,`scroll-mb`,`scroll-ml`],"scroll-mx":[`scroll-mr`,`scroll-ml`],"scroll-my":[`scroll-mt`,`scroll-mb`],"scroll-p":[`scroll-px`,`scroll-py`,`scroll-ps`,`scroll-pe`,`scroll-pbs`,`scroll-pbe`,`scroll-pt`,`scroll-pr`,`scroll-pb`,`scroll-pl`],"scroll-px":[`scroll-pr`,`scroll-pl`],"scroll-py":[`scroll-pt`,`scroll-pb`],touch:[`touch-x`,`touch-y`,`touch-pz`],"touch-x":[`touch`],"touch-y":[`touch`],"touch-pz":[`touch`]},conflictingClassGroupModifiers:{"font-size":[`leading`]},postfixLookupClassGroups:[`container-type`],orderSensitiveModifiers:[`*`,`**`,`after`,`backdrop`,`before`,`details-content`,`file`,`first-letter`,`first-line`,`marker`,`placeholder`,`selection`]}});function Z(...e){return Yv(x_(e))}var Xv=F({__name:`Alert`,props:{class:{type:[Boolean,null,String,Object,Array]},variant:{}},setup(e){let t=e;return(n,r)=>(R(),z(`div`,{"data-slot":`alert`,class:O(N(Z)(N($v)({variant:e.variant}),t.class)),role:`alert`},[I(n.$slots,`default`)],2))}}),Zv=F({__name:`AlertDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`alert-description`,class:O(N(Z)(`text-muted-foreground text-sm text-balance md:text-pretty [&_p:not(:last-child)]:mb-4 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[I(e.$slots,`default`)],2))}}),Qv=F({__name:`AlertTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`alert-title`,class:O(N(Z)(`font-medium group-has-[>svg]/alert:col-start-2 cn-font-heading [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[I(e.$slots,`default`)],2))}}),$v=w_(`grid gap-0.5 rounded-lg border px-2.5 py-2 text-left text-sm has-data-[slot=alert-action]:relative has-data-[slot=alert-action]:pr-18 has-[>svg]:grid-cols-[auto_1fr] has-[>svg]:gap-x-2 *:[svg]:row-span-2 *:[svg]:translate-y-0.5 *:[svg]:text-current *:[svg:not([class*=size-])]:size-4 group/alert relative w-full`,{variants:{variant:{default:`bg-card text-card-foreground`,destructive:`text-destructive bg-card *:data-[slot=alert-description]:text-destructive/90 *:[svg]:text-current`}},defaultVariants:{variant:`default`}});function ey(e){return typeof e==`string`?`'${e}'`:new iy().serialize(e)}var ty=` _-,;:!?.'"()[]{}@*/\\&#%\`^+<=>|~$0123456789abcdefghijklmnopqrstuvwxyz`,ny=(function(){let e=new Uint8Array(128);for(let t=0;t<69;t++)e[ty.charCodeAt(t)]=t+1;for(let t=65;t<=90;t++)e[t]=e[t+32];return e})();function ry(e,t){if(e===t)return 0;let n=Math.min(e.length,t.length),r=0;for(let i=0;i<n;i++){let n=e.charCodeAt(i),a=t.charCodeAt(i);if(n===a)continue;let o=n<128&&ny[n]?ny[n]:n+128,s=a<128&&ny[a]?ny[a]:a+128;if(o!==s)return o<s?-1:1;r===0&&(r=n>a?-1:1)}return e.length===t.length?r:e.length<t.length?-1:1}var iy=(function(){class e{#e=new Map;compare(e,t){let n=typeof e,r=typeof t;return n===`string`&&r===`string`?ry(e,t):n===`number`&&r===`number`?e-t:ry(this.serialize(e,!0),this.serialize(t,!0))}serialize(e,t){if(e===null)return`null`;switch(typeof e){case`string`:return t?e:`'${e}'`;case`bigint`:return`${e}n`;case`object`:return this.$object(e);case`function`:return this.$function(e)}return String(e)}serializeObject(e){let t=Object.prototype.toString.call(e);if(t!==`[object Object]`)return this.serializeBuiltInType(t.length<10?`unknown:${t}`:t.slice(8,-1),e);let n=e.constructor,r=n===Object||n===void 0?``:n.name;if(r!==``&&globalThis[r]===n)return this.serializeBuiltInType(r,e);if(`toJSON`in e&&typeof e.toJSON==`function`){let t=e.toJSON();return r+(typeof t==`object`&&t?this.$object(t):`(${this.serialize(t)})`)}let i=Object.keys(e).sort(ry),a=`${r}{`;for(let t=0;t<i.length;t++){let n=i[t];a+=`${n}:${this.serialize(e[n])}`,t<i.length-1&&(a+=`,`)}return a+`}`}serializeBuiltInType(e,t){let n=this[`$`+e];if(n)return n.call(this,t);if(typeof t.entries==`function`)return this.serializeObjectEntries(e,t.entries());throw Error(`Cannot serialize ${e}`)}serializeObjectEntries(e,t){let n=Array.from(t).sort((e,t)=>this.compare(e[0],t[0])),r=`${e}{`;for(let e=0;e<n.length;e++){let[t,i]=n[e];r+=`${this.serialize(t,!0)}:${this.serialize(i)}`,e<n.length-1&&(r+=`,`)}return r+`}`}$object(e){let t=this.#e.get(e);return t===void 0&&(this.#e.set(e,`#${this.#e.size}`),t=this.serializeObject(e),this.#e.set(e,t)),t}$function(e){let t=Function.prototype.toString.call(e);return t.slice(-15)===`[native code] }`?`${e.name||``}()[native]`:`${e.name}(${e.length})${t.replace(/\s*\n\s*/g,``)}`}$Array(e){let t=`[`;for(let n=0;n<e.length;n++)t+=this.serialize(e[n]),n<e.length-1&&(t+=`,`);return t+`]`}$Date(e){try{return`Date(${e.toISOString()})`}catch{return`Date(null)`}}$ArrayBuffer(e){return`ArrayBuffer[${new Uint8Array(e).join(`,`)}]`}$Set(e){return`Set${this.$Array(Array.from(e).sort((e,t)=>this.compare(e,t)))}`}$Map(e){return this.serializeObjectEntries(`Map`,e.entries())}}for(let t of[`Error`,`RegExp`,`URL`])e.prototype[`$`+t]=function(e){return`${t}(${e})`};for(let t of[`Int8Array`,`Uint8Array`,`Uint8ClampedArray`,`Int16Array`,`Uint16Array`,`Int32Array`,`Uint32Array`,`Float32Array`,`Float64Array`])e.prototype[`$`+t]=function(e){return`${t}[${e.join(`,`)}]`};for(let t of[`BigInt64Array`,`BigUint64Array`])e.prototype[`$`+t]=function(e){return`${t}[${e.join(`n,`)}${e.length>0?`n`:``}]`};return e})();function ay(e,t){return e===t||ey(e)===ey(t)}function oy(e,t){let n=typeof e==`string`&&!t?`${e}Context`:t,r=Symbol(n);return[t=>{let n=yr(r,t);if(n||n===null)return n;throw Error(`Injection \`${r.toString()}\` not found. Component must be used within ${Array.isArray(e)?`one of the following components: ${e.join(`, `)}`:`\`${e}\``}`)},e=>(vr(r,e),e)]}function sy(){let e=document.activeElement;if(e==null)return null;for(;e!=null&&e.shadowRoot!=null&&e.shadowRoot.activeElement!=null;)e=e.shadowRoot.activeElement;return e}function cy(e){return e==null}function ly(e,t){return cy(e)?!1:Array.isArray(e)?e.some(e=>ay(e,t)):ay(e,t)}function uy(e,t){return Fe()?(Ie(e,t),!0):!1}function dy(e){let t=!1,n,r=Pe(!0);return((...i)=>(t||=(n=r.run(()=>e(...i)),!0),n))}var fy=typeof window<`u`&&typeof document<`u`;typeof WorkerGlobalScope<`u`&&globalThis instanceof WorkerGlobalScope;var py=e=>e!==void 0,my=Object.prototype.toString,hy=e=>my.call(e)===`[object Object]`,gy=_y();function _y(){var e,t;return fy&&!!((e=window)!=null&&(e=e.navigator)!=null&&e.userAgent)&&(/iP(?:ad|hone|od)/.test(window.navigator.userAgent)||((t=window)==null||(t=t.navigator)==null?void 0:t.maxTouchPoints)>2&&/iPad|Macintosh/.test(window?.navigator.userAgent))}function vy(e){return Array.isArray(e)?e:[e]}function yy(e){return e||Fs()}function by(e){if(!fy)return e;let t=0,n,r,i=()=>{--t,r&&t<=0&&(r.stop(),n=void 0,r=void 0)};return((...a)=>(t+=1,r||(r=Pe(!0),n=r.run(()=>e(...a))),uy(i),n))}function xy(e){return Zt(j(e)?new Proxy({},{get(t,n,r){return N(Reflect.get(e.value,n,r))},set(t,n,r){return j(e.value[n])&&!j(r)?e.value[n].value=r:e.value[n]=r,!0},deleteProperty(t,n){return Reflect.deleteProperty(e.value,n)},has(t,n){return Reflect.has(e.value,n)},ownKeys(){return Object.keys(e.value)},getOwnPropertyDescriptor(){return{enumerable:!0,configurable:!0}}}):e)}function Sy(e){return xy(W(e))}function Cy(e,...t){let n=t.flat(),r=n[0];return Sy(()=>Object.fromEntries(typeof r==`function`?Object.entries(yn(e)).filter(([e,t])=>!r(mn(t),e)):Object.entries(yn(e)).filter(e=>!n.includes(e[0]))))}function wy(e,t=1e4){return vn((n,r)=>{let i=mn(e),a,o=()=>setTimeout(()=>{i=mn(e),r()},mn(t));return uy(()=>{clearTimeout(a)}),{get(){return n(),i},set(e){i=e,r(),clearTimeout(a),a=o()}}})}function Ty(e,t){yy(t)&&ea(e,t)}function Ey(e,t,n){return Er(e,t,{...n,immediate:!0})}var Dy=fy?window:void 0;fy&&window.document,fy&&window.navigator,fy&&window.location;function Oy(e){let t=mn(e);return t?.$el??t}function ky(...e){let t=(e,t,n,r)=>(e.addEventListener(t,n,r),()=>e.removeEventListener(t,n,r)),n=W(()=>{let t=vy(mn(e[0])).filter(e=>e!=null);return t.every(e=>typeof e!=`string`)?t:void 0});return Ey(()=>[n.value?.map(e=>Oy(e))??[Dy].filter(e=>e!=null),vy(mn(n.value?e[1]:e[0])),vy(N(n.value?e[2]:e[1])),mn(n.value?e[3]:e[2])],([e,n,r,i],a,o)=>{if(!e?.length||!n?.length||!r?.length)return;let s=hy(i)?{...i}:i,c=e.flatMap(e=>n.flatMap(n=>r.map(r=>t(e,n,r,s))));o(()=>{c.forEach(e=>e())})},{flush:`post`})}function Ay(){let e=un(!1),t=Fs();return t&&Zi(()=>{e.value=!0},t),e}function jy(e){let t=Ay();return W(()=>(t.value,!!e()))}function My(e){return typeof e==`function`?e:typeof e==`string`?t=>t.key===e:Array.isArray(e)?t=>e.includes(t.key):()=>!0}function Ny(...e){let t,n,r={};e.length===3?(t=e[0],n=e[1],r=e[2]):e.length===2?typeof e[1]==`object`?(t=!0,n=e[0],r=e[1]):(t=e[0],n=e[1]):(t=!0,n=e[0]);let{target:i=Dy,eventName:a=`keydown`,passive:o=!1,dedupe:s=!1}=r,c=My(t);return ky(i,a,e=>{e.repeat&&mn(s)||c(e)&&n(e)},o)}function Py(e){return JSON.parse(JSON.stringify(e))}function Fy(e,t,n={}){let{window:r=Dy,...i}=n,a,o=jy(()=>r&&`ResizeObserver`in r),s=()=>{a&&=(a.disconnect(),void 0)},c=Er(W(()=>{let t=mn(e);return Array.isArray(t)?t.map(e=>Oy(e)):[Oy(t)]}),e=>{if(s(),o.value&&r){a=new ResizeObserver(t);for(let t of e)t&&a.observe(t,i)}},{immediate:!0,flush:`post`}),l=()=>{s(),c()};return uy(l),{isSupported:o,stop:l}}function Iy(e,t,n,r={}){var i,a;let{clone:o=!1,passive:s=!1,eventName:c,deep:l=!1,defaultValue:u,shouldEmit:d}=r,f=Fs(),p=n||f?.emit||(f==null||(i=f.$emit)==null?void 0:i.bind(f))||(f==null||(a=f.proxy)==null||(a=a.$emit)==null?void 0:a.bind(f?.proxy)),m=c;t||=`modelValue`,m||=`update:${t.toString()}`;let h=e=>o?typeof o==`function`?o(e):Py(e):e,g=()=>py(e[t])?h(e[t]):u,_=e=>{d?d(e)&&p(m,e):p(m,e)};if(s){let n=M(g()),r=!1;return Er(()=>e[t],e=>{r||(r=!0,n.value=h(e),Qn(()=>r=!1))}),Er(n,n=>{!r&&(n!==e[t]||l)&&_(n)},{deep:l}),n}return W({get(){return g()},set(e){_(e)}})}function Ly(e){return e?e.flatMap(e=>e.type===L?Ly(e.children):[e]):[]}var Ry=[`INPUT`,`TEXTAREA`];function zy(e,t,n,r={}){if(!t||r.enableIgnoredElement&&Ry.includes(t.nodeName))return null;let{arrowKeyOptions:i=`both`,attributeName:a=`[data-reka-collection-item]`,itemsArray:o=[],loop:s=!0,dir:c=`ltr`,preventScroll:l=!0,focus:u=!1}=r,[d,f,p,m,h,g]=[e.key===`ArrowRight`,e.key===`ArrowLeft`,e.key===`ArrowUp`,e.key===`ArrowDown`,e.key===`Home`,e.key===`End`],_=p||m,v=d||f;if(!h&&!g&&(!_&&!v||i===`vertical`&&v||i===`horizontal`&&_))return null;let y=n?Array.from(n.querySelectorAll(a)):o;if(!y.length)return null;l&&e.preventDefault();let b=null;return v||_?b=By(y,t,{goForward:_?m:c===`ltr`?d:f,loop:s}):h?b=y.at(0)||null:g&&(b=y.at(-1)||null),u&&b?.focus(),b}function By(e,t,n,r=e.includes(t)?e.length:e.length+1){if(--r===0)return null;let i=e.indexOf(t),a;if(a=i===-1?n.goForward?0:e.length-1:n.goForward?i+1:i-1,!n.loop&&(a<0||a>=e.length))return null;let o=e[(a+e.length)%e.length];return o?o.hasAttribute(`disabled`)&&o.getAttribute(`disabled`)!==`false`?By(e,o,n,r):o:null}var[Vy,Hy]=oy(`ConfigProvider`);function Uy(e){let t=Vy({dir:M(`ltr`)});return W(()=>e?.value||t.dir?.value||`ltr`)}function Wy(e){let t=Fs(),n=t?.type.emits,r={};return n?.length||console.warn(`No emitted event found. Please check component: ${t?.type.__name}`),n?.forEach(t=>{r[ce(E(t))]=(...n)=>e(t,...n)}),r}function Gy(){let e=Fs(),t=M(),n=W(()=>r());$i(()=>{n.value!==r()&&pn(t)});function r(){return t.value&&`$el`in t.value&&[`#text`,`#comment`].includes(t.value.$el.nodeName)?t.value.$el.nextElementSibling:Oy(t)}let i=Object.assign({},e.exposed),a={};for(let t in e.props)Object.defineProperty(a,t,{enumerable:!0,configurable:!0,get:()=>e.props[t]});if(Object.keys(i).length>0)for(let e in i)Object.defineProperty(a,e,{enumerable:!0,configurable:!0,get:()=>i[e]});Object.defineProperty(a,"$el",{enumerable:!0,configurable:!0,get:()=>e.vnode.el}),e.exposed=a;function o(n){if(t.value=n,n&&(Object.defineProperty(a,"$el",{enumerable:!0,configurable:!0,get:()=>n instanceof Element?n:n.$el}),!(n instanceof Element)&&!Object.hasOwn(n,`$el`))){let t=n.$.exposed,r=Object.assign({},a);for(let e in t)Object.defineProperty(r,e,{enumerable:!0,configurable:!0,get:()=>t[e]});e.exposed=r}}return{forwardRef:o,currentRef:t,currentElement:n}}function Ky(e){let t=Fs(),n=Object.keys(t?.type.props??{}).reduce((e,n)=>{let r=(t?.type.props[n]).default;return r!==void 0&&(e[n]=r),e},{}),r=Sn(e);return W(()=>{let e={},i=t?.vnode.props??{};return Object.keys(i).forEach(t=>{e[E(t)]=i[t]}),Object.keys({...n,...e}).reduce((e,t)=>(r.value[t]!==void 0&&(e[t]=r.value[t]),e),{})})}function qy(e,t){let n=Ky(e),r=t?Wy(t):{};return W(()=>({...n.value,...r}))}var Jy=0;function Yy(e,t=`reka`){if(e)return e;let n,r=Vy({useId:void 0});return n=r.useId?r.useId():`useId`in xu?ai?.():`${++Jy}`,t?`${t}-${n}`:n}function Xy(e,t){let n=M(e);function r(e){return t[n.value][e]??n.value}return{state:n,dispatch:e=>{n.value=r(e)}}}function Zy(e,t){let n=M({}),r=M(`none`),i=M(e),a=e.value?`mounted`:`unmounted`,o,s=t.value?.ownerDocument.defaultView??Dy,{state:c,dispatch:l}=Xy(a,{mounted:{UNMOUNT:`unmounted`,ANIMATION_OUT:`unmountSuspended`},unmountSuspended:{MOUNT:`mounted`,ANIMATION_END:`unmounted`},unmounted:{MOUNT:`mounted`}}),u=e=>{if(fy){let n=new CustomEvent(e,{bubbles:!1,cancelable:!1});t.value?.dispatchEvent(n)}};Er(e,async(e,i)=>{let a=i!==e;if(await Qn(),a){let a=r.value,o=Qy(t.value);e?(l(`MOUNT`),u(`enter`),o===`none`&&u(`after-enter`)):o===`none`||o===`undefined`||n.value?.display===`none`?(l(`UNMOUNT`),u(`leave`),u(`after-leave`)):i&&a!==o?(l(`ANIMATION_OUT`),u(`leave`)):(l(`UNMOUNT`),u(`after-leave`))}},{immediate:!0});let d=e=>{if(e.target!==t.value)return;let n=Qy(t.value),r=n.includes(CSS.escape(e.animationName)),a=c.value===`mounted`?`enter`:`leave`;if(r&&(u(`after-${a}`),l(`ANIMATION_END`),!i.value)){let e=t.value.style.animationFillMode;t.value.style.animationFillMode=`forwards`,o=s?.setTimeout(()=>{t.value?.style.animationFillMode===`forwards`&&(t.value.style.animationFillMode=e)})}n===`none`&&l(`ANIMATION_END`)},f=e=>{e.target===t.value&&(r.value=Qy(t.value))},p=Er(t,(e,t)=>{e?(n.value=getComputedStyle(e),e.addEventListener(`animationstart`,f),e.addEventListener(`animationcancel`,d),e.addEventListener(`animationend`,d)):(l(`ANIMATION_END`),o!==void 0&&s?.clearTimeout(o),t?.removeEventListener(`animationstart`,f),t?.removeEventListener(`animationcancel`,d),t?.removeEventListener(`animationend`,d))},{immediate:!0}),m=Er(c,()=>{let e=Qy(t.value);r.value=c.value===`mounted`?e:`none`});return ta(()=>{p(),m(),t.value&&(t.value.removeEventListener(`animationstart`,f),t.value.removeEventListener(`animationcancel`,d),t.value.removeEventListener(`animationend`,d)),o!==void 0&&s?.clearTimeout(o)}),{isPresent:W(()=>[`mounted`,`unmountSuspended`].includes(c.value))}}function Qy(e){return e&&getComputedStyle(e).animationName||`none`}var $y=F({name:`Presence`,props:{present:{type:Boolean,required:!0},forceMount:{type:Boolean}},slots:{},setup(e,{slots:t,expose:n}){let{present:r,forceMount:i}=yn(e),a=M(),{isPresent:o}=Zy(r,a);n({present:o});let s=t.default({present:o.value});s=Ly(s||[]);let c=Fs();if(s&&s?.length>1){let e=c?.parent?.type.name?`<${c.parent.type.name} />`:`component`;throw Error([`Detected an invalid children for \`${e}\` for  \`Presence\` component.`,``,"Note: Presence works similarly to `v-if` directly, but it waits for animation/transition to finished before unmounting. So it expect only one direct child of valid VNode type.",`You can apply a few solutions:`,["Provide a single child element so that `presence` directive attach correctly.",`Ensure the first child is an actual element instead of a raw text node or comment node.`].map(e=>`  - ${e}`).join(`
`)].join(`
`))}return()=>i.value||r.value||o.value?tc(t.default({present:o.value})[0],{ref:e=>{let t=Oy(e);return t?.hasAttribute===void 0||(t?.hasAttribute(`data-reka-popper-content-wrapper`)?a.value=t.firstElementChild:a.value=t),t}}):null}}),eb=F({name:`PrimitiveSlot`,inheritAttrs:!1,setup(e,{attrs:t,slots:n}){return()=>{if(!n.default)return null;let e=Ly(n.default()),r=e.findIndex(e=>e.type!==cs);if(r===-1)return e;let i=e[r];delete i.props?.ref;let a=i.props?ks(t,i.props):t,o=Cs({...i,props:{}},a);return e.length===1?o:(e[r]=o,e)}}}),tb=[`area`,`img`,`input`],nb=F({name:`Primitive`,inheritAttrs:!1,props:{asChild:{type:Boolean,default:!1},as:{type:[String,Object],default:`div`}},setup(e,{attrs:t,slots:n}){let r=e.asChild?`template`:e.as;return typeof r==`string`&&tb.includes(r)?()=>tc(r,t):r===`template`?()=>tc(eb,t,{default:n.default}):()=>tc(e.as,t,{default:n.default})}});function rb(){let e=M();return{primitiveElement:e,currentElement:W(()=>[`#text`,`#comment`].includes(e.value?.$el.nodeName)?e.value?.$el.nextElementSibling:Oy(e))}}var[ib,ab]=oy(`CollapsibleRoot`),ob=F({__name:`CollapsibleRoot`,props:{defaultOpen:{type:Boolean,required:!1,default:!1},open:{type:Boolean,required:!1,default:void 0},disabled:{type:Boolean,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:open`],setup(e,{expose:t,emit:n}){let r=e,i=Iy(r,`open`,n,{defaultValue:r.defaultOpen,passive:r.open===void 0}),{disabled:a,unmountOnHide:o}=yn(r);return ab({contentId:``,disabled:a,open:i,unmountOnHide:o,onOpenToggle:()=>{a.value||(i.value=!i.value)}}),t({open:i}),Gy(),(e,t)=>(R(),B(N(nb),{as:e.as,"as-child":r.asChild,"data-state":N(i)?`open`:`closed`,"data-disabled":N(a)?``:void 0},{default:P(()=>[I(e.$slots,`default`,{open:N(i)})]),_:3},8,[`as`,`as-child`,`data-state`,`data-disabled`]))}}),sb=F({inheritAttrs:!1,__name:`CollapsibleContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`contentFound`],setup(e,{emit:t}){let n=e,r=t,i=ib();i.contentId||=Yy(void 0,`reka-collapsible-content`);let a=M(),{forwardRef:o,currentElement:s}=Gy(),c=M(0),l=M(0),u=W(()=>i.open.value),d=M(u.value),f=M();Er(()=>[u.value,a.value?.present],async()=>{await Qn();let e=s.value;if(!e)return;f.value=f.value||{transitionDuration:e.style.transitionDuration,animationName:e.style.animationName},e.style.transitionDuration=`0s`,e.style.animationName=`none`;let t=e.getBoundingClientRect();l.value=t.height,c.value=t.width,d.value||(e.style.transitionDuration=f.value.transitionDuration,e.style.animationName=f.value.animationName)},{immediate:!0});let p=W(()=>d.value&&i.open.value);return Zi(()=>{requestAnimationFrame(()=>{d.value=!1})}),ky(s,`beforematch`,e=>{requestAnimationFrame(()=>{i.onOpenToggle(),r(`contentFound`)})}),(e,t)=>(R(),B(N($y),{ref_key:`presentRef`,ref:a,present:e.forceMount||N(i).open.value,"force-mount":!0},{default:P(({present:t})=>[H(N(nb),ks(e.$attrs,{id:N(i).contentId,ref:N(o),"as-child":n.asChild,as:e.as,hidden:t?void 0:N(i).unmountOnHide.value?``:`until-found`,"data-state":p.value?void 0:N(i).open.value?`open`:`closed`,"data-disabled":N(i).disabled?.value?``:void 0,style:{"--reka-collapsible-content-height":`${l.value}px`,"--reka-collapsible-content-width":`${c.value}px`}}),{default:P(()=>[!N(i).unmountOnHide.value||t?I(e.$slots,`default`,{key:0}):Ts(`v-if`,!0)]),_:2},1040,[`id`,`as-child`,`as`,`hidden`,`data-state`,`data-disabled`,`style`])]),_:3},8,[`present`]))}}),cb=F({__name:`CollapsibleTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e;Gy();let n=ib();return(e,r)=>(R(),B(N(nb),{type:e.as===`button`?`button`:void 0,as:e.as,"as-child":t.asChild,"aria-controls":N(n).contentId,"aria-expanded":N(n).open.value,"data-state":N(n).open.value?`open`:`closed`,"data-disabled":N(n).disabled?.value?``:void 0,disabled:N(n).disabled?.value,onClick:N(n).onOpenToggle},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`type`,`as`,`as-child`,`aria-controls`,`aria-expanded`,`data-state`,`data-disabled`,`disabled`,`onClick`]))}});function lb({type:e,defaultValue:t,modelValue:n}){let r=n||t;return n!==void 0||t!==void 0?Array.isArray(r)?`multiple`:`single`:e??`single`}function ub({type:e,defaultValue:t,modelValue:n}){return e||lb({type:e,defaultValue:t,modelValue:n})}function db({type:e,defaultValue:t}){return t===void 0?e===`single`?void 0:[]:t}function fb(e,t){let n=W(()=>ub(e)),r=Iy(e,`modelValue`,t,{defaultValue:db(e),passive:e.modelValue===void 0,deep:!0});function i(e){if(n.value===`single`)r.value=ay(e,r.value)?void 0:e;else{let t=Array.isArray(r.value)?[...r.value||[]]:[r.value].filter(Boolean);if(ly(t,e)){let n=t.findIndex(t=>ay(t,e));t.splice(n,1)}else t.push(e);r.value=t}}return{modelValue:r,changeModelValue:i,isSingle:W(()=>n.value===`single`)}}var[pb,mb]=oy(`AccordionRoot`),hb=F({__name:`AccordionRoot`,props:{collapsible:{type:Boolean,required:!1,default:!1},disabled:{type:Boolean,required:!1,default:!1},dir:{type:String,required:!1},orientation:{type:String,required:!1,default:`vertical`},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},type:{type:String,required:!1},modelValue:{type:null,required:!1},defaultValue:{type:null,required:!1}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,{dir:i,disabled:a,unmountOnHide:o}=yn(n),s=Uy(i),{modelValue:c,changeModelValue:l,isSingle:u}=fb(n,r),{forwardRef:d,currentElement:f}=Gy();return mb({disabled:a,direction:s,orientation:n.orientation,parentElement:f,isSingle:u,collapsible:n.collapsible,modelValue:c,changeModelValue:l,unmountOnHide:o}),(e,t)=>(R(),B(N(nb),{ref:N(d),"as-child":e.asChild,as:e.as},{default:P(()=>[I(e.$slots,`default`,{modelValue:N(c)})]),_:3},8,[`as-child`,`as`]))}}),gb=function(e){return e.Open=`open`,e.Closed=`closed`,e}(gb||{}),[_b,vb]=oy(`AccordionItem`),yb=F({__name:`AccordionItem`,props:{disabled:{type:Boolean,required:!1},value:{type:String,required:!0},unmountOnHide:{type:Boolean,required:!1,default:void 0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e,{expose:t}){let n=e,r=pb(),i=W(()=>r.isSingle.value?n.value===r.modelValue.value:Array.isArray(r.modelValue.value)&&r.modelValue.value.includes(n.value)),a=W(()=>r.disabled.value||n.disabled),o=W(()=>a.value?``:void 0),s=W(()=>i.value?gb.Open:gb.Closed);t({open:i,dataDisabled:o});let{currentRef:c,currentElement:l}=Gy();vb({open:i,dataState:s,disabled:a,dataDisabled:o,triggerId:``,currentRef:c,currentElement:l,value:W(()=>n.value)});function u(e){let t=e.target;if(Array.from(r.parentElement.value?.querySelectorAll(`[data-reka-collection-item]`)??[]).findIndex(e=>e===t)===-1)return null;zy(e,t,r.parentElement.value,{arrowKeyOptions:r.orientation,dir:r.direction.value,focus:!0})}return(e,t)=>(R(),B(N(ob),{"data-orientation":N(r).orientation,"data-disabled":o.value,"data-state":s.value,disabled:a.value,open:i.value,as:n.as,"as-child":n.asChild,"unmount-on-hide":n.unmountOnHide??N(r).unmountOnHide.value,onKeydown:su(u,[`up`,`down`,`left`,`right`,`home`,`end`])},{default:P(()=>[I(e.$slots,`default`,{open:i.value})]),_:3},8,[`data-orientation`,`data-disabled`,`data-state`,`disabled`,`open`,`as`,`as-child`,`unmount-on-hide`]))}}),bb=F({__name:`AccordionContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=pb(),r=_b();return Gy(),(e,i)=>(R(),B(N(sb),{role:`region`,"as-child":t.asChild,as:e.as,"force-mount":t.forceMount,"aria-labelledby":N(r).triggerId,"data-state":N(r).dataState.value,"data-disabled":N(r).dataDisabled.value,"data-orientation":N(n).orientation,style:{"--reka-accordion-content-width":`var(--reka-collapsible-content-width)`,"--reka-accordion-content-height":`var(--reka-collapsible-content-height)`},onContentFound:i[0]||=e=>N(n).changeModelValue(N(r).value.value)},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`force-mount`,`aria-labelledby`,`data-state`,`data-disabled`,`data-orientation`]))}}),xb=F({__name:`AccordionHeader`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`h3`}},setup(e){let t=e,n=pb(),r=_b();return Gy(),(e,i)=>(R(),B(N(nb),{as:t.as,"as-child":t.asChild,"data-orientation":N(n).orientation,"data-state":N(r).dataState.value,"data-disabled":N(r).dataDisabled.value},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`data-orientation`,`data-state`,`data-disabled`]))}}),Sb=F({__name:`AccordionTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=pb(),r=_b();r.triggerId||=Yy(void 0,`reka-accordion-trigger`);function i(){let e=n.isSingle.value&&r.open.value&&!n.collapsible;r.disabled.value||e||n.changeModelValue(r.value.value)}return(e,a)=>(R(),B(N(cb),{id:N(r).triggerId,ref:N(r).currentRef,"data-reka-collection-item":``,as:t.as,"as-child":t.asChild,"aria-disabled":N(r).disabled.value||void 0,"aria-expanded":N(r).open.value||!1,"data-disabled":N(r).dataDisabled.value,"data-orientation":N(n).orientation,"data-state":N(r).dataState.value,disabled:N(r).disabled.value,onClick:i},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`id`,`as`,`as-child`,`aria-disabled`,`aria-expanded`,`data-disabled`,`data-orientation`,`data-state`,`disabled`]))}}),Cb=`data-reka-collection-item`;function wb(e={}){let{key:t=``,isProvider:n=!1}=e,r=`${t}CollectionProvider`,i;n?(i={collectionRef:M(),itemMap:M(new Map)},vr(r,i)):i=yr(r);let a=(e=!1)=>{let t=i.collectionRef.value;if(!t)return[];let n=Array.from(t.querySelectorAll(`[${Cb}]`)),r=new Map(n.map((e,t)=>[e,t])),a=Array.from(i.itemMap.value.values()).sort((e,t)=>(r.get(e.ref)??-1)-(r.get(t.ref)??-1));return e?a:a.filter(e=>e.ref.dataset.disabled!==``)},o=F({name:`CollectionSlot`,inheritAttrs:!1,setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=rb();return Er(a,()=>{i.collectionRef.value=a.value}),()=>tc(eb,{ref:r,...n},t)}}),s=F({name:`CollectionItem`,inheritAttrs:!1,props:{value:{validator:()=>!0}},setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=rb();return Cr(t=>{if(a.value){let n=sn(a.value);i.itemMap.value.set(n,{ref:a.value,value:e.value}),t(()=>i.itemMap.value.delete(n))}}),()=>tc(eb,{...n,[Cb]:``,ref:r},t)}});return{getItems:a,reactiveItems:W(()=>Array.from(i.itemMap.value.values())),itemMapSize:W(()=>i.itemMap.value.size),CollectionSlot:o,CollectionItem:s}}var Tb=`rovingFocusGroup.onEntryFocus`,Eb={bubbles:!1,cancelable:!0},Db={ArrowLeft:`prev`,ArrowUp:`prev`,ArrowRight:`next`,ArrowDown:`next`,PageUp:`first`,Home:`first`,PageDown:`last`,End:`last`};function Ob(e,t){return t===`rtl`?e===`ArrowLeft`?`ArrowRight`:e===`ArrowRight`?`ArrowLeft`:e:e}function kb(e,t,n){let r=Ob(e.key,n);if(!(t===`vertical`&&[`ArrowLeft`,`ArrowRight`].includes(r))&&!(t===`horizontal`&&[`ArrowUp`,`ArrowDown`].includes(r)))return Db[r]}function Ab(e,t=!1){let n=sy();for(let r of e)if(r===n||(r.focus({preventScroll:t}),sy()!==n))return}function jb(e,t){return e.map((n,r)=>e[(t+r)%e.length])}var[Mb,Nb]=oy(`RovingFocusGroup`),Pb=F({__name:`RovingFocusGroup`,props:{orientation:{type:String,required:!1,default:void 0},dir:{type:String,required:!1},loop:{type:Boolean,required:!1,default:!1},currentTabStopId:{type:[String,null],required:!1},defaultCurrentTabStopId:{type:String,required:!1},preventScrollOnEntryFocus:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`entryFocus`,`update:currentTabStopId`],setup(e,{expose:t,emit:n}){let r=e,i=n,{loop:a,orientation:o,dir:s}=yn(r),c=Uy(s),l=Iy(r,`currentTabStopId`,i,{defaultValue:r.defaultCurrentTabStopId,passive:r.currentTabStopId===void 0}),u=M(!1),d=M(!1),f=M(0),{getItems:p,CollectionSlot:m}=wb({isProvider:!0});function h(e){let t=!d.value;if(e.currentTarget&&e.target===e.currentTarget&&t&&!u.value){let t=new CustomEvent(Tb,Eb);if(e.currentTarget.dispatchEvent(t),i(`entryFocus`,t),!t.defaultPrevented){let e=p().map(e=>e.ref).filter(e=>e.dataset.disabled!==``);Ab([e.find(e=>e.getAttribute(`data-active`)===``),e.find(e=>e.getAttribute(`data-highlighted`)===``),e.find(e=>e.id===l.value),...e].filter(Boolean),r.preventScrollOnEntryFocus)}}d.value=!1}function g(){setTimeout(()=>{d.value=!1},1)}return t({getItems:p}),Nb({loop:a,dir:c,orientation:o,currentTabStopId:l,onItemFocus:e=>{l.value=e},onItemShiftTab:()=>{u.value=!0},onFocusableItemAdd:()=>{f.value++},onFocusableItemRemove:()=>{f.value--}}),(e,t)=>(R(),B(N(m),null,{default:P(()=>[H(N(nb),{tabindex:u.value||f.value===0?-1:0,"data-orientation":N(o),as:e.as,"as-child":e.asChild,dir:N(c),style:{outline:`none`},onMousedown:t[0]||=e=>d.value=!0,onMouseup:g,onFocus:h,onBlur:t[1]||=e=>u.value=!1},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`as`,`as-child`,`dir`])]),_:3}))}}),Fb=F({__name:`RovingFocusItem`,props:{tabStopId:{type:String,required:!1},focusable:{type:Boolean,required:!1,default:!0},active:{type:Boolean,required:!1},allowShiftKey:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Mb(),r=Yy(),i=W(()=>t.tabStopId||r),a=W(()=>n.currentTabStopId.value===i.value),{getItems:o,CollectionItem:s}=wb();Zi(()=>{t.focusable&&n.onFocusableItemAdd()}),ta(()=>{t.focusable&&n.onFocusableItemRemove()}),Er(()=>t.focusable,(e,t)=>{e!==t&&(e?n.onFocusableItemAdd():n.onFocusableItemRemove())});function c(e){if(e.key===`Tab`&&e.shiftKey){n.onItemShiftTab();return}if(e.target!==e.currentTarget)return;let r=kb(e,n.orientation.value,n.dir.value);if(r!==void 0){if(e.metaKey||e.ctrlKey||e.altKey||!t.allowShiftKey&&e.shiftKey)return;e.preventDefault();let i=[...o().map(e=>e.ref).filter(e=>e.dataset.disabled!==``)];if(r===`last`)i.reverse();else if(r===`prev`||r===`next`){r===`prev`&&i.reverse();let t=i.indexOf(e.currentTarget);i=n.loop.value?jb(i,t+1):i.slice(t+1)}Qn(()=>Ab(i))}}return(e,t)=>(R(),B(N(s),null,{default:P(()=>[H(N(nb),{tabindex:a.value?0:-1,"data-orientation":N(n).orientation.value,"data-active":e.active?``:void 0,"data-disabled":e.focusable?void 0:``,as:e.as,"as-child":e.asChild,onMousedown:t[0]||=t=>{e.focusable?N(n).onItemFocus(i.value):t.preventDefault()},onFocus:t[1]||=e=>N(n).onItemFocus(i.value),onKeydown:c},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`data-active`,`data-disabled`,`as`,`as-child`])]),_:3}))}}),[Ib,Lb]=oy(`TabsRoot`),Rb=F({__name:`TabsRoot`,props:{defaultValue:{type:null,required:!1},orientation:{type:String,required:!1,default:`horizontal`},dir:{type:String,required:!1},activationMode:{type:String,required:!1,default:`automatic`},modelValue:{type:null,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,{orientation:i,unmountOnHide:a,dir:o}=yn(n),s=Uy(o);Gy();let c=Iy(n,`modelValue`,r,{defaultValue:n.defaultValue,passive:n.modelValue===void 0}),l=M(),u=un(new Set);return Lb({modelValue:c,changeModelValue:e=>{c.value=e},orientation:i,dir:s,unmountOnHide:a,activationMode:n.activationMode,baseId:Yy(void 0,`reka-tabs`),tabsList:l,contentIds:u,registerContent:e=>{u.value=new Set([...u.value,e])},unregisterContent:e=>{let t=new Set(u.value);t.delete(e),u.value=t}}),(e,t)=>(R(),B(N(nb),{dir:N(s),"data-orientation":N(i),"as-child":e.asChild,as:e.as},{default:P(()=>[I(e.$slots,`default`,{modelValue:N(c)})]),_:3},8,[`dir`,`data-orientation`,`as-child`,`as`]))}});function zb(e,t){return`${e}-trigger-${t}`}function Bb(e,t){return`${e}-content-${t}`}var Vb=F({__name:`TabsContent`,props:{value:{type:[String,Number],required:!0},forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{forwardRef:n}=Gy(),r=Ib(),i=W(()=>zb(r.baseId,t.value)),a=W(()=>Bb(r.baseId,t.value)),o=W(()=>t.value===r.modelValue.value),s=M(o.value);return Zi(()=>{r.registerContent(t.value),requestAnimationFrame(()=>{s.value=!1})}),ea(()=>{r.unregisterContent(t.value)}),(e,t)=>(R(),B(N($y),{present:e.forceMount||o.value,"force-mount":``},{default:P(({present:t})=>[H(N(nb),{id:a.value,ref:N(n),"as-child":e.asChild,as:e.as,role:`tabpanel`,"data-state":o.value?`active`:`inactive`,"data-orientation":N(r).orientation.value,"aria-labelledby":i.value,hidden:!t,tabindex:`0`,style:ge({animationDuration:s.value?`0s`:void 0})},{default:P(()=>[!N(r).unmountOnHide.value||t?I(e.$slots,`default`,{key:0}):Ts(`v-if`,!0)]),_:2},1032,[`id`,`as-child`,`as`,`data-state`,`data-orientation`,`aria-labelledby`,`hidden`,`style`])]),_:3},8,[`present`]))}}),Hb=F({__name:`TabsList`,props:{loop:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let{loop:t}=yn(e),{forwardRef:n,currentElement:r}=Gy(),i=Ib();return i.tabsList=r,(e,r)=>(R(),B(N(Pb),{"as-child":``,orientation:N(i).orientation.value,dir:N(i).dir.value,loop:N(t)},{default:P(()=>[H(N(nb),{ref:N(n),role:`tablist`,"as-child":e.asChild,as:e.as,"aria-orientation":N(i).orientation.value},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`aria-orientation`])]),_:3},8,[`orientation`,`dir`,`loop`]))}}),Ub=F({__name:`TabsTrigger`,props:{value:{type:[String,Number],required:!0},disabled:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e,{forwardRef:n}=Gy(),r=Ib(),i=W(()=>zb(r.baseId,t.value)),a=W(()=>r.contentIds.value.has(t.value)?Bb(r.baseId,t.value):void 0),o=W(()=>t.value===r.modelValue.value);return(e,t)=>(R(),B(N(Fb),{"as-child":``,focusable:!e.disabled,active:o.value},{default:P(()=>[H(N(nb),{id:i.value,ref:N(n),role:`tab`,type:e.as===`button`?`button`:void 0,as:e.as,"as-child":e.asChild,"aria-selected":o.value?`true`:`false`,"aria-controls":a.value,"data-state":o.value?`active`:`inactive`,disabled:e.disabled,"data-disabled":e.disabled?``:void 0,"data-orientation":N(r).orientation.value,onMousedown:t[0]||=au(t=>{!e.disabled&&t.ctrlKey===!1?N(r).changeModelValue(e.value):t.preventDefault()},[`left`]),onKeydown:t[1]||=su(t=>N(r).changeModelValue(e.value),[`enter`,`space`]),onFocus:t[2]||=()=>{let t=N(r).activationMode!==`manual`;!o.value&&!e.disabled&&t&&N(r).changeModelValue(e.value)}},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`id`,`type`,`as`,`as-child`,`aria-selected`,`aria-controls`,`data-state`,`disabled`,`data-disabled`,`data-orientation`])]),_:3},8,[`focusable`,`active`]))}}),Wb=F({__name:`Button`,props:{variant:{},size:{},class:{type:[Boolean,null,String,Object,Array]},asChild:{type:Boolean},as:{default:`button`}},setup(e){let t=e;return(n,r)=>(R(),B(N(nb),{"data-slot":`button`,"data-variant":e.variant,"data-size":e.size,as:e.as,"as-child":e.asChild,class:O(N(Z)(N(Gb)({variant:e.variant,size:e.size}),t.class))},{default:P(()=>[I(n.$slots,`default`)]),_:3},8,[`data-variant`,`data-size`,`as`,`as-child`,`class`]))}}),Gb=w_(`focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 rounded-lg border border-transparent bg-clip-padding text-sm font-medium focus-visible:ring-3 aria-invalid:ring-3 active:not-aria-[haspopup]:translate-y-px [&_svg:not([class*=size-])]:size-4 group/button inline-flex shrink-0 items-center justify-center whitespace-nowrap transition-all outline-none select-none disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0`,{variants:{variant:{default:`bg-primary text-primary-foreground [a]:hover:bg-primary/80`,outline:`border-border bg-background hover:bg-muted hover:text-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50 aria-expanded:bg-muted aria-expanded:text-foreground`,secondary:`bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground`,ghost:`hover:bg-muted hover:text-foreground dark:hover:bg-muted/50 aria-expanded:bg-muted aria-expanded:text-foreground`,destructive:`bg-destructive/10 hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/20 text-destructive focus-visible:border-destructive/40 dark:hover:bg-destructive/30`,link:`text-primary underline-offset-4 hover:underline`},size:{default:`h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2`,xs:`h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*=size-])]:size-3`,sm:`h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*=size-])]:size-3.5`,lg:`h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2`,icon:`size-8`,"icon-xs":`size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*=size-])]:size-3`,"icon-sm":`size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg`,"icon-lg":`size-9`}},defaultVariants:{variant:`default`,size:`default`}}),Kb=[`data-size`],qb=F({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e;return(n,r)=>(R(),z(`div`,{"data-slot":`card`,"data-size":e.size,class:O(N(Z)(`ring-foreground/10 bg-card text-card-foreground gap-4 overflow-hidden rounded-xl py-4 text-sm ring-1 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl group/card flex flex-col`,t.class))},[I(n.$slots,`default`)],10,Kb))}}),Jb=F({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-content`,class:O(N(Z)(`px-4 group-data-[size=sm]/card:px-3`,t.class))},[I(e.$slots,`default`)],2))}}),Yb=F({__name:`CardDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-description`,class:O(N(Z)(`text-muted-foreground text-sm`,t.class))},[I(e.$slots,`default`)],2))}}),Xb=F({__name:`CardHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-header`,class:O(N(Z)(`gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3 group/card-header @container/card-header grid auto-rows-min items-start has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto]`,t.class))},[I(e.$slots,`default`)],2))}}),Zb=F({__name:`CardTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-title`,class:O(N(Z)(`text-base leading-snug font-medium group-data-[size=sm]/card:text-sm cn-font-heading`,t.class))},[I(e.$slots,`default`)],2))}}),Qb=F({__name:`Input`,props:{defaultValue:{},modelValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=Iy(n,`modelValue`,t,{passive:!0,defaultValue:n.defaultValue});return(e,t)=>gr((R(),z(`input`,{"onUpdate:modelValue":t[0]||=e=>j(r)?r.value=e:null,"data-slot":`input`,class:O(N(Z)(`dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 disabled:bg-input/50 dark:disabled:bg-input/80 h-8 rounded-lg border bg-transparent px-2.5 py-1 text-base transition-colors file:h-6 file:text-sm file:font-medium focus-visible:ring-3 aria-invalid:ring-3 md:text-sm w-full min-w-0 outline-none file:inline-flex file:border-0 file:bg-transparent file:text-foreground placeholder:text-muted-foreground disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50`,n.class))},null,2)),[[Gl,N(r)]])}}),$b=`llmgwAdminKey`;function ex(){try{return sessionStorage.getItem($b)??``}catch{return``}}function tx(e){try{sessionStorage.setItem($b,e)}catch{}}function nx(){try{sessionStorage.removeItem($b)}catch{}}var rx=n_(`auth`,{state:()=>({apiKey:ex(),error:``}),getters:{isAuthenticated:e=>e.apiKey!==``},actions:{submit(e){e&&(this.apiKey=e,this.error=``,tx(e))},reject(e){this.apiKey=``,this.error=e,nx()}}}),ix=class extends Error{status;constructor(e,t){super(e),this.name=`AdminApiError`,this.status=t}};async function ax(e){let t=rx(),n=t.apiKey,r=await fetch(e,{credentials:`same-origin`,headers:n?{"x-api-key":n}:{}});if(r.status===401||r.status===403)throw t.apiKey===n&&t.reject(`invalid key, or not an admin`),new ix(`${e}: HTTP ${r.status}`,r.status);if(!r.ok)throw new ix(`${e}: HTTP ${r.status}`,r.status);return await r.json()}var ox=5e3,sx=n_(`dashboard`,{state:()=>({overview:null,usage:null,targets:null,lastUpdated:null,error:``,timer:void 0}),actions:{async refresh(){if(!rx().isAuthenticated)return;let[e,t,n]=await Promise.allSettled([ax(`/admin/api/overview`),ax(`/admin/api/usage`),ax(`/admin/api/targets`)]);e.status===`fulfilled`&&(this.overview=e.value),t.status===`fulfilled`&&(this.usage=t.value),n.status===`fulfilled`&&(this.targets=n.value);let r=[];if(e.status===`rejected`&&r.push({label:`overview`,reason:e.reason}),t.status===`rejected`&&r.push({label:`usage`,reason:t.reason}),n.status===`rejected`&&r.push({label:`targets`,reason:n.reason}),r.length===0){this.lastUpdated=new Date,this.error=``;return}r.some(({reason:e})=>e instanceof ix&&(e.status===401||e.status===403))||(r.length<3&&(this.lastUpdated=new Date),this.error=r.map(({label:e,reason:t})=>`${e}: ${t instanceof Error?t.message:String(t)}`).join(`; `))},startPolling(){this.timer===void 0&&(this.refresh(),this.timer=setInterval(()=>void this.refresh(),ox))},stopPolling(){this.timer!==void 0&&(clearInterval(this.timer),this.timer=void 0)}}}),cx={class:`mx-auto flex min-h-[70vh] max-w-md flex-col justify-center px-4`},lx={class:`flex size-12 items-center justify-center rounded-full bg-primary/10 text-primary`},ux={class:`flex flex-col items-center gap-1`},dx={"aria-labelledby":`authgate-security-heading`,class:`flex flex-col gap-1.5 text-xs text-muted-foreground`},fx={class:`flex items-start gap-1.5`},px={class:`flex items-start gap-1.5`},mx={class:`flex items-start gap-1.5`},hx={class:`relative`},gx=((e,t)=>{let n=e.__vccOpts||e;for(let[e,r]of t)n[e]=r;return n})(F({__name:`AuthGate`,setup(e){let t=rx(),n=sx(),r=M(``),i=M(!1),a=M(null),o=W(()=>r.value.trim()!==``);function s(){let e=r.value;r.value=``,t.submit(e),n.refresh()}function c(){Qn(()=>a.value?.$el?.focus())}return Zi(c),Er(()=>t.error,e=>{e&&c()}),(e,n)=>{let c=ca(`FontAwesomeIcon`);return R(),z(`div`,cx,[H(N(qb),null,{default:P(()=>[H(N(Xb),{class:`flex flex-col items-center gap-3 text-center`},{default:P(()=>[V(`div`,lx,[H(c,{icon:N(a_),class:`size-5`,"aria-hidden":`true`},null,8,[`icon`])]),V(`div`,ux,[n[3]||=V(`span`,{class:`text-xs font-medium text-muted-foreground`},`LLM Gateway`,-1),H(N(Zb),{class:`text-lg font-semibold`},{default:P(()=>[...n[2]||=[U(`Admin key required`,-1)]]),_:1})]),H(N(Yb),null,{default:P(()=>[...n[4]||=[U(`Enter an admin API key to continue.`,-1)]]),_:1})]),_:1}),H(N(Jb),{class:`flex flex-col gap-4`},{default:P(()=>[n[10]||=V(`h2`,{id:`authgate-security-heading`,class:`sr-only`},` How this key is handled `,-1),V(`ul`,dx,[V(`li`,fx,[H(c,{icon:N(d_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[5]||=V(`span`,null,`Kept only in this tab's session storage`,-1)]),V(`li`,px,[H(c,{icon:N(d_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[6]||=V(`span`,null,`Never written to disk`,-1)]),V(`li`,mx,[H(c,{icon:N(d_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[7]||=V(`span`,null,`Sent only to this page's own /admin/api/* requests`,-1)])]),V(`form`,{class:`flex flex-col gap-3`,onSubmit:au(s,[`prevent`])},[V(`div`,hx,[H(N(Qb),{ref_key:`keyInputEl`,ref:a,modelValue:r.value,"onUpdate:modelValue":n[0]||=e=>r.value=e,type:i.value?`text`:`password`,autocomplete:`off`,placeholder:`API key`,"aria-label":`Admin API key`,"aria-invalid":!!N(t).error,"aria-describedby":N(t).error?`authgate-error`:void 0,class:O([`h-10 pr-10`,{"authgate-shake":N(t).error}])},null,8,[`modelValue`,`type`,`aria-invalid`,`aria-describedby`,`class`]),H(N(Wb),{type:`button`,variant:`ghost`,size:`icon-xs`,class:`absolute top-1/2 right-1.5 -translate-y-1/2 text-muted-foreground hover:text-foreground`,"aria-label":i.value?`Hide key`:`Show key`,onClick:n[1]||=e=>i.value=!i.value},{default:P(()=>[H(c,{icon:i.value?N(v_):N(s_),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`aria-label`])]),H(N(Wb),{type:`submit`,class:`w-full`,disabled:!o.value},{default:P(()=>[...n[8]||=[U(` Continue `,-1)]]),_:1},8,[`disabled`])],32),N(t).error?(R(),B(N(Xv),{key:0,id:`authgate-error`,variant:`destructive`},{default:P(()=>[H(N(Qv),null,{default:P(()=>[...n[9]||=[U(`Authentication failed`,-1)]]),_:1}),H(N(Zv),null,{default:P(()=>[U(k(N(t).error),1)]),_:1})]),_:1})):Ts(``,!0)]),_:1})]),_:1})])}}}),[[`__scopeId`,`data-v-4be6bc09`]]);function _x(e,t){return typeof e==`function`?e(t):e}function vx(e,t){return n=>{t.setState(t=>({...t,[e]:_x(n,t[e])}))}}function yx(e){return e instanceof Function}function bx(e){return Array.isArray(e)&&e.every(e=>typeof e==`number`)}function xx(e,t){let n=[],r=e=>{e.forEach(e=>{n.push(e);let i=t(e);i!=null&&i.length&&r(i)})};return r(e),n}function Q(e,t,n){let r=[],i;return a=>{let o;n.key&&n.debug&&(o=Date.now());let s=e(a);if(!(s.length!==r.length||s.some((e,t)=>r[t]!==e)))return i;r=s;let c;if(n.key&&n.debug&&(c=Date.now()),i=t(...s),n==null||n.onChange==null||n.onChange(i),n.key&&n.debug&&n!=null&&n.debug()){let e=Math.round((Date.now()-o)*100)/100,t=Math.round((Date.now()-c)*100)/100,r=t/16,i=(e,t)=>{for(e=String(e);e.length<t;)e=` `+e;return e};console.info(`%c⏱ ${i(t,5)} /${i(e,5)} ms`,`
            font-size: .6rem;
            font-weight: bold;
            color: hsl(${Math.max(0,Math.min(120-120*r,120))}deg 100% 31%);`,n?.key)}return i}}function $(e,t,n,r){return{debug:()=>e?.debugAll??e[t],key:!1,onChange:r}}function Sx(e,t,n,r){let i={id:`${t.id}_${n.id}`,row:t,column:n,getValue:()=>t.getValue(r),renderValue:()=>i.getValue()??e.options.renderFallbackValue,getContext:Q(()=>[e,n,t,i],(e,t,n,r)=>({table:e,column:t,row:n,cell:r,getValue:r.getValue,renderValue:r.renderValue}),$(e.options,`debugCells`,`cell.getContext`))};return e._features.forEach(r=>{r.createCell==null||r.createCell(i,n,t,e)},{}),i}function Cx(e,t,n,r){let i={...e._getDefaultColumnDef(),...t},a=i.accessorKey,o=i.id??(a?typeof String.prototype.replaceAll==`function`?a.replaceAll(`.`,`_`):a.replace(/\./g,`_`):void 0)??(typeof i.header==`string`?i.header:void 0),s;if(i.accessorFn?s=i.accessorFn:a&&(s=a.includes(`.`)?e=>{let t=e;for(let e of a.split(`.`))t=t?.[e];return t}:e=>e[i.accessorKey]),!o)throw Error();let c={id:`${String(o)}`,accessorFn:s,parent:r,depth:n,columnDef:i,columns:[],getFlatColumns:Q(()=>[!0],()=>[c,...c.columns?.flatMap(e=>e.getFlatColumns())],$(e.options,`debugColumns`,`column.getFlatColumns`)),getLeafColumns:Q(()=>[e._getOrderColumnsFn()],e=>{var t;return(t=c.columns)!=null&&t.length?e(c.columns.flatMap(e=>e.getLeafColumns())):[c]},$(e.options,`debugColumns`,`column.getLeafColumns`))};for(let t of e._features)t.createColumn==null||t.createColumn(c,e);return c}var wx=`debugHeaders`;function Tx(e,t,n){let r={id:n.id??t.id,column:t,index:n.index,isPlaceholder:!!n.isPlaceholder,placeholderId:n.placeholderId,depth:n.depth,subHeaders:[],colSpan:0,rowSpan:0,headerGroup:null,getLeafHeaders:()=>{let e=[],t=n=>{n.subHeaders&&n.subHeaders.length&&n.subHeaders.map(t),e.push(n)};return t(r),e},getContext:()=>({table:e,header:r,column:t})};return e._features.forEach(t=>{t.createHeader==null||t.createHeader(r,e)}),r}var Ex={createTable:e=>{e.getHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(t,n,r,i)=>{let a=r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],o=i?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],s=n.filter(e=>!(r!=null&&r.includes(e.id))&&!(i!=null&&i.includes(e.id)));return Dx(t,[...a,...s,...o],e)},$(e.options,wx,`getHeaderGroups`)),e.getCenterHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(t,n,r,i)=>(n=n.filter(e=>!(r!=null&&r.includes(e.id))&&!(i!=null&&i.includes(e.id))),Dx(t,n,e,`center`)),$(e.options,wx,`getCenterHeaderGroups`)),e.getLeftHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left],(t,n,r)=>Dx(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`left`),$(e.options,wx,`getLeftHeaderGroups`)),e.getRightHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.right],(t,n,r)=>Dx(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`right`),$(e.options,wx,`getRightHeaderGroups`)),e.getFooterGroups=Q(()=>[e.getHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getFooterGroups`)),e.getLeftFooterGroups=Q(()=>[e.getLeftHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getLeftFooterGroups`)),e.getCenterFooterGroups=Q(()=>[e.getCenterHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getCenterFooterGroups`)),e.getRightFooterGroups=Q(()=>[e.getRightHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getRightFooterGroups`)),e.getFlatHeaders=Q(()=>[e.getHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getFlatHeaders`)),e.getLeftFlatHeaders=Q(()=>[e.getLeftHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getLeftFlatHeaders`)),e.getCenterFlatHeaders=Q(()=>[e.getCenterHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getCenterFlatHeaders`)),e.getRightFlatHeaders=Q(()=>[e.getRightHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getRightFlatHeaders`)),e.getCenterLeafHeaders=Q(()=>[e.getCenterFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getCenterLeafHeaders`)),e.getLeftLeafHeaders=Q(()=>[e.getLeftFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getLeftLeafHeaders`)),e.getRightLeafHeaders=Q(()=>[e.getRightFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getRightLeafHeaders`)),e.getLeafHeaders=Q(()=>[e.getLeftHeaderGroups(),e.getCenterHeaderGroups(),e.getRightHeaderGroups()],(e,t,n)=>[...e[0]?.headers??[],...t[0]?.headers??[],...n[0]?.headers??[]].map(e=>e.getLeafHeaders()).flat(),$(e.options,wx,`getLeafHeaders`))}};function Dx(e,t,n,r){let i=0,a=function(e,t){t===void 0&&(t=1),i=Math.max(i,t),e.filter(e=>e.getIsVisible()).forEach(e=>{var n;(n=e.columns)!=null&&n.length&&a(e.columns,t+1)},0)};a(e);let o=[],s=(e,t)=>{let i={depth:t,id:[r,`${t}`].filter(Boolean).join(`_`),headers:[]},a=[];e.forEach(e=>{let o=[...a].reverse()[0],s=e.column.depth===i.depth,c,l=!1;if(s&&e.column.parent?c=e.column.parent:(c=e.column,l=!0),o&&o?.column===c)o.subHeaders.push(e);else{let i=Tx(n,c,{id:[r,t,c.id,e?.id].filter(Boolean).join(`_`),isPlaceholder:l,placeholderId:l?`${a.filter(e=>e.column===c).length}`:void 0,depth:t,index:a.length});i.subHeaders.push(e),a.push(i)}i.headers.push(e),e.headerGroup=i}),o.push(i),t>0&&s(a,t-1)};s(t.map((e,t)=>Tx(n,e,{depth:i,index:t})),i-1),o.reverse();let c=e=>e.filter(e=>e.column.getIsVisible()).map(e=>{let t=0,n=0,r=[0];e.subHeaders&&e.subHeaders.length?(r=[],c(e.subHeaders).forEach(e=>{let{colSpan:n,rowSpan:i}=e;t+=n,r.push(i)})):t=1;let i=Math.min(...r);return n+=i,e.colSpan=t,e.rowSpan=n,{colSpan:t,rowSpan:n}});return c(o[0]?.headers??[]),o}var Ox=(e,t,n,r,i,a,o)=>{let s={id:t,index:r,original:n,depth:i,parentId:o,_valuesCache:{},_uniqueValuesCache:{},getValue:t=>{if(s._valuesCache.hasOwnProperty(t))return s._valuesCache[t];let n=e.getColumn(t);if(n!=null&&n.accessorFn)return s._valuesCache[t]=n.accessorFn(s.original,r),s._valuesCache[t]},getUniqueValues:t=>{if(s._uniqueValuesCache.hasOwnProperty(t))return s._uniqueValuesCache[t];let n=e.getColumn(t);if(n!=null&&n.accessorFn)return n.columnDef.getUniqueValues?(s._uniqueValuesCache[t]=n.columnDef.getUniqueValues(s.original,r),s._uniqueValuesCache[t]):(s._uniqueValuesCache[t]=[s.getValue(t)],s._uniqueValuesCache[t])},renderValue:t=>s.getValue(t)??e.options.renderFallbackValue,subRows:a??[],getLeafRows:()=>xx(s.subRows,e=>e.subRows),getParentRow:()=>s.parentId?e.getRow(s.parentId,!0):void 0,getParentRows:()=>{let e=[],t=s;for(;;){let n=t.getParentRow();if(!n)break;e.push(n),t=n}return e.reverse()},getAllCells:Q(()=>[e.getAllLeafColumns()],t=>t.map(t=>Sx(e,s,t,t.id)),$(e.options,`debugRows`,`getAllCells`)),_getAllCellsByColumnId:Q(()=>[s.getAllCells()],e=>e.reduce((e,t)=>(e[t.column.id]=t,e),{}),$(e.options,`debugRows`,`getAllCellsByColumnId`))};for(let t=0;t<e._features.length;t++){let n=e._features[t];n==null||n.createRow==null||n.createRow(s,e)}return s},kx={createColumn:(e,t)=>{e._getFacetedRowModel=t.options.getFacetedRowModel&&t.options.getFacetedRowModel(t,e.id),e.getFacetedRowModel=()=>e._getFacetedRowModel?e._getFacetedRowModel():t.getPreFilteredRowModel(),e._getFacetedUniqueValues=t.options.getFacetedUniqueValues&&t.options.getFacetedUniqueValues(t,e.id),e.getFacetedUniqueValues=()=>e._getFacetedUniqueValues?e._getFacetedUniqueValues():new Map,e._getFacetedMinMaxValues=t.options.getFacetedMinMaxValues&&t.options.getFacetedMinMaxValues(t,e.id),e.getFacetedMinMaxValues=()=>{if(e._getFacetedMinMaxValues)return e._getFacetedMinMaxValues()}}},Ax=(e,t,n)=>{var r,i;let a=n==null||(r=n.toString())==null?void 0:r.toLowerCase();return!!((i=e.getValue(t))!=null&&(i=i.toString())!=null&&(i=i.toLowerCase())!=null&&i.includes(a))};Ax.autoRemove=e=>Bx(e);var jx=(e,t,n)=>{var r;return!!((r=e.getValue(t))!=null&&(r=r.toString())!=null&&r.includes(n))};jx.autoRemove=e=>Bx(e);var Mx=(e,t,n)=>{var r;return((r=e.getValue(t))==null||(r=r.toString())==null?void 0:r.toLowerCase())===n?.toLowerCase()};Mx.autoRemove=e=>Bx(e);var Nx=(e,t,n)=>e.getValue(t)?.includes(n);Nx.autoRemove=e=>Bx(e);var Px=(e,t,n)=>!n.some(n=>{var r;return!((r=e.getValue(t))!=null&&r.includes(n))});Px.autoRemove=e=>Bx(e)||!(e!=null&&e.length);var Fx=(e,t,n)=>n.some(n=>e.getValue(t)?.includes(n));Fx.autoRemove=e=>Bx(e)||!(e!=null&&e.length);var Ix=(e,t,n)=>e.getValue(t)===n;Ix.autoRemove=e=>Bx(e);var Lx=(e,t,n)=>e.getValue(t)==n;Lx.autoRemove=e=>Bx(e);var Rx=(e,t,n)=>{let[r,i]=n,a=e.getValue(t);return a>=r&&a<=i};Rx.resolveFilterValue=e=>{let[t,n]=e,r=typeof t==`number`?t:parseFloat(t),i=typeof n==`number`?n:parseFloat(n),a=t===null||Number.isNaN(r)?-1/0:r,o=n===null||Number.isNaN(i)?1/0:i;if(a>o){let e=a;a=o,o=e}return[a,o]},Rx.autoRemove=e=>Bx(e)||Bx(e[0])&&Bx(e[1]);var zx={includesString:Ax,includesStringSensitive:jx,equalsString:Mx,arrIncludes:Nx,arrIncludesAll:Px,arrIncludesSome:Fx,equals:Ix,weakEquals:Lx,inNumberRange:Rx};function Bx(e){return e==null||e===``}var Vx={getDefaultColumnDef:()=>({filterFn:`auto`}),getInitialState:e=>({columnFilters:[],...e}),getDefaultOptions:e=>({onColumnFiltersChange:vx(`columnFilters`,e),filterFromLeafRows:!1,maxLeafRowFilterDepth:100}),createColumn:(e,t)=>{e.getAutoFilterFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);return typeof n==`string`?zx.includesString:typeof n==`number`?zx.inNumberRange:typeof n==`boolean`||typeof n==`object`&&n?zx.equals:Array.isArray(n)?zx.arrIncludes:zx.weakEquals},e.getFilterFn=()=>yx(e.columnDef.filterFn)?e.columnDef.filterFn:e.columnDef.filterFn===`auto`?e.getAutoFilterFn():t.options.filterFns?.[e.columnDef.filterFn]??zx[e.columnDef.filterFn],e.getCanFilter=()=>(e.columnDef.enableColumnFilter??!0)&&(t.options.enableColumnFilters??!0)&&(t.options.enableFilters??!0)&&!!e.accessorFn,e.getIsFiltered=()=>e.getFilterIndex()>-1,e.getFilterValue=()=>{var n;return(n=t.getState().columnFilters)==null||(n=n.find(t=>t.id===e.id))==null?void 0:n.value},e.getFilterIndex=()=>t.getState().columnFilters?.findIndex(t=>t.id===e.id)??-1,e.setFilterValue=n=>{t.setColumnFilters(t=>{let r=e.getFilterFn(),i=t?.find(t=>t.id===e.id),a=_x(n,i?i.value:void 0);if(Hx(r,a,e))return t?.filter(t=>t.id!==e.id)??[];let o={id:e.id,value:a};return i?t?.map(t=>t.id===e.id?o:t)??[]:t!=null&&t.length?[...t,o]:[o]})}},createRow:(e,t)=>{e.columnFilters={},e.columnFiltersMeta={}},createTable:e=>{e.setColumnFilters=t=>{let n=e.getAllLeafColumns();e.options.onColumnFiltersChange==null||e.options.onColumnFiltersChange(e=>_x(t,e)?.filter(e=>{let t=n.find(t=>t.id===e.id);return!(t&&Hx(t.getFilterFn(),e.value,t))}))},e.resetColumnFilters=t=>{e.setColumnFilters(t?[]:e.initialState?.columnFilters??[])},e.getPreFilteredRowModel=()=>e.getCoreRowModel(),e.getFilteredRowModel=()=>(!e._getFilteredRowModel&&e.options.getFilteredRowModel&&(e._getFilteredRowModel=e.options.getFilteredRowModel(e)),e.options.manualFiltering||!e._getFilteredRowModel?e.getPreFilteredRowModel():e._getFilteredRowModel())}};function Hx(e,t,n){return(e&&e.autoRemove?e.autoRemove(t,n):!1)||t===void 0||typeof t==`string`&&!t}var Ux={sum:(e,t,n)=>n.reduce((t,n)=>{let r=n.getValue(e);return t+(typeof r==`number`?r:0)},0),min:(e,t,n)=>{let r;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r>n||r===void 0&&n>=n)&&(r=n)}),r},max:(e,t,n)=>{let r;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r<n||r===void 0&&n>=n)&&(r=n)}),r},extent:(e,t,n)=>{let r,i;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r===void 0?n>=n&&(r=i=n):(r>n&&(r=n),i<n&&(i=n)))}),[r,i]},mean:(e,t)=>{let n=0,r=0;if(t.forEach(t=>{let i=t.getValue(e);i!=null&&(i=+i)>=i&&(++n,r+=i)}),n)return r/n},median:(e,t)=>{if(!t.length)return;let n=t.map(t=>t.getValue(e));if(!bx(n))return;if(n.length===1)return n[0];let r=Math.floor(n.length/2),i=n.sort((e,t)=>e-t);return n.length%2==0?(i[r-1]+i[r])/2:i[r]},unique:(e,t)=>Array.from(new Set(t.map(t=>t.getValue(e))).values()),uniqueCount:(e,t)=>new Set(t.map(t=>t.getValue(e))).size,count:(e,t)=>t.length},Wx={getDefaultColumnDef:()=>({aggregatedCell:e=>{var t;return((t=e.getValue())==null||t.toString==null?void 0:t.toString())??null},aggregationFn:`auto`}),getInitialState:e=>({grouping:[],...e}),getDefaultOptions:e=>({onGroupingChange:vx(`grouping`,e),groupedColumnMode:`reorder`}),createColumn:(e,t)=>{e.toggleGrouping=()=>{t.setGrouping(t=>t!=null&&t.includes(e.id)?t.filter(t=>t!==e.id):[...t??[],e.id])},e.getCanGroup=()=>(e.columnDef.enableGrouping??!0)&&(t.options.enableGrouping??!0)&&(!!e.accessorFn||!!e.columnDef.getGroupingValue),e.getIsGrouped=()=>t.getState().grouping?.includes(e.id),e.getGroupedIndex=()=>t.getState().grouping?.indexOf(e.id),e.getToggleGroupingHandler=()=>{let t=e.getCanGroup();return()=>{t&&e.toggleGrouping()}},e.getAutoAggregationFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);if(typeof n==`number`)return Ux.sum;if(Object.prototype.toString.call(n)===`[object Date]`)return Ux.extent},e.getAggregationFn=()=>{if(!e)throw Error();return yx(e.columnDef.aggregationFn)?e.columnDef.aggregationFn:e.columnDef.aggregationFn===`auto`?e.getAutoAggregationFn():t.options.aggregationFns?.[e.columnDef.aggregationFn]??Ux[e.columnDef.aggregationFn]}},createTable:e=>{e.setGrouping=t=>e.options.onGroupingChange==null?void 0:e.options.onGroupingChange(t),e.resetGrouping=t=>{e.setGrouping(t?[]:e.initialState?.grouping??[])},e.getPreGroupedRowModel=()=>e.getFilteredRowModel(),e.getGroupedRowModel=()=>(!e._getGroupedRowModel&&e.options.getGroupedRowModel&&(e._getGroupedRowModel=e.options.getGroupedRowModel(e)),e.options.manualGrouping||!e._getGroupedRowModel?e.getPreGroupedRowModel():e._getGroupedRowModel())},createRow:(e,t)=>{e.getIsGrouped=()=>!!e.groupingColumnId,e.getGroupingValue=n=>{if(e._groupingValuesCache.hasOwnProperty(n))return e._groupingValuesCache[n];let r=t.getColumn(n);return r!=null&&r.columnDef.getGroupingValue?(e._groupingValuesCache[n]=r.columnDef.getGroupingValue(e.original),e._groupingValuesCache[n]):e.getValue(n)},e._groupingValuesCache={}},createCell:(e,t,n,r)=>{e.getIsGrouped=()=>t.getIsGrouped()&&t.id===n.groupingColumnId,e.getIsPlaceholder=()=>!e.getIsGrouped()&&t.getIsGrouped(),e.getIsAggregated=()=>{var t;return!e.getIsGrouped()&&!e.getIsPlaceholder()&&!!((t=n.subRows)!=null&&t.length)}}};function Gx(e,t,n){if(!(t!=null&&t.length)||!n)return e;let r=e.filter(e=>!t.includes(e.id));return n===`remove`?r:[...t.map(t=>e.find(e=>e.id===t)).filter(Boolean),...r]}var Kx={getInitialState:e=>({columnOrder:[],...e}),getDefaultOptions:e=>({onColumnOrderChange:vx(`columnOrder`,e)}),createColumn:(e,t)=>{e.getIndex=Q(e=>[rS(t,e)],t=>t.findIndex(t=>t.id===e.id),$(t.options,`debugColumns`,`getIndex`)),e.getIsFirstColumn=n=>rS(t,n)[0]?.id===e.id,e.getIsLastColumn=n=>{let r=rS(t,n);return r[r.length-1]?.id===e.id}},createTable:e=>{e.setColumnOrder=t=>e.options.onColumnOrderChange==null?void 0:e.options.onColumnOrderChange(t),e.resetColumnOrder=t=>{e.setColumnOrder(t?[]:e.initialState.columnOrder??[])},e._getOrderColumnsFn=Q(()=>[e.getState().columnOrder,e.getState().grouping,e.options.groupedColumnMode],(e,t,n)=>r=>{let i=[];if(!(e!=null&&e.length))i=r;else{let t=[...e],n=[...r];for(;n.length&&t.length;){let e=t.shift(),r=n.findIndex(t=>t.id===e);r>-1&&i.push(n.splice(r,1)[0])}i=[...i,...n]}return Gx(i,t,n)},$(e.options,`debugTable`,`_getOrderColumnsFn`))}},qx=()=>({left:[],right:[]}),Jx={getInitialState:e=>({columnPinning:qx(),...e}),getDefaultOptions:e=>({onColumnPinningChange:vx(`columnPinning`,e)}),createColumn:(e,t)=>{e.pin=n=>{let r=e.getLeafColumns().map(e=>e.id).filter(Boolean);t.setColumnPinning(e=>n===`right`?{left:(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),right:[...(e?.right??[]).filter(e=>!(r!=null&&r.includes(e))),...r]}:n===`left`?{left:[...(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),...r],right:(e?.right??[]).filter(e=>!(r!=null&&r.includes(e)))}:{left:(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),right:(e?.right??[]).filter(e=>!(r!=null&&r.includes(e)))})},e.getCanPin=()=>e.getLeafColumns().some(e=>(e.columnDef.enablePinning??!0)&&(t.options.enableColumnPinning??t.options.enablePinning??!0)),e.getIsPinned=()=>{let n=e.getLeafColumns().map(e=>e.id),{left:r,right:i}=t.getState().columnPinning,a=n.some(e=>r?.includes(e)),o=n.some(e=>i?.includes(e));return a?`left`:o?`right`:!1},e.getPinnedIndex=()=>{var n;let r=e.getIsPinned();return r?((n=t.getState().columnPinning)==null||(n=n[r])==null?void 0:n.indexOf(e.id))??-1:0}},createRow:(e,t)=>{e.getCenterVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.left,t.getState().columnPinning.right],(e,t,n)=>{let r=[...t??[],...n??[]];return e.filter(e=>!r.includes(e.column.id))},$(t.options,`debugRows`,`getCenterVisibleCells`)),e.getLeftVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.column.id===t)).filter(Boolean).map(e=>({...e,position:`left`})),$(t.options,`debugRows`,`getLeftVisibleCells`)),e.getRightVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.column.id===t)).filter(Boolean).map(e=>({...e,position:`right`})),$(t.options,`debugRows`,`getRightVisibleCells`))},createTable:e=>{e.setColumnPinning=t=>e.options.onColumnPinningChange==null?void 0:e.options.onColumnPinningChange(t),e.resetColumnPinning=t=>e.setColumnPinning(t?qx():e.initialState?.columnPinning??qx()),e.getIsSomeColumnsPinned=t=>{let n=e.getState().columnPinning;return t?!!n[t]?.length:!!(n.left?.length||n.right?.length)},e.getLeftLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),$(e.options,`debugColumns`,`getLeftLeafColumns`)),e.getRightLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),$(e.options,`debugColumns`,`getRightLeafColumns`)),e.getCenterLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(e,t,n)=>{let r=[...t??[],...n??[]];return e.filter(e=>!r.includes(e.id))},$(e.options,`debugColumns`,`getCenterLeafColumns`))}};function Yx(e){return e||(typeof document<`u`?document:null)}var Xx={size:150,minSize:20,maxSize:2**53-1},Zx=()=>({startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,isResizingColumn:!1,columnSizingStart:[]}),Qx={getDefaultColumnDef:()=>Xx,getInitialState:e=>({columnSizing:{},columnSizingInfo:Zx(),...e}),getDefaultOptions:e=>({columnResizeMode:`onEnd`,columnResizeDirection:`ltr`,onColumnSizingChange:vx(`columnSizing`,e),onColumnSizingInfoChange:vx(`columnSizingInfo`,e)}),createColumn:(e,t)=>{e.getSize=()=>{let n=t.getState().columnSizing[e.id];return Math.min(Math.max(e.columnDef.minSize??Xx.minSize,n??e.columnDef.size??Xx.size),e.columnDef.maxSize??Xx.maxSize)},e.getStart=Q(e=>[e,rS(t,e),t.getState().columnSizing],(t,n)=>n.slice(0,e.getIndex(t)).reduce((e,t)=>e+t.getSize(),0),$(t.options,`debugColumns`,`getStart`)),e.getAfter=Q(e=>[e,rS(t,e),t.getState().columnSizing],(t,n)=>n.slice(e.getIndex(t)+1).reduce((e,t)=>e+t.getSize(),0),$(t.options,`debugColumns`,`getAfter`)),e.resetSize=()=>{t.setColumnSizing(t=>{let{[e.id]:n,...r}=t;return r})},e.getCanResize=()=>(e.columnDef.enableResizing??!0)&&(t.options.enableColumnResizing??!0),e.getIsResizing=()=>t.getState().columnSizingInfo.isResizingColumn===e.id},createHeader:(e,t)=>{e.getSize=()=>{let t=0,n=e=>{e.subHeaders.length?e.subHeaders.forEach(n):t+=e.column.getSize()??0};return n(e),t},e.getStart=()=>{if(e.index>0){let t=e.headerGroup.headers[e.index-1];return t.getStart()+t.getSize()}return 0},e.getResizeHandler=n=>{let r=t.getColumn(e.column.id),i=r?.getCanResize();return a=>{if(!r||!i||(a.persist==null||a.persist(),tS(a)&&a.touches&&a.touches.length>1))return;let o=e.getSize(),s=e?e.getLeafHeaders().map(e=>[e.column.id,e.column.getSize()]):[[r.id,r.getSize()]],c=tS(a)?Math.round(a.touches[0].clientX):a.clientX,l={},u=(e,n)=>{typeof n==`number`&&(t.setColumnSizingInfo(e=>{let r=t.options.columnResizeDirection===`rtl`?-1:1,i=(n-(e?.startOffset??0))*r,a=Math.max(i/(e?.startSize??0),-.999999);return e.columnSizingStart.forEach(e=>{let[t,n]=e;l[t]=Math.round(Math.max(n+n*a,0)*100)/100}),{...e,deltaOffset:i,deltaPercentage:a}}),(t.options.columnResizeMode===`onChange`||e===`end`)&&t.setColumnSizing(e=>({...e,...l})))},d=e=>u(`move`,e),f=e=>{u(`end`,e),t.setColumnSizingInfo(e=>({...e,isResizingColumn:!1,startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,columnSizingStart:[]}))},p=Yx(n),m={moveHandler:e=>d(e.clientX),upHandler:e=>{p?.removeEventListener(`mousemove`,m.moveHandler),p?.removeEventListener(`mouseup`,m.upHandler),f(e.clientX)}},h={moveHandler:e=>(e.cancelable&&(e.preventDefault(),e.stopPropagation()),d(e.touches[0].clientX),!1),upHandler:e=>{p?.removeEventListener(`touchmove`,h.moveHandler),p?.removeEventListener(`touchend`,h.upHandler),e.cancelable&&(e.preventDefault(),e.stopPropagation()),f(e.touches[0]?.clientX)}},g=eS()?{passive:!1}:!1;tS(a)?(p?.addEventListener(`touchmove`,h.moveHandler,g),p?.addEventListener(`touchend`,h.upHandler,g)):(p?.addEventListener(`mousemove`,m.moveHandler,g),p?.addEventListener(`mouseup`,m.upHandler,g)),t.setColumnSizingInfo(e=>({...e,startOffset:c,startSize:o,deltaOffset:0,deltaPercentage:0,columnSizingStart:s,isResizingColumn:r.id}))}}},createTable:e=>{e.setColumnSizing=t=>e.options.onColumnSizingChange==null?void 0:e.options.onColumnSizingChange(t),e.setColumnSizingInfo=t=>e.options.onColumnSizingInfoChange==null?void 0:e.options.onColumnSizingInfoChange(t),e.resetColumnSizing=t=>{e.setColumnSizing(t?{}:e.initialState.columnSizing??{})},e.resetHeaderSizeInfo=t=>{e.setColumnSizingInfo(t?Zx():e.initialState.columnSizingInfo??Zx())},e.getTotalSize=()=>e.getHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getLeftTotalSize=()=>e.getLeftHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getCenterTotalSize=()=>e.getCenterHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getRightTotalSize=()=>e.getRightHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0}},$x=null;function eS(){if(typeof $x==`boolean`)return $x;let e=!1;try{let t={get passive(){return e=!0,!1}},n=()=>{};window.addEventListener(`test`,n,t),window.removeEventListener(`test`,n)}catch{e=!1}return $x=e,$x}function tS(e){return e.type===`touchstart`}var nS={getInitialState:e=>({columnVisibility:{},...e}),getDefaultOptions:e=>({onColumnVisibilityChange:vx(`columnVisibility`,e)}),createColumn:(e,t)=>{e.toggleVisibility=n=>{e.getCanHide()&&t.setColumnVisibility(t=>({...t,[e.id]:n??!e.getIsVisible()}))},e.getIsVisible=()=>{let n=e.columns;return(n.length?n.some(e=>e.getIsVisible()):t.getState().columnVisibility?.[e.id])??!0},e.getCanHide=()=>(e.columnDef.enableHiding??!0)&&(t.options.enableHiding??!0),e.getToggleVisibilityHandler=()=>t=>{e.toggleVisibility==null||e.toggleVisibility(t.target.checked)}},createRow:(e,t)=>{e._getAllVisibleCells=Q(()=>[e.getAllCells(),t.getState().columnVisibility],e=>e.filter(e=>e.column.getIsVisible()),$(t.options,`debugRows`,`_getAllVisibleCells`)),e.getVisibleCells=Q(()=>[e.getLeftVisibleCells(),e.getCenterVisibleCells(),e.getRightVisibleCells()],(e,t,n)=>[...e,...t,...n],$(t.options,`debugRows`,`getVisibleCells`))},createTable:e=>{let t=(t,n)=>Q(()=>[n(),n().filter(e=>e.getIsVisible()).map(e=>e.id).join(`_`)],e=>e.filter(e=>e.getIsVisible==null?void 0:e.getIsVisible()),$(e.options,`debugColumns`,t));e.getVisibleFlatColumns=t(`getVisibleFlatColumns`,()=>e.getAllFlatColumns()),e.getVisibleLeafColumns=t(`getVisibleLeafColumns`,()=>e.getAllLeafColumns()),e.getLeftVisibleLeafColumns=t(`getLeftVisibleLeafColumns`,()=>e.getLeftLeafColumns()),e.getRightVisibleLeafColumns=t(`getRightVisibleLeafColumns`,()=>e.getRightLeafColumns()),e.getCenterVisibleLeafColumns=t(`getCenterVisibleLeafColumns`,()=>e.getCenterLeafColumns()),e.setColumnVisibility=t=>e.options.onColumnVisibilityChange==null?void 0:e.options.onColumnVisibilityChange(t),e.resetColumnVisibility=t=>{e.setColumnVisibility(t?{}:e.initialState.columnVisibility??{})},e.toggleAllColumnsVisible=t=>{t??=!e.getIsAllColumnsVisible(),e.setColumnVisibility(e.getAllLeafColumns().reduce((e,n)=>({...e,[n.id]:t||!(n.getCanHide!=null&&n.getCanHide())}),{}))},e.getIsAllColumnsVisible=()=>!e.getAllLeafColumns().some(e=>!(e.getIsVisible!=null&&e.getIsVisible())),e.getIsSomeColumnsVisible=()=>e.getAllLeafColumns().some(e=>e.getIsVisible==null?void 0:e.getIsVisible()),e.getToggleAllColumnsVisibilityHandler=()=>t=>{e.toggleAllColumnsVisible(t.target?.checked)}}};function rS(e,t){return t?t===`center`?e.getCenterVisibleLeafColumns():t===`left`?e.getLeftVisibleLeafColumns():e.getRightVisibleLeafColumns():e.getVisibleLeafColumns()}var iS={createTable:e=>{e._getGlobalFacetedRowModel=e.options.getFacetedRowModel&&e.options.getFacetedRowModel(e,`__global__`),e.getGlobalFacetedRowModel=()=>e.options.manualFiltering||!e._getGlobalFacetedRowModel?e.getPreFilteredRowModel():e._getGlobalFacetedRowModel(),e._getGlobalFacetedUniqueValues=e.options.getFacetedUniqueValues&&e.options.getFacetedUniqueValues(e,`__global__`),e.getGlobalFacetedUniqueValues=()=>e._getGlobalFacetedUniqueValues?e._getGlobalFacetedUniqueValues():new Map,e._getGlobalFacetedMinMaxValues=e.options.getFacetedMinMaxValues&&e.options.getFacetedMinMaxValues(e,`__global__`),e.getGlobalFacetedMinMaxValues=()=>{if(e._getGlobalFacetedMinMaxValues)return e._getGlobalFacetedMinMaxValues()}}},aS={getInitialState:e=>({globalFilter:void 0,...e}),getDefaultOptions:e=>({onGlobalFilterChange:vx(`globalFilter`,e),globalFilterFn:`auto`,getColumnCanGlobalFilter:t=>{var n;let r=(n=e.getCoreRowModel().flatRows[0])==null||(n=n._getAllCellsByColumnId()[t.id])==null?void 0:n.getValue();return typeof r==`string`||typeof r==`number`}}),createColumn:(e,t)=>{e.getCanGlobalFilter=()=>(e.columnDef.enableGlobalFilter??!0)&&(t.options.enableGlobalFilter??!0)&&(t.options.enableFilters??!0)&&((t.options.getColumnCanGlobalFilter==null?void 0:t.options.getColumnCanGlobalFilter(e))??!0)&&!!e.accessorFn},createTable:e=>{e.getGlobalAutoFilterFn=()=>zx.includesString,e.getGlobalFilterFn=()=>{let{globalFilterFn:t}=e.options;return yx(t)?t:t===`auto`?e.getGlobalAutoFilterFn():e.options.filterFns?.[t]??zx[t]},e.setGlobalFilter=t=>{e.options.onGlobalFilterChange==null||e.options.onGlobalFilterChange(t)},e.resetGlobalFilter=t=>{e.setGlobalFilter(t?void 0:e.initialState.globalFilter)}}},oS={getInitialState:e=>({expanded:{},...e}),getDefaultOptions:e=>({onExpandedChange:vx(`expanded`,e),paginateExpandedRows:!0}),createTable:e=>{let t=!1,n=!1;e._autoResetExpanded=()=>{if(!t){e._queue(()=>{t=!0});return}if(e.options.autoResetAll??e.options.autoResetExpanded??!e.options.manualExpanding){if(n)return;n=!0,e._queue(()=>{e.resetExpanded(),n=!1})}},e.setExpanded=t=>e.options.onExpandedChange==null?void 0:e.options.onExpandedChange(t),e.toggleAllRowsExpanded=t=>{t??!e.getIsAllRowsExpanded()?e.setExpanded(!0):e.setExpanded({})},e.resetExpanded=t=>{e.setExpanded(t?{}:e.initialState?.expanded??{})},e.getCanSomeRowsExpand=()=>e.getPrePaginationRowModel().flatRows.some(e=>e.getCanExpand()),e.getToggleAllRowsExpandedHandler=()=>t=>{t.persist==null||t.persist(),e.toggleAllRowsExpanded()},e.getIsSomeRowsExpanded=()=>{let t=e.getState().expanded;return t===!0||Object.values(t).some(Boolean)},e.getIsAllRowsExpanded=()=>{let t=e.getState().expanded;return typeof t==`boolean`?t===!0:!(!Object.keys(t).length||e.getRowModel().flatRows.some(e=>!e.getIsExpanded()))},e.getExpandedDepth=()=>{let t=0;return(e.getState().expanded===!0?Object.keys(e.getRowModel().rowsById):Object.keys(e.getState().expanded)).forEach(e=>{let n=e.split(`.`);t=Math.max(t,n.length)}),t},e.getPreExpandedRowModel=()=>e.getSortedRowModel(),e.getExpandedRowModel=()=>(!e._getExpandedRowModel&&e.options.getExpandedRowModel&&(e._getExpandedRowModel=e.options.getExpandedRowModel(e)),e.options.manualExpanding||!e._getExpandedRowModel?e.getPreExpandedRowModel():e._getExpandedRowModel())},createRow:(e,t)=>{e.toggleExpanded=n=>{t.setExpanded(r=>{let i=r===!0||!!(r!=null&&r[e.id]),a={};if(r===!0?Object.keys(t.getRowModel().rowsById).forEach(e=>{a[e]=!0}):a=r,n??=!i,!i&&n)return{...a,[e.id]:!0};if(i&&!n){let{[e.id]:t,...n}=a;return n}return r})},e.getIsExpanded=()=>{let n=t.getState().expanded;return!!((t.options.getIsRowExpanded==null?void 0:t.options.getIsRowExpanded(e))??(n===!0||n?.[e.id]))},e.getCanExpand=()=>{var n;return(t.options.getRowCanExpand==null?void 0:t.options.getRowCanExpand(e))??((t.options.enableExpanding??!0)&&!!((n=e.subRows)!=null&&n.length))},e.getIsAllParentsExpanded=()=>{let n=!0,r=e;for(;n&&r.parentId;)r=t.getRow(r.parentId,!0),n=r.getIsExpanded();return n},e.getToggleExpandedHandler=()=>{let t=e.getCanExpand();return()=>{t&&e.toggleExpanded()}}}},sS=0,cS=10,lS=()=>({pageIndex:sS,pageSize:cS}),uS={getInitialState:e=>({...e,pagination:{...lS(),...e?.pagination}}),getDefaultOptions:e=>({onPaginationChange:vx(`pagination`,e)}),createTable:e=>{let t=!1,n=!1;e._autoResetPageIndex=()=>{if(!t){e._queue(()=>{t=!0});return}if(e.options.autoResetAll??e.options.autoResetPageIndex??!e.options.manualPagination){if(n)return;n=!0,e._queue(()=>{e.resetPageIndex(),n=!1})}},e.setPagination=t=>e.options.onPaginationChange==null?void 0:e.options.onPaginationChange(e=>_x(t,e)),e.resetPagination=t=>{e.setPagination(t?lS():e.initialState.pagination??lS())},e.setPageIndex=t=>{e.setPagination(n=>{let r=_x(t,n.pageIndex),i=e.options.pageCount===void 0||e.options.pageCount===-1?2**53-1:e.options.pageCount-1;return r=Math.max(0,Math.min(r,i)),{...n,pageIndex:r}})},e.resetPageIndex=t=>{var n;e.setPageIndex(t?sS:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageIndex)??sS)},e.resetPageSize=t=>{var n;e.setPageSize(t?cS:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageSize)??cS)},e.setPageSize=t=>{e.setPagination(e=>{let n=Math.max(1,_x(t,e.pageSize)),r=e.pageSize*e.pageIndex,i=Math.floor(r/n);return{...e,pageIndex:i,pageSize:n}})},e.setPageCount=t=>e.setPagination(n=>{let r=_x(t,e.options.pageCount??-1);return typeof r==`number`&&(r=Math.max(-1,r)),{...n,pageCount:r}}),e.getPageOptions=Q(()=>[e.getPageCount()],e=>{let t=[];return e&&e>0&&(t=[...Array(e)].fill(null).map((e,t)=>t)),t},$(e.options,`debugTable`,`getPageOptions`)),e.getCanPreviousPage=()=>e.getState().pagination.pageIndex>0,e.getCanNextPage=()=>{let{pageIndex:t}=e.getState().pagination,n=e.getPageCount();return n===-1||n!==0&&t<n-1},e.previousPage=()=>e.setPageIndex(e=>e-1),e.nextPage=()=>e.setPageIndex(e=>e+1),e.firstPage=()=>e.setPageIndex(0),e.lastPage=()=>e.setPageIndex(e.getPageCount()-1),e.getPrePaginationRowModel=()=>e.getExpandedRowModel(),e.getPaginationRowModel=()=>(!e._getPaginationRowModel&&e.options.getPaginationRowModel&&(e._getPaginationRowModel=e.options.getPaginationRowModel(e)),e.options.manualPagination||!e._getPaginationRowModel?e.getPrePaginationRowModel():e._getPaginationRowModel()),e.getPageCount=()=>e.options.pageCount??Math.ceil(e.getRowCount()/e.getState().pagination.pageSize),e.getRowCount=()=>e.options.rowCount??e.getPrePaginationRowModel().rows.length}},dS=()=>({top:[],bottom:[]}),fS={getInitialState:e=>({rowPinning:dS(),...e}),getDefaultOptions:e=>({onRowPinningChange:vx(`rowPinning`,e)}),createRow:(e,t)=>{e.pin=(n,r,i)=>{let a=r?e.getLeafRows().map(e=>{let{id:t}=e;return t}):[],o=i?e.getParentRows().map(e=>{let{id:t}=e;return t}):[],s=new Set([...o,e.id,...a]);t.setRowPinning(e=>n===`bottom`?{top:(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),bottom:[...(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e))),...Array.from(s)]}:n===`top`?{top:[...(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),...Array.from(s)],bottom:(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e)))}:{top:(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),bottom:(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e)))})},e.getCanPin=()=>{let{enableRowPinning:n,enablePinning:r}=t.options;return typeof n==`function`?n(e):n??r??!0},e.getIsPinned=()=>{let n=[e.id],{top:r,bottom:i}=t.getState().rowPinning,a=n.some(e=>r?.includes(e)),o=n.some(e=>i?.includes(e));return a?`top`:o?`bottom`:!1},e.getPinnedIndex=()=>{let n=e.getIsPinned();return n?((n===`top`?t.getTopRows():t.getBottomRows())?.map(e=>{let{id:t}=e;return t}))?.indexOf(e.id)??-1:-1}},createTable:e=>{e.setRowPinning=t=>e.options.onRowPinningChange==null?void 0:e.options.onRowPinningChange(t),e.resetRowPinning=t=>e.setRowPinning(t?dS():e.initialState?.rowPinning??dS()),e.getIsSomeRowsPinned=t=>{let n=e.getState().rowPinning;return t?!!n[t]?.length:!!(n.top?.length||n.bottom?.length)},e._getPinnedRows=(t,n,r)=>(e.options.keepPinnedRows??!0?(n??[]).map(t=>{let n=e.getRow(t,!0);return n.getIsAllParentsExpanded()?n:null}):(n??[]).map(e=>t.find(t=>t.id===e))).filter(Boolean).map(e=>({...e,position:r})),e.getTopRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.top],(t,n)=>e._getPinnedRows(t,n,`top`),$(e.options,`debugRows`,`getTopRows`)),e.getBottomRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.bottom],(t,n)=>e._getPinnedRows(t,n,`bottom`),$(e.options,`debugRows`,`getBottomRows`)),e.getCenterRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.top,e.getState().rowPinning.bottom],(e,t,n)=>{let r=new Set([...t??[],...n??[]]);return e.filter(e=>!r.has(e.id))},$(e.options,`debugRows`,`getCenterRows`))}},pS={getInitialState:e=>({rowSelection:{},...e}),getDefaultOptions:e=>({onRowSelectionChange:vx(`rowSelection`,e),enableRowSelection:!0,enableMultiRowSelection:!0,enableSubRowSelection:!0}),createTable:e=>{e.setRowSelection=t=>e.options.onRowSelectionChange==null?void 0:e.options.onRowSelectionChange(t),e.resetRowSelection=t=>e.setRowSelection(t?{}:e.initialState.rowSelection??{}),e.toggleAllRowsSelected=t=>{e.setRowSelection(n=>{t=t===void 0?!e.getIsAllRowsSelected():t;let r={...n},i=e.getPreGroupedRowModel().flatRows;return t?i.forEach(e=>{e.getCanSelect()&&(r[e.id]=!0)}):i.forEach(e=>{delete r[e.id]}),r})},e.toggleAllPageRowsSelected=t=>e.setRowSelection(n=>{let r=t===void 0?!e.getIsAllPageRowsSelected():t,i={...n};return e.getRowModel().rows.forEach(t=>{mS(i,t.id,r,!0,e)}),i}),e.getPreSelectedRowModel=()=>e.getCoreRowModel(),e.getSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getCoreRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getSelectedRowModel`)),e.getFilteredSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getFilteredRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getFilteredSelectedRowModel`)),e.getGroupedSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getSortedRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getGroupedSelectedRowModel`)),e.getIsAllRowsSelected=()=>{let t=e.getFilteredRowModel().flatRows,{rowSelection:n}=e.getState(),r=!!(t.length&&Object.keys(n).length);return r&&t.some(e=>e.getCanSelect()&&!n[e.id])&&(r=!1),r},e.getIsAllPageRowsSelected=()=>{let t=e.getPaginationRowModel().flatRows.filter(e=>e.getCanSelect()),{rowSelection:n}=e.getState(),r=!!t.length;return r&&t.some(e=>!n[e.id])&&(r=!1),r},e.getIsSomeRowsSelected=()=>{let t=Object.keys(e.getState().rowSelection??{}).length;return t>0&&t<e.getFilteredRowModel().flatRows.length},e.getIsSomePageRowsSelected=()=>{let t=e.getPaginationRowModel().flatRows;return!e.getIsAllPageRowsSelected()&&t.filter(e=>e.getCanSelect()).some(e=>e.getIsSelected()||e.getIsSomeSelected())},e.getToggleAllRowsSelectedHandler=()=>t=>{e.toggleAllRowsSelected(t.target.checked)},e.getToggleAllPageRowsSelectedHandler=()=>t=>{e.toggleAllPageRowsSelected(t.target.checked)}},createRow:(e,t)=>{e.toggleSelected=(n,r)=>{let i=e.getIsSelected();t.setRowSelection(a=>{if(n=n===void 0?!i:n,e.getCanSelect()&&i===n)return a;let o={...a};return mS(o,e.id,n,r?.selectChildren??!0,t),o})},e.getIsSelected=()=>{let{rowSelection:n}=t.getState();return gS(e,n)},e.getIsSomeSelected=()=>{let{rowSelection:n}=t.getState();return _S(e,n)===`some`},e.getIsAllSubRowsSelected=()=>{let{rowSelection:n}=t.getState();return _S(e,n)===`all`},e.getCanSelect=()=>typeof t.options.enableRowSelection==`function`?t.options.enableRowSelection(e):t.options.enableRowSelection??!0,e.getCanSelectSubRows=()=>typeof t.options.enableSubRowSelection==`function`?t.options.enableSubRowSelection(e):t.options.enableSubRowSelection??!0,e.getCanMultiSelect=()=>typeof t.options.enableMultiRowSelection==`function`?t.options.enableMultiRowSelection(e):t.options.enableMultiRowSelection??!0,e.getToggleSelectedHandler=()=>{let t=e.getCanSelect();return n=>{t&&e.toggleSelected(n.target?.checked)}}}},mS=(e,t,n,r,i)=>{var a;let o=i.getRow(t,!0);n?(o.getCanMultiSelect()||Object.keys(e).forEach(t=>delete e[t]),o.getCanSelect()&&(e[t]=!0)):delete e[t],r&&(a=o.subRows)!=null&&a.length&&o.getCanSelectSubRows()&&o.subRows.forEach(t=>mS(e,t.id,n,r,i))};function hS(e,t){let n=e.getState().rowSelection,r=[],i={},a=function(e,t){return e.map(e=>{var t;let o=gS(e,n);if(o&&(r.push(e),i[e.id]=e),(t=e.subRows)!=null&&t.length&&(e={...e,subRows:a(e.subRows)}),o)return e}).filter(Boolean)};return{rows:a(t.rows),flatRows:r,rowsById:i}}function gS(e,t){return t[e.id]??!1}function _S(e,t,n){var r;if(!((r=e.subRows)!=null&&r.length))return!1;let i=!0,a=!1;return e.subRows.forEach(e=>{if(!(a&&!i)&&(e.getCanSelect()&&(gS(e,t)?a=!0:i=!1),e.subRows&&e.subRows.length)){let n=_S(e,t);n===`all`?a=!0:(n===`some`&&(a=!0),i=!1)}}),i?`all`:a?`some`:!1}var vS=/([0-9]+)/gm,yS=(e,t,n)=>DS(ES(e.getValue(n)).toLowerCase(),ES(t.getValue(n)).toLowerCase()),bS=(e,t,n)=>DS(ES(e.getValue(n)),ES(t.getValue(n))),xS=(e,t,n)=>TS(ES(e.getValue(n)).toLowerCase(),ES(t.getValue(n)).toLowerCase()),SS=(e,t,n)=>TS(ES(e.getValue(n)),ES(t.getValue(n))),CS=(e,t,n)=>{let r=e.getValue(n),i=t.getValue(n);return r>i?1:r<i?-1:0},wS=(e,t,n)=>TS(e.getValue(n),t.getValue(n));function TS(e,t){return e===t?0:e>t?1:-1}function ES(e){return typeof e==`number`?isNaN(e)||e===1/0||e===-1/0?``:String(e):typeof e==`string`?e:``}function DS(e,t){let n=e.split(vS).filter(Boolean),r=t.split(vS).filter(Boolean);for(;n.length&&r.length;){let e=n.shift(),t=r.shift(),i=parseInt(e,10),a=parseInt(t,10),o=[i,a].sort();if(isNaN(o[0])){if(e>t)return 1;if(t>e)return-1;continue}if(isNaN(o[1]))return isNaN(i)?-1:1;if(i>a)return 1;if(a>i)return-1}return n.length-r.length}var OS={alphanumeric:yS,alphanumericCaseSensitive:bS,text:xS,textCaseSensitive:SS,datetime:CS,basic:wS},kS=[Ex,nS,Kx,Jx,kx,Vx,iS,aS,{getInitialState:e=>({sorting:[],...e}),getDefaultColumnDef:()=>({sortingFn:`auto`,sortUndefined:1}),getDefaultOptions:e=>({onSortingChange:vx(`sorting`,e),isMultiSortEvent:e=>e.shiftKey}),createColumn:(e,t)=>{e.getAutoSortingFn=()=>{let n=t.getFilteredRowModel().flatRows.slice(10),r=!1;for(let t of n){let n=t?.getValue(e.id);if(Object.prototype.toString.call(n)===`[object Date]`)return OS.datetime;if(typeof n==`string`&&(r=!0,n.split(vS).length>1))return OS.alphanumeric}return r?OS.text:OS.basic},e.getAutoSortDir=()=>typeof t.getFilteredRowModel().flatRows[0]?.getValue(e.id)==`string`?`asc`:`desc`,e.getSortingFn=()=>{if(!e)throw Error();return yx(e.columnDef.sortingFn)?e.columnDef.sortingFn:e.columnDef.sortingFn===`auto`?e.getAutoSortingFn():t.options.sortingFns?.[e.columnDef.sortingFn]??OS[e.columnDef.sortingFn]},e.toggleSorting=(n,r)=>{let i=e.getNextSortingOrder(),a=n!=null;t.setSorting(o=>{let s=o?.find(t=>t.id===e.id),c=o?.findIndex(t=>t.id===e.id),l=[],u,d=a?n:i===`desc`;return u=o!=null&&o.length&&e.getCanMultiSort()&&r?s?`toggle`:`add`:o!=null&&o.length&&c!==o.length-1?`replace`:s?`toggle`:`replace`,u===`toggle`&&(a||i||(u=`remove`)),u===`add`?(l=[...o,{id:e.id,desc:d}],l.splice(0,l.length-(t.options.maxMultiSortColCount??2**53-1))):l=u===`toggle`?o.map(t=>t.id===e.id?{...t,desc:d}:t):u===`remove`?o.filter(t=>t.id!==e.id):[{id:e.id,desc:d}],l})},e.getFirstSortDir=()=>e.columnDef.sortDescFirst??t.options.sortDescFirst??e.getAutoSortDir()===`desc`?`desc`:`asc`,e.getNextSortingOrder=n=>{let r=e.getFirstSortDir(),i=e.getIsSorted();return i?i!==r&&(t.options.enableSortingRemoval??!0)&&(!n||(t.options.enableMultiRemove??!0))?!1:i===`desc`?`asc`:`desc`:r},e.getCanSort=()=>(e.columnDef.enableSorting??!0)&&(t.options.enableSorting??!0)&&!!e.accessorFn,e.getCanMultiSort=()=>e.columnDef.enableMultiSort??t.options.enableMultiSort??!!e.accessorFn,e.getIsSorted=()=>{let n=t.getState().sorting?.find(t=>t.id===e.id);return n?n.desc?`desc`:`asc`:!1},e.getSortIndex=()=>t.getState().sorting?.findIndex(t=>t.id===e.id)??-1,e.clearSorting=()=>{t.setSorting(t=>t!=null&&t.length?t.filter(t=>t.id!==e.id):[])},e.getToggleSortingHandler=()=>{let n=e.getCanSort();return r=>{n&&(r.persist==null||r.persist(),e.toggleSorting==null||e.toggleSorting(void 0,e.getCanMultiSort()?t.options.isMultiSortEvent==null?void 0:t.options.isMultiSortEvent(r):!1))}}},createTable:e=>{e.setSorting=t=>e.options.onSortingChange==null?void 0:e.options.onSortingChange(t),e.resetSorting=t=>{e.setSorting(t?[]:e.initialState?.sorting??[])},e.getPreSortedRowModel=()=>e.getGroupedRowModel(),e.getSortedRowModel=()=>(!e._getSortedRowModel&&e.options.getSortedRowModel&&(e._getSortedRowModel=e.options.getSortedRowModel(e)),e.options.manualSorting||!e._getSortedRowModel?e.getPreSortedRowModel():e._getSortedRowModel())}},Wx,oS,uS,fS,pS,Qx];function AS(e){let t=[...kS,...e._features??[]],n={_features:t},r=n._features.reduce((e,t)=>Object.assign(e,t.getDefaultOptions==null?void 0:t.getDefaultOptions(n)),{}),i=e=>n.options.mergeOptions?n.options.mergeOptions(r,e):{...r,...e},a={...e.initialState??{}};n._features.forEach(e=>{a=(e.getInitialState==null?void 0:e.getInitialState(a))??a});let o=[],s=!1,c={_features:t,options:{...r,...e},initialState:a,_queue:e=>{o.push(e),s||(s=!0,Promise.resolve().then(()=>{for(;o.length;)o.shift()();s=!1}).catch(e=>setTimeout(()=>{throw e})))},reset:()=>{n.setState(n.initialState)},setOptions:e=>{let t=_x(e,n.options);n.options=i(t)},getState:()=>n.options.state,setState:e=>{n.options.onStateChange==null||n.options.onStateChange(e)},_getRowId:(e,t,r)=>(n.options.getRowId==null?void 0:n.options.getRowId(e,t,r))??`${r?[r.id,t].join(`.`):t}`,getCoreRowModel:()=>(n._getCoreRowModel||=n.options.getCoreRowModel(n),n._getCoreRowModel()),getRowModel:()=>n.getPaginationRowModel(),getRow:(e,t)=>{let r=(t?n.getPrePaginationRowModel():n.getRowModel()).rowsById[e];if(!r&&(r=n.getCoreRowModel().rowsById[e],!r))throw Error();return r},_getDefaultColumnDef:Q(()=>[n.options.defaultColumn],e=>(e??={},{header:e=>{let t=e.header.column.columnDef;return t.accessorKey?t.accessorKey:t.accessorFn?t.id:null},cell:e=>{var t;return((t=e.renderValue())==null||t.toString==null?void 0:t.toString())??null},...n._features.reduce((e,t)=>Object.assign(e,t.getDefaultColumnDef==null?void 0:t.getDefaultColumnDef()),{}),...e}),$(e,`debugColumns`,`_getDefaultColumnDef`)),_getColumnDefs:()=>n.options.columns,getAllColumns:Q(()=>[n._getColumnDefs()],e=>{let t=function(e,r,i){return i===void 0&&(i=0),e.map(e=>{let a=Cx(n,e,i,r),o=e;return a.columns=o.columns?t(o.columns,a,i+1):[],a})};return t(e)},$(e,`debugColumns`,`getAllColumns`)),getAllFlatColumns:Q(()=>[n.getAllColumns()],e=>e.flatMap(e=>e.getFlatColumns()),$(e,`debugColumns`,`getAllFlatColumns`)),_getAllFlatColumnsById:Q(()=>[n.getAllFlatColumns()],e=>e.reduce((e,t)=>(e[t.id]=t,e),{}),$(e,`debugColumns`,`getAllFlatColumnsById`)),getAllLeafColumns:Q(()=>[n.getAllColumns(),n._getOrderColumnsFn()],(e,t)=>t(e.flatMap(e=>e.getLeafColumns())),$(e,`debugColumns`,`getAllLeafColumns`)),getColumn:e=>n._getAllFlatColumnsById()[e]};Object.assign(n,c);for(let e=0;e<n._features.length;e++){let t=n._features[e];t==null||t.createTable==null||t.createTable(n)}return n}function jS(){return e=>Q(()=>[e.options.data],t=>{let n={rows:[],flatRows:[],rowsById:{}},r=function(t,i,a){i===void 0&&(i=0);let o=[];for(let c=0;c<t.length;c++){let l=Ox(e,e._getRowId(t[c],c,a),t[c],c,i,void 0,a?.id);if(n.flatRows.push(l),n.rowsById[l.id]=l,o.push(l),e.options.getSubRows){var s;l.originalSubRows=e.options.getSubRows(t[c],c),(s=l.originalSubRows)!=null&&s.length&&(l.subRows=r(l.originalSubRows,i+1,l))}}return o};return n.rows=r(t),n},$(e.options,`debugTable`,`getRowModel`,()=>e._autoResetPageIndex()))}function MS(){return e=>Q(()=>[e.getState().sorting,e.getPreSortedRowModel()],(t,n)=>{if(!n.rows.length||!(t!=null&&t.length))return n;let r=e.getState().sorting,i=[],a=r.filter(t=>e.getColumn(t.id)?.getCanSort()),o={};a.forEach(t=>{let n=e.getColumn(t.id);n&&(o[t.id]={sortUndefined:n.columnDef.sortUndefined,invertSorting:n.columnDef.invertSorting,sortingFn:n.getSortingFn()})});let s=e=>{let t=e.map(e=>({...e}));return t.sort((e,t)=>{for(let n=0;n<a.length;n+=1){let r=a[n],i=o[r.id],s=i.sortUndefined,c=r?.desc??!1,l=0;if(s){let n=e.getValue(r.id),i=t.getValue(r.id),a=n===void 0,o=i===void 0;if(a||o){if(s===`first`)return a?-1:1;if(s===`last`)return a?1:-1;l=a&&o?0:a?s:-s}}if(l===0&&(l=i.sortingFn(e,t,r.id)),l!==0)return c&&(l*=-1),i.invertSorting&&(l*=-1),l}return e.index-t.index}),t.forEach(e=>{var t;i.push(e),(t=e.subRows)!=null&&t.length&&(e.subRows=s(e.subRows))}),t};return{rows:s(n.rows),flatRows:i,rowsById:n.rowsById}},$(e.options,`debugTable`,`getSortedRowModel`,()=>e._autoResetPageIndex()))}function NS(){return!0}var PS=Symbol(`merge-proxy`),FS={get(e,t,n){return t===PS?n:e.get(t)},has(e,t){return e.has(t)},set:NS,deleteProperty:NS,getOwnPropertyDescriptor(e,t){return{configurable:!0,enumerable:!0,get(){return e.get(t)},set:NS,deleteProperty:NS}},ownKeys(e){return e.keys()}};function IS(e){return`value`in e?e.value:e}function LS(){var e=[...arguments];return new Proxy({get(t){for(let n=e.length-1;n>=0;n--){let r=IS(e[n])[t];if(r!==void 0)return r}},has(t){for(let n=e.length-1;n>=0;n--)if(t in IS(e[n]))return!0;return!1},keys(){let t=[];for(let n=0;n<e.length;n++)t.push(...Object.keys(IS(e[n])));return[...Array.from(new Set(t))]}},FS)}var RS=F({props:[`render`,`props`],setup:e=>()=>typeof e.render==`function`||typeof e.render==`object`?tc(e.render,e.props):e.render});function zS(e){return LS(e,{data:N(e.data)})}function BS(e){let t=j(e.data),n=AS(LS({state:{},onStateChange:()=>{},renderFallbackValue:null,mergeOptions(e,n){return t?{...e,...n}:LS(e,n)}},t?zS(e):e));if(t){let t=un(e.data);Er(t,()=>{n.setState(e=>({...e,data:t.value}))},{immediate:!0})}let r=M(n.initialState);return Cr(()=>{n.setOptions(n=>{let i=new Proxy({},{get:(e,t)=>r.value[t]});return LS(n,t?zS(e):e,{state:LS(i,e.state??{}),onStateChange:t=>{t instanceof Function?r.value=t(r.value):r.value=t,e.onStateChange==null||e.onStateChange(t)}})})}),n}var VS=[`aria-label`],HS=F({__name:`SortHeaderButton`,props:{header:{}},setup(e){let t=e,n=W(()=>t.header.column.getIsSorted()),r=W(()=>n.value===`asc`?o_:n.value===`desc`?y_:f_),i=W(()=>{let e=t.header.column.columnDef.header;return typeof e==`string`?e:t.header.column.id}),a=W(()=>{let e=n.value===`asc`?`ascending`:n.value===`desc`?`descending`:`none`;return`Sort by ${i.value}, currently ${e}`});function o(){t.header.column.toggleSorting(n.value===`asc`)}return(t,i)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`button`,{type:`button`,"aria-label":a.value,class:`inline-flex items-center gap-1 rounded px-1.5 py-0.5 hover:text-foreground focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring`,onClick:o},[e.header.isPlaceholder?Ts(``,!0):(R(),B(N(RS),{key:0,render:e.header.column.columnDef.header,props:e.header.getContext()},null,8,[`render`,`props`])),H(s,{icon:r.value,class:O([`size-3 shrink-0`,n.value?`text-foreground`:`text-muted-foreground/60`]),"aria-hidden":`true`},null,8,[`icon`,`class`])],8,VS)}}}),US={"data-slot":`table-container`,class:`relative w-full overflow-x-auto`},WS=F({__name:`Table`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,US,[V(`table`,{"data-slot":`table`,class:O(N(Z)(`w-full caption-bottom text-sm`,t.class))},[I(e.$slots,`default`)],2)]))}}),GS=F({__name:`TableBody`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`tbody`,{"data-slot":`table-body`,class:O(N(Z)(`[&_tr:last-child]:border-0`,t.class))},[I(e.$slots,`default`)],2))}}),KS=F({__name:`TableCell`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`td`,{"data-slot":`table-cell`,class:O(N(Z)(`p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[I(e.$slots,`default`)],2))}}),qS=F({__name:`TableRow`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`tr`,{"data-slot":`table-row`,class:O(N(Z)(`hover:bg-muted/50 data-[state=selected]:bg-muted border-b transition-colors has-aria-expanded:bg-muted/50`,t.class))},[I(e.$slots,`default`)],2))}}),JS={class:`flex items-center justify-center py-10`},YS=F({__name:`TableEmpty`,props:{class:{type:[Boolean,null,String,Object,Array]},colspan:{default:1}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(qS,null,{default:P(()=>[H(KS,ks({class:N(Z)(`p-4 whitespace-nowrap align-middle text-sm text-foreground`,t.class)},N(n)),{default:P(()=>[V(`div`,JS,[I(e.$slots,`default`)])]),_:3},16,[`class`])]),_:3}))}}),XS=F({__name:`TableHead`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`th`,{"data-slot":`table-head`,class:O(N(Z)(`text-foreground h-10 px-2 text-left align-middle font-medium whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[I(e.$slots,`default`)],2))}}),ZS=F({__name:`TableHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`thead`,{"data-slot":`table-header`,class:O(N(Z)(`[&_tr]:border-b`,t.class))},[I(e.$slots,`default`)],2))}});function QS(e,t){t.value=typeof e==`function`?e(t.value):e}var $S=F({__name:`DataTable`,props:{columns:{},data:{},rowClass:{type:Function},emptyMessage:{}},setup(e){let t=e,n=M([]),r=BS({get data(){return t.data},get columns(){return t.columns},getCoreRowModel:jS(),getSortedRowModel:MS(),onSortingChange:e=>QS(e,n),state:{get sorting(){return n.value}}});function i(e){if(e===`asc`)return`ascending`;if(e===`desc`)return`descending`}return(t,n)=>(R(),B(N(WS),null,{default:P(()=>[H(N(ZS),null,{default:P(()=>[(R(!0),z(L,null,ma(N(r).getHeaderGroups(),e=>(R(),B(N(qS),{key:e.id},{default:P(()=>[(R(!0),z(L,null,ma(e.headers,e=>(R(),B(N(XS),{key:e.id,class:O(e.column.columnDef.meta?.align===`right`?`text-right`:void 0),"aria-sort":e.column.getCanSort()?i(e.column.getIsSorted())??`none`:void 0},{default:P(()=>[e.column.getCanSort()?(R(),B(HS,{key:0,header:e,class:`-mx-1.5`},null,8,[`header`])):e.isPlaceholder?Ts(``,!0):(R(),B(N(RS),{key:1,render:e.column.columnDef.header,props:e.getContext()},null,8,[`render`,`props`]))]),_:2},1032,[`class`,`aria-sort`]))),128))]),_:2},1024))),128))]),_:1}),H(N(GS),null,{default:P(()=>[N(r).getRowModel().rows.length===0?(R(),B(N(YS),{key:0,colspan:e.columns.length,class:`text-muted-foreground`},{default:P(()=>[U(k(e.emptyMessage??`none`),1)]),_:1},8,[`colspan`])):Ts(``,!0),(R(!0),z(L,null,ma(N(r).getRowModel().rows,t=>(R(),B(N(qS),{key:t.id,class:O(e.rowClass?.(t.original))},{default:P(()=>[(R(!0),z(L,null,ma(t.getVisibleCells(),e=>(R(),B(N(KS),{key:e.id,class:O(e.column.columnDef.meta?.align===`right`?`text-right tabular-nums`:void 0)},{default:P(()=>[H(N(RS),{render:e.column.columnDef.cell,props:e.getContext()},null,8,[`render`,`props`])]),_:2},1032,[`class`]))),128))]),_:2},1032,[`class`]))),128))]),_:1})]),_:1}))}}),eC=F({__name:`Badge`,props:{asChild:{type:Boolean},as:{},variant:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(r,i)=>(R(),B(N(nb),ks({"data-slot":`badge`,"data-variant":e.variant,class:N(Z)(N(tC)({variant:e.variant}),t.class)},N(n)),{default:P(()=>[I(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),tC=w_(`h-5 gap-1 rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium transition-all has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&>svg]:size-3! group/badge inline-flex w-fit shrink-0 items-center justify-center overflow-hidden whitespace-nowrap focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none`,{variants:{variant:{default:`bg-primary text-primary-foreground [a]:hover:bg-primary/80`,secondary:`bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80`,destructive:`bg-destructive/10 [a]:hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 text-destructive dark:bg-destructive/20`,outline:`border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground`,ghost:`hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50`,link:`text-primary underline-offset-4 hover:underline`}},defaultVariants:{variant:`default`}});async function nC(e,t){if(navigator.clipboard?.writeText)try{return await navigator.clipboard.writeText(e),`copied`}catch{}if(!t)return`failed`;let n=document.createRange();n.selectNodeContents(t);let r=window.getSelection();return r?(r.removeAllRanges(),r.addRange(n),`selected`):`failed`}var rC=`0001-01-01T00:00:00Z`;function iC(e,t){return`${e}/${t}`}function aC(e){return`$${(e/1e6).toFixed(4)}`}function oC(e){return e.toLocaleString(`en-US`)}function sC(e){let t=Math.abs(e);if(t<1e4)return oC(e);let n=e<0?`-`:``,[r,i]=t<1e6?[1e3,`k`]:t<1e9?[1e6,`M`]:[1e9,`B`],a=t/r,o=3-(Math.floor(a)>=100?3:Math.floor(a)>=10?2:1),s=10**o,c=(Math.floor(t*s/r)/s).toFixed(o);return o>0&&(c=c.replace(/0+$/,``).replace(/\.$/,``)),`${n}${c}${i}`}function cC(e){return e>0&&!(e&e-1)}function lC(e){return e<1024?`${e}`:cC(e)?e<1048576?`${Math.round(e/1024)}k`:`${Math.round(e/1048576)}M`:e<1e6?`${Math.round(e/1e3)}k`:`${Math.round(e/1e6)}M`}function uC(e){return`$${e.toFixed(2)}`}function dC(e,t){return e===0&&t===0?`free`:`in ${uC(e)} / out ${uC(t)} per MTok`}function fC(e){return e<1e3?`${Math.round(e)}ms`:`${(e/1e3).toFixed(1)}s`}function pC(e){if(!e||e===rC)return``;let t=new Date(e).getTime();return Number.isNaN(t)?``:` (${Math.max(0,Math.round((Date.now()-t)/1e3))}s ago)`}function mC(e){if(!e||e===rC)return``;let t=new Date(e).getTime();if(Number.isNaN(t))return``;let n=Math.round((t-Date.now())/1e3);return n<=0?``:`in ${n}s`}function hC(e){if(!e||e===rC)return`never`;let t=new Date(e);return Number.isNaN(t.getTime())?e:t.toLocaleString()}function gC(e,t){return e?pC(t)?`refreshed`:`pending`:`off`}function _C(e,t){switch(gC(e,t)){case`off`:return`discovery off`;case`pending`:return`pending`;case`refreshed`:return`refreshed${pC(t)}`}}function vC(e,t){switch(gC(e,t)){case`off`:return`discovery off`;case`pending`:return`pending`;case`refreshed`:return hC(t)}}function yC(e){if(!e)return`none`;let t=[];return e.requestsPerMinute&&t.push(`req/min ${e.requestsPerMinute}`),e.requestsPerDay&&t.push(`req/day ${e.requestsPerDay}`),e.tokensPerDay&&t.push(`tok/day ${e.tokensPerDay}`),e.tokensPerMonth&&t.push(`tok/month ${e.tokensPerMonth}`),e.costPerDayUSD&&t.push(`cost/day $${e.costPerDayUSD}`),e.costPerMonthUSD&&t.push(`cost/month $${e.costPerMonthUSD}`),t.length?t.join(`, `):`none`}function bC(e,t){switch(t){case`hour`:return`${e.slice(8,10)}:00`;case`day`:{let t=Number(e.slice(0,4)),n=Number(e.slice(4,6)),r=Number(e.slice(6,8));return new Date(t,n-1,r).toLocaleDateString(void 0,{month:`short`,day:`numeric`})}case`month`:{let t=Number(e.slice(0,4)),n=Number(e.slice(4,6));return new Date(t,n-1,1).toLocaleDateString(void 0,{month:`short`,year:`numeric`})}}}var xC=F({__name:`ModelChip`,props:{id:{},contextTokens:{},inputPerMTokUsd:{},outputPerMTokUsd:{}},setup(e){let t=e,n=si(`label`),r=M(`idle`),i;function a(){clearTimeout(i),i=setTimeout(()=>{r.value=`idle`},1500)}async function o(){let e=await nC(t.id,n.value??void 0);r.value=e,a()}let s={idle:__,copied:d_,selected:d_,failed:g_},c=W(()=>({idle:`Copy ${t.id}`,copied:`Copied`,selected:`Selected — press Ctrl/Cmd+C`,failed:`Copy failed`})),l=W(()=>{let e=[];return t.inputPerMTokUsd!==void 0&&t.outputPerMTokUsd!==void 0&&e.push(dC(t.inputPerMTokUsd,t.outputPerMTokUsd)),t.contextTokens!==void 0&&e.push(`${lC(t.contextTokens)} context`),e.join(` · `)}),u=W(()=>{let e=c.value[r.value];return l.value?`${e} · ${l.value}`:e});return ta(()=>{clearTimeout(i)}),(t,n)=>{let i=ca(`FontAwesomeIcon`);return R(),B(N(eC),{as:`button`,type:`button`,variant:`secondary`,class:O([`cursor-pointer gap-1 font-mono text-xs font-normal transition-colors hover:bg-accent hover:text-accent-foreground`,r.value===`failed`?`text-destructive`:``]),title:u.value,"aria-label":u.value,onClick:o},{default:P(()=>[V(`span`,{ref:`label`,class:`select-text`},k(e.id),513),H(i,{icon:s[r.value],class:`size-2.5 shrink-0`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`class`,`title`,`aria-label`])}}});function SC(e,t){return!Number.isFinite(e)||e<=0?null:(e-(Number.isFinite(t)?t:0))/e}function CC(e){return e===null?`no-traffic`:e<.9?`severe`:e<.99?`degraded`:`healthy`}function wC(e,t){let n=SC(e,t);return n!==null&&n<.99}function TC(e){return e>=1?`100%`:`${Math.floor(e*100)}%`}function EC(e,t,n){return e===1?t:n}function DC(e,t){if(e<=0)return`no traffic in the last minute`;let n=SC(e,t),r=n===null?``:` (${TC(n)})`;return`${e} ${EC(e,`attempt`,`attempts`)}, ${t} ${EC(t,`failure`,`failures`)} in the last minute${r}`}function OC(e,t){if(e<=0)return`no traffic today`;let n=SC(e,t),r=n===null?``:` (${TC(n)})`;return`${e} ${EC(e,`attempt`,`attempts`)}, ${t} ${EC(t,`failure`,`failures`)} today${r}`}var kC={"aria-hidden":`true`},AC={class:`sr-only`},jC=F({__name:`ProviderRateBadge`,props:{attemptsDay:{},failuresDay:{},attemptsMinute:{},failuresMinute:{}},setup(e){let t=e,n=W(()=>SC(t.attemptsDay,t.failuresDay)),r=W(()=>CC(n.value)),i=W(()=>r.value===`no-traffic`?`no traffic`:TC(n.value)),a=W(()=>t.attemptsMinute===void 0||t.failuresMinute===void 0?OC(t.attemptsDay,t.failuresDay):DC(t.attemptsMinute,t.failuresMinute)),o=W(()=>r.value===`severe`?`destructive`:r.value===`healthy`?`secondary`:`outline`),s=W(()=>r.value===`degraded`?`border-status-warn/40 text-status-warn`:r.value===`no-traffic`?`text-muted-foreground`:``);return(e,t)=>(R(),B(N(eC),{as:`span`,variant:o.value,class:O([s.value,`font-normal tabular-nums`]),title:a.value},{default:P(()=>[V(`span`,kC,k(i.value),1),V(`span`,AC,k(a.value),1)]),_:1},8,[`variant`,`class`,`title`]))}}),MC=F({__name:`SearchInput`,props:{modelValue:{},placeholder:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=W(()=>n.modelValue.length>0);function a(e){r(`update:modelValue`,String(e))}function o(){r(`update:modelValue`,``)}return(t,r)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`div`,{class:O(N(Z)(`relative`,n.class))},[H(s,{icon:N(i_),class:`pointer-events-none absolute top-1/2 left-2.5 size-3.5 -translate-y-1/2 text-muted-foreground`,"aria-hidden":`true`},null,8,[`icon`]),H(N(Qb),{"model-value":e.modelValue,type:`text`,placeholder:e.placeholder,"aria-label":e.placeholder,class:`pr-8 pl-8`,"onUpdate:modelValue":a},null,8,[`model-value`,`placeholder`,`aria-label`]),i.value?(R(),B(N(Wb),{key:0,type:`button`,variant:`ghost`,size:`icon-xs`,"aria-label":`Clear search`,class:`absolute top-1/2 right-1 -translate-y-1/2 text-muted-foreground hover:text-foreground`,onClick:o},{default:P(()=>[H(s,{icon:N(p_),class:`size-3.5`},null,8,[`icon`])]),_:1})):Ts(``,!0)],2)}}}),NC=F({__name:`Accordion`,props:{collapsible:{type:Boolean},disabled:{type:Boolean},dir:{},orientation:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},type:{},modelValue:{},defaultValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=qy(Cy(n,`class`),r);return(e,t)=>(R(),B(N(hb),ks({"data-slot":`accordion`},N(i),{class:N(Z)(`flex w-full flex-col`,n.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`class`]))}}),PC=F({__name:`AccordionContent`,props:{forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(N(bb),ks({"data-slot":`accordion-content`},N(n),{class:`data-open:animate-accordion-down data-closed:animate-accordion-up text-sm overflow-hidden`}),{default:P(()=>[V(`div`,{class:O(N(Z)(`pt-0 pb-2.5 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4`,t.class))},[I(e.$slots,`default`)],2)]),_:3},16))}}),FC=F({__name:`AccordionItem`,props:{disabled:{type:Boolean},value:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Ky(Cy(t,`class`));return(e,r)=>(R(),B(N(yb),ks({"data-slot":`accordion-item`},N(n),{class:N(Z)(`not-last:border-b`,t.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`class`]))}}),IC=F({__name:`AccordionTrigger`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>{let i=ca(`FontAwesomeIcon`);return R(),B(N(xb),{class:`flex`},{default:P(()=>[H(N(Sb),ks({"data-slot":`accordion-trigger`},N(n),{class:N(Z)(`focus-visible:ring-ring/50 focus-visible:border-ring focus-visible:after:border-ring **:data-[slot=accordion-trigger-icon]:text-muted-foreground rounded-lg py-2.5 text-left text-sm font-medium hover:underline focus-visible:ring-3 **:data-[slot=accordion-trigger-icon]:ml-auto **:data-[slot=accordion-trigger-icon]:size-4 group/accordion-trigger relative flex flex-1 items-start justify-between border border-transparent transition-all outline-none disabled:pointer-events-none disabled:opacity-50`,t.class)}),{default:P(()=>[I(e.$slots,`default`),I(e.$slots,`icon`,{},()=>[H(i,{icon:N(h_),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden`},null,8,[`icon`]),H(i,{icon:N(c_),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none hidden shrink-0 group-aria-expanded/accordion-trigger:inline`},null,8,[`icon`])])]),_:3},16,[`class`])]),_:3})}}});function LC(){let e=M(``),t=W(()=>e.value.trim().toLowerCase());return{query:e,normalized:t,hasQuery:W(()=>t.value.length>0)}}function RC(e,t,n){if(!t)return new Set(e.manuallyExpanded);let r=new Set(e.manuallyExpanded);for(let t of n)e.manuallyCollapsed.has(t)||r.add(t);return r}function zC(e,t,n){n?(e.manuallyExpanded.delete(t),e.manuallyCollapsed.add(t)):(e.manuallyCollapsed.delete(t),e.manuallyExpanded.add(t))}function BC(e){e.manuallyCollapsed.clear()}var VC={class:`flex flex-col gap-6`},HC={class:`grid gap-4 sm:grid-cols-3`},UC={class:`font-medium`},WC={key:0,class:`flex items-start gap-1.5 text-destructive`},GC={class:`font-medium`},KC={key:0,class:`text-muted-foreground`},qC={class:`font-medium`},JC={key:0,class:`text-muted-foreground`},YC={key:0,class:`py-6 text-center text-sm text-muted-foreground`},XC={key:1,class:`py-6 text-center text-sm text-muted-foreground`},ZC={class:`flex flex-1 flex-wrap items-center gap-x-3 gap-y-1 pr-2 text-left`},QC={class:`font-medium`},$C={class:`text-xs text-muted-foreground tabular-nums`},ew={class:`text-xs text-muted-foreground`},tw={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-3`},nw={class:`break-all`},rw={key:0},iw={key:1},aw={class:`text-destructive`},ow={key:0,class:`flex flex-wrap gap-1.5`},sw={key:0,title:`context window`,class:`text-xs text-muted-foreground tabular-nums`},cw={key:1,class:`text-sm text-muted-foreground`},lw={key:0,class:`text-xs text-muted-foreground`},uw=`Per-replica, in-process only — not a fleet-wide average across this deployment’s replicas.`,dw=F({__name:`ProvidersView`,setup(e){let t=sx(),n=W(()=>t.overview),r=Zt({manuallyExpanded:new Set,manuallyCollapsed:new Set}),{query:i,normalized:a,hasQuery:o}=LC();function s(e,t){return iC(e,t).toLowerCase().includes(a.value)}function c(e){return e.models.some(t=>s(e.name,t))}function l(e){return e.alias.toLowerCase().includes(a.value)||e.target.toLowerCase().includes(a.value)}let u=W(()=>{let e=n.value?.providers??[];return o.value?e.filter(c):e}),d=W(()=>{let e=n.value?.aliases??[];return o.value?e.filter(l):e}),f=W(()=>RC(r,o.value,u.value.map(e=>e.name)));function p(e){zC(r,e,f.value.has(e))}let m=W({get:()=>Array.from(f.value),set:e=>{let t=new Set(e);for(let e of f.value)t.has(e)||p(e);for(let e of t)f.value.has(e)||p(e)}});Er(i,e=>{e.trim()===``&&BC(r)});function h(e){return o.value?e.models.filter(t=>s(e.name,t)):e.models}let g={attemptsDay:0,failuresDay:0};function _(e,t){return e.modelRates?.[t]??g}function v(e,t){let n=_(e,t);return wC(n.attemptsDay,n.failuresDay)}let y={};function b(e,t){return e.modelMeta?.[t]??y}function x(e){switch(e){case`open`:return`destructive`;case`half-open`:return`secondary`;default:return}}function S(e){let t=mC(e.openUntil);return t?`${e.healthState} (${t})`:e.healthState}function C(e){return e===`open`?`text-destructive`:`text-muted-foreground`}function w(e){return e.latency?.streaming}function ee(e){return e.latency?.[`non-streaming`]}function te(e){return e.count===void 0?`no observations counted`:`${e.count} ${e.count===1?`observation`:`observations`} on this replica`}function T(e){return`Average time to first byte, the load-sensitive reading for streaming traffic. ${te(e)}. ${uw}`}function ne(e){return`Average total response time, including generation — not a load-sensitive signal like streaming ttfb, since this provider buffers the whole completion before sending anything. ${te(e)}. ${uw}`}function re(e){return e.provenance?.estimated}function ie(e){return e.provenance?.unbilled}function E(e){let t=e.requests===1?``:`s`;return`${e.requests} non-streaming response${t} carried no usage from the provider — prompt tokens were estimated from request body size instead (${e.tokens} tokens billed from the estimate), completion billed as zero. ${uw}`}function ae(e){let t=e.requests===1?``:`s`;return`${e.requests} streaming response${t} carried no usage from the provider — the request was counted but zero tokens were billed. If this keeps happening, this provider may be serving completions entirely free against every budget. ${uw}`}let oe=[{id:`alias`,header:`Alias`,accessorFn:e=>e.alias,cell:({row:e})=>tc(xC,{id:e.original.alias,contextTokens:e.original.modelMeta?.contextTokens,inputPerMTokUsd:e.original.modelMeta?.inputPerMTokUsd,outputPerMTokUsd:e.original.modelMeta?.outputPerMTokUsd})},{id:`target`,header:`Target`,accessorFn:e=>e.target,cell:({row:e})=>tc(`span`,{class:`text-muted-foreground`},e.original.target)}],se=W(()=>n.value?.aliases.length?o.value?`no aliases match "${i.value}"`:`none`:`none configured`);return(e,t)=>{let r=ca(`FontAwesomeIcon`);return R(),z(`div`,VC,[V(`div`,HC,[H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.redis.configured?N(m_):N(l_),class:O([n.value?.redis.configured?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[2]||=U(` Redis `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`flex flex-col gap-1 text-sm`},{default:P(()=>[V(`p`,UC,k(n.value?.redis.configured?`Configured`:`Not configured`),1),n.value?.redis.lastErr?(R(),z(`p`,WC,[H(r,{icon:N(g_),class:`mt-0.5 size-3.5 shrink-0`},null,8,[`icon`]),V(`span`,null,k(n.value.redis.lastErr)+k(N(pC)(n.value.redis.lastErrAt)),1)])):Ts(``,!0)]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.cache.enabled?N(m_):N(l_),class:O([n.value?.cache.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[3]||=U(` Response cache `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`text-sm`},{default:P(()=>[V(`p`,GC,k(n.value?.cache.enabled?`Enabled`:`Disabled`),1),n.value?.cache.enabled?(R(),z(`p`,KC,`ttl `+k(n.value.cache.ttl),1)):Ts(``,!0)]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.retry.enabled?N(m_):N(l_),class:O([n.value?.retry.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[4]||=U(` Retry `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`text-sm`},{default:P(()=>[V(`p`,qC,k(n.value?.retry.enabled?`Enabled`:`Disabled`),1),n.value?.retry.enabled?(R(),z(`p`,JC,` attempts `+k(n.value.retry.attempts)+`, backoff `+k(n.value.retry.backoff),1)):Ts(``,!0)]),_:1})]),_:1})]),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[5]||=[U(`Providers`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[6]||=[U(` Every configured upstream and its last discovery refresh. Search filters providers and aliases by model id. `,-1)]]),_:1}),H(MC,{modelValue:N(i),"onUpdate:modelValue":t[0]||=e=>j(i)?i.value=e:null,placeholder:`Search models or aliases...`,class:`mt-2 max-w-sm`},null,8,[`modelValue`])]),_:1}),H(N(Jb),null,{default:P(()=>[n.value?.providers.length?N(o)&&u.value.length===0?(R(),z(`p`,XC,` no providers match "`+k(N(i))+`" `,1)):(R(),B(N(NC),{key:2,modelValue:m.value,"onUpdate:modelValue":t[1]||=e=>m.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:P(()=>[(R(!0),z(L,null,ma(u.value,e=>(R(),B(N(FC),{key:e.name,value:e.name},{default:P(()=>[H(N(IC),null,{default:P(()=>[V(`span`,ZC,[V(`span`,QC,k(e.name),1),H(N(eC),{as:`span`,variant:`secondary`,class:`font-normal`},{default:P(()=>[U(k(e.type),1)]),_:2},1024),V(`span`,$C,k(e.modelCount)+` models`,1),H(jC,{"attempts-day":e.attemptsDay,"failures-day":e.failuresDay,"attempts-minute":e.attemptsMinute,"failures-minute":e.failuresMinute},null,8,[`attempts-day`,`failures-day`,`attempts-minute`,`failures-minute`]),e.healthState===`closed`?Ts(``,!0):(R(),B(N(eC),{key:0,as:`span`,variant:x(e.healthState),class:`font-normal`,title:e.healthState===`open`?`discovery is backing off after repeated failures`:`a discovery probe is deciding whether to recover`},{default:P(()=>[U(k(S(e)),1)]),_:2},1032,[`variant`,`title`])),w(e)?.avgTtfbMs===void 0?Ts(``,!0):(R(),B(N(eC),{key:1,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:T(w(e))},{default:P(()=>[U(` streaming ttfb `+k(N(fC)(w(e).avgTtfbMs)),1)]),_:2},1032,[`title`])),ee(e)?.avgDurationMs===void 0?Ts(``,!0):(R(),B(N(eC),{key:2,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:ne(ee(e))},{default:P(()=>[U(` non-streaming avg `+k(N(fC)(ee(e).avgDurationMs)),1)]),_:2},1032,[`title`])),re(e)?(R(),B(N(eC),{key:3,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:E(re(e))},{default:P(()=>[U(` estimated `+k(re(e).requests),1)]),_:2},1032,[`title`])):Ts(``,!0),ie(e)?(R(),B(N(eC),{key:4,as:`span`,variant:`destructive`,class:`font-normal tabular-nums`,title:ae(ie(e))},{default:P(()=>[U(` unbilled `+k(ie(e).requests),1)]),_:2},1032,[`title`])):Ts(``,!0),e.lastErr?(R(),B(r,{key:5,icon:N(g_),class:`size-3.5 shrink-0 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):Ts(``,!0),V(`span`,ew,k(N(_C)(e.discoveryEnabled,e.lastRefresh)),1)])]),_:2},1024),H(N(PC),null,{default:P(()=>[V(`dl`,tw,[V(`div`,null,[t[7]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Base URL`,-1),V(`dd`,nw,k(e.baseUrl),1)]),V(`div`,null,[t[8]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Last refresh`,-1),V(`dd`,null,k(N(vC)(e.discoveryEnabled,e.lastRefresh)),1)]),e.healthState===`closed`?Ts(``,!0):(R(),z(`div`,rw,[t[9]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Discovery health`,-1),V(`dd`,{class:O(C(e.healthState))},k(S(e)),3)])),e.lastErr?(R(),z(`div`,iw,[t[10]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Last error`,-1),V(`dd`,aw,k(e.lastErr),1)])):Ts(``,!0)]),h(e).length?(R(),z(`div`,ow,[(R(!0),z(L,null,ma(h(e),t=>(R(),z(`span`,{key:t,class:`inline-flex items-center gap-1`},[H(xC,{id:N(iC)(e.name,t),"context-tokens":b(e,t).contextTokens,"input-per-m-tok-usd":b(e,t).inputPerMTokUsd,"output-per-m-tok-usd":b(e,t).outputPerMTokUsd},null,8,[`id`,`context-tokens`,`input-per-m-tok-usd`,`output-per-m-tok-usd`]),b(e,t).contextTokens===void 0?Ts(``,!0):(R(),z(`span`,sw,k(N(lC)(b(e,t).contextTokens)),1)),v(e,t)?(R(),B(jC,{key:1,"attempts-day":_(e,t).attemptsDay,"failures-day":_(e,t).failuresDay},null,8,[`attempts-day`,`failures-day`])):Ts(``,!0)]))),128))])):(R(),z(`p`,cw,`no models known yet`))]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):(R(),z(`p`,YC,`none`))]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[11]||=[U(`Model aliases`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[12]||=[U(`Operator-defined alias → target model mappings.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:oe,data:d.value,"empty-message":se.value},null,8,[`data`,`empty-message`])]),_:1})]),_:1}),n.value?.version?(R(),z(`p`,lw,`Version: `+k(n.value.version),1)):Ts(``,!0)])}}}),fw=[`title`],pw={"aria-hidden":`true`},mw={class:`sr-only`},hw=F({__name:`CompactNumber`,props:{value:{}},setup(e){let t=e,n=W(()=>sC(t.value)),r=W(()=>oC(t.value));return(e,t)=>(R(),z(`span`,{title:r.value},[V(`span`,pw,k(n.value),1),V(`span`,mw,k(r.value),1)],8,fw))}});function gw(e,t,n){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>tc(hw,{value:n(e.original)})}}function _w(){return[{id:`name`,header:`Name`,accessorFn:e=>e.name,cell:({row:e})=>tc(`span`,{class:`font-medium`},e.original.name)},{id:`url`,header:`URL`,accessorFn:e=>e.url,cell:({row:e})=>tc(`span`,{class:`block max-w-xs truncate text-muted-foreground`,title:e.original.url},e.original.url)},{id:`access`,header:`Access`,enableSorting:!1,accessorFn:e=>(e.access??[]).join(`, `),cell:({row:e})=>{let t=e.original.access;return t?.length?tc(`div`,{class:`flex flex-wrap gap-1.5`},t.map(e=>tc(eC,{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},()=>e))):tc(`span`,{class:`text-muted-foreground`},`All groups`)}},gw(`reqMin`,`req/min`,e=>e.counters.requestsPerMinute),gw(`reqDay`,`req/day`,e=>e.counters.requestsPerDay),gw(`reqMonth`,`req/month`,e=>e.counters.requestsPerMonth)]}var vw={class:`flex flex-col gap-6`},yw=F({__name:`TargetsView`,setup(e){let t=sx(),n=W(()=>t.targets),{query:r,normalized:i,hasQuery:a}=LC();function o(e){return e.name.toLowerCase().includes(i.value)}let s=W(()=>{let e=n.value?.mcpServers??[];return a.value?e.filter(o):e}),c=W(()=>{let e=n.value?.agents??[];return a.value?e.filter(o):e});function l(e,t){return e?a.value&&t===0?`no targets match "${r.value}"`:`none`:`none configured`}let u=W(()=>l(n.value?.mcpServers.length??0,s.value.length)),d=W(()=>l(n.value?.agents.length??0,c.value.length)),f=_w();return(e,t)=>(R(),z(`div`,vw,[H(MC,{modelValue:N(r),"onUpdate:modelValue":t[0]||=e=>j(r)?r.value=e:null,placeholder:`Filter MCP servers or agents`,class:`max-w-sm`},null,8,[`modelValue`]),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[1]||=[U(`MCP servers`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[2]||=[U(`Configured MCP proxy targets, the groups allowed to reach them, and their request counters.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:N(f),data:s.value,"empty-message":u.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[3]||=[U(`Agents`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[4]||=[U(`Configured A2A agent proxy targets, the groups allowed to reach them, and their request counters.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:N(f),data:c.value,"empty-message":d.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1})]))}}),bw=F({__name:`Tabs`,props:{defaultValue:{},orientation:{},dir:{},activationMode:{},modelValue:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=qy(Cy(n,`class`),r);return(e,t)=>(R(),B(N(Rb),ks({"data-slot":`tabs`,"data-orientation":N(i).orientation||`horizontal`},N(i),{class:N(Z)(`gap-2 group/tabs flex data-horizontal:flex-col`,n.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`data-orientation`,`class`]))}}),xw=F({__name:`TabsContent`,props:{value:{},forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(N(Vb),ks({"data-slot":`tabs-content`,class:N(Z)(`text-sm flex-1 outline-none`,t.class)},N(n)),{default:P(()=>[I(e.$slots,`default`)]),_:3},16,[`class`]))}}),Sw=F({__name:`TabsList`,props:{loop:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]},variant:{default:`default`}},setup(e){let t=e,n=Cy(t,`class`,`variant`);return(r,i)=>(R(),B(N(Hb),ks({"data-slot":`tabs-list`,"data-variant":e.variant},N(n),{class:N(Z)(N(ww)({variant:e.variant}),t.class)}),{default:P(()=>[I(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),Cw=F({__name:`TabsTrigger`,props:{value:{},disabled:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Ky(Cy(t,`class`));return(e,r)=>(R(),B(N(Ub),ks({"data-slot":`tabs-trigger`,class:N(Z)(`gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg:not([class*=size-])]:size-4 has-data-[icon=inline-end]:pr-1 has-data-[icon=inline-start]:pl-1 relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center whitespace-nowrap text-foreground/60 transition-all group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 dark:text-muted-foreground dark:hover:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0`,`group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent`,`data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground`,`after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100`,t.class)},N(n)),{default:P(()=>[I(e.$slots,`default`)]),_:3},16,[`class`]))}}),ww=w_(`rounded-lg p-0.75 group-data-horizontal/tabs:h-8 data-[variant=line]:rounded-none group/tabs-list inline-flex w-fit items-center justify-center text-muted-foreground group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col`,{variants:{variant:{default:`bg-muted`,line:`gap-1 bg-transparent`}},defaultVariants:{variant:`default`}});function Tw(e,t,n,r=String,i=!0){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>{if(e.original.storeDown)return`?`;let t=n(e.original);return i?tc(hw,{value:t}):r(t)}}}function Ew(e,t,n){return[{id:`id`,header:e,accessorFn:e=>e.id,cell:({row:e})=>tc(`span`,{class:`font-medium`},e.original.id)},{id:`secondary`,header:t,accessorFn:n,cell:({row:e})=>tc(`span`,{class:`text-muted-foreground`},n(e.original))},{id:`limits`,header:`Limits`,accessorFn:e=>yC(e.limits),cell:({row:e})=>tc(`span`,{class:`text-muted-foreground`},yC(e.original.limits))},Tw(`reqMin`,`req/min`,e=>e.requestsPerMinute),Tw(`reqDay`,`req/day`,e=>e.requestsPerDay),Tw(`tokInDay`,`tokIn/day`,e=>e.tokensInPerDay),Tw(`tokOutDay`,`tokOut/day`,e=>e.tokensOutPerDay),Tw(`tokInMonth`,`tokIn/month`,e=>e.tokensInPerMonth),Tw(`tokOutMonth`,`tokOut/month`,e=>e.tokensOutPerMonth),Tw(`costDay`,`cost/day`,e=>e.costPerDayMicroUsd,aC,!1),Tw(`costMonth`,`cost/month`,e=>e.costPerMonthMicroUsd,aC,!1)]}var Dw=F({__name:`UsageTable`,props:{idLabel:{},entries:{},secondaryColumnLabel:{},secondaryValue:{type:Function},emptyMessage:{}},setup(e){let t=e,n=W(()=>Ew(t.idLabel,t.secondaryColumnLabel,t.secondaryValue));return(t,r)=>(R(),B($S,{columns:n.value,data:e.entries,"empty-message":e.emptyMessage,"row-class":e=>e.storeDown?`bg-destructive/10`:void 0},null,8,[`columns`,`data`,`empty-message`,`row-class`]))}});function Ow(e,t){return e.id.toLowerCase().includes(t)}function kw(e,t){return e.id.toLowerCase().includes(t)}function Aw(e,t){return t.filter(t=>t.groupName===e.id)}function jw(e,t,n){return Aw(e,t).filter(e=>Ow(e,n))}function Mw(e,t,n){return kw(e,n)||jw(e,t,n).length>0}var Nw={class:`flex flex-col gap-6`},Pw={class:`text-lg font-semibold tabular-nums`},Fw={class:`text-lg font-semibold tabular-nums`},Iw={class:`text-lg font-semibold tabular-nums`},Lw={class:`text-lg font-semibold tabular-nums`},Rw={key:0,class:`mb-3 flex flex-wrap gap-x-4 gap-y-1 text-xs font-medium text-muted-foreground`},zw={class:`flex flex-1 flex-wrap items-center gap-x-4 gap-y-1 pr-2 text-left`},Bw={class:`font-medium`},Vw={class:`text-xs text-muted-foreground tabular-nums`},Hw={class:`text-xs text-muted-foreground tabular-nums`},Uw={class:`text-xs text-muted-foreground tabular-nums`},Ww={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},Gw={key:0,class:`flex flex-wrap gap-1.5`},Kw={key:1,class:`text-muted-foreground`},qw={key:0,class:`flex flex-wrap gap-1.5`},Jw={key:1,class:`text-muted-foreground`},Yw={key:0,class:`flex flex-wrap gap-1.5`},Xw={key:1,class:`text-muted-foreground`},Zw={key:0,class:`flex flex-wrap gap-1.5`},Qw={key:1,class:`text-muted-foreground`},$w={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},eT={class:`tabular-nums`},tT={class:`tabular-nums`},nT={class:`tabular-nums`},rT={class:`tabular-nums`},iT={class:`tabular-nums`},aT={class:`tabular-nums`},oT={key:2,class:`py-6 text-center text-sm text-muted-foreground`},sT=`Glob pattern — matches like a shell wildcard (*, ?, [...])`,cT=F({__name:`UsageView`,setup(e){let t=sx(),n=W(()=>t.usage),r=W(()=>{let e={};for(let n of t.overview?.groups??[])e[n.name]=n.memberCount;return e});function i(e){return e.groupName??``}function a(e){let t=r.value[e.id];return t===void 0?``:String(t)}let{query:o,normalized:s,hasQuery:c}=LC(),l=W(()=>{let e=n.value?.groups??[];if(!c.value)return e;let t=n.value?.users??[];return e.filter(e=>Mw(e,t,s.value))}),u=W(()=>c.value?l.value.filter(e=>!kw(e,s.value)).map(e=>e.id):[]);function d(e){let t=n.value?.users??[];return!c.value||kw(e,s.value)?Aw(e,t):jw(e,t,s.value)}let f=W(()=>n.value?.groups.length?c.value?`no groups match "${o.value}"`:`none`:`none configured`),p=W(()=>{let e=n.value?.users??[];if(!c.value)return e;let t=n.value?.groups??[],r=new Set(t.filter(e=>kw(e,s.value)).map(e=>e.id));return e.filter(e=>Ow(e,s.value)||e.groupName!==void 0&&r.has(e.groupName))}),m=W(()=>n.value?.users.length?c.value?`no users match "${o.value}"`:`none`:`none configured`),h=Ew(`Name`,`Members`,a),g=M([]),_=BS({get data(){return l.value},get columns(){return h},getCoreRowModel:jS(),getSortedRowModel:MS(),onSortingChange:e=>QS(e,g),state:{get sorting(){return g.value}}}),v=W(()=>_.getRowModel().rows),y=new Set([`id`,`secondary`,`reqDay`,`costDay`]),b=W(()=>_.getHeaderGroups()[0].headers.filter(e=>y.has(e.column.id))),x=Zt({manuallyExpanded:new Set,manuallyCollapsed:new Set}),S=W(()=>RC(x,c.value,u.value));function C(e){zC(x,e,S.value.has(e))}let w=W({get:()=>Array.from(S.value),set:e=>{let t=new Set(e);for(let e of S.value)t.has(e)||C(e);for(let e of t)S.value.has(e)||C(e)}});Er(o,e=>{e.trim()===``&&BC(x)});function ee(e){return/[*?[]/.test(e)}return(e,t)=>(R(),z(`div`,Nw,[H(MC,{modelValue:N(o),"onUpdate:modelValue":t[0]||=e=>j(o)?o.value=e:null,placeholder:`Filter users or groups`,class:`max-w-sm`},null,8,[`modelValue`]),n.value?(R(),B(N(qb),{key:0},{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[2]||=[U(`Total`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[3]||=[U(`Usage summed across every user and group combined.`,-1)]]),_:1})]),_:1}),H(N(Jb),{class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-4`},{default:P(()=>[V(`div`,null,[t[4]||=V(`p`,{class:`text-muted-foreground`},`Requests/day`,-1),V(`p`,Pw,[H(hw,{value:n.value.total.requestsPerDay},null,8,[`value`])])]),V(`div`,null,[t[5]||=V(`p`,{class:`text-muted-foreground`},`Tokens in/day`,-1),V(`p`,Fw,[H(hw,{value:n.value.total.tokensInPerDay},null,8,[`value`])])]),V(`div`,null,[t[6]||=V(`p`,{class:`text-muted-foreground`},`Tokens out/day`,-1),V(`p`,Iw,[H(hw,{value:n.value.total.tokensOutPerDay},null,8,[`value`])])]),V(`div`,null,[t[7]||=V(`p`,{class:`text-muted-foreground`},`Cost/day`,-1),V(`p`,Lw,k(N(aC)(n.value.total.costPerDayMicroUsd)),1)])]),_:1})]),_:1})):Ts(``,!0),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[8]||=[U(`Groups`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[9]||=[U(`Expand a group to see its member users' own usage.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[v.value.length?(R(),z(`div`,Rw,[(R(!0),z(L,null,ma(b.value,e=>(R(),B(HS,{key:e.id,header:e},null,8,[`header`]))),128))])):Ts(``,!0),v.value.length?(R(),B(N(NC),{key:1,modelValue:w.value,"onUpdate:modelValue":t[1]||=e=>w.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:P(()=>[(R(!0),z(L,null,ma(v.value,e=>(R(),B(N(FC),{key:e.original.id,value:e.original.id},{default:P(()=>[H(N(IC),null,{default:P(()=>[V(`span`,zw,[V(`span`,Bw,k(e.original.id),1),V(`span`,Vw,k(a(e.original)||`0`)+` members`,1),V(`span`,Hw,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(hw,{key:1,value:e.original.requestsPerDay},null,8,[`value`])),t[10]||=U(` req/day `,-1)]),V(`span`,Uw,k(e.original.storeDown?`?`:N(aC)(e.original.costPerDayMicroUsd))+`/day `,1)])]),_:2},1024),H(N(PC),null,{default:P(()=>[V(`dl`,Ww,[V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:sT},`Providers`),V(`dd`,null,[e.original.providers?.length?(R(),z(`div`,Gw,[(R(!0),z(L,null,ma(e.original.providers,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,Kw,`All providers`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:sT},`Models`),V(`dd`,null,[e.original.models?.length?(R(),z(`div`,qw,[(R(!0),z(L,null,ma(e.original.models,e=>(R(),z(L,{key:e},[ee(e)?(R(),B(N(eC),{key:1,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024)):(R(),B(xC,{key:0,id:e},null,8,[`id`]))],64))),128))])):(R(),z(`span`,Jw,`All models`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:sT},`MCP servers`),V(`dd`,null,[e.original.mcpServers?.length?(R(),z(`div`,Yw,[(R(!0),z(L,null,ma(e.original.mcpServers,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,Xw,`All MCP servers`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:sT},`Agents`),V(`dd`,null,[e.original.agents?.length?(R(),z(`div`,Zw,[(R(!0),z(L,null,ma(e.original.agents,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,Qw,`All agents`))])])]),V(`dl`,$w,[V(`div`,null,[t[11]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Limits`,-1),V(`dd`,null,k(N(yC)(e.original.limits)),1)]),V(`div`,null,[t[12]||=V(`dt`,{class:`text-xs text-muted-foreground`},`req/min`,-1),V(`dd`,eT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(hw,{key:1,value:e.original.requestsPerMinute},null,8,[`value`]))])]),V(`div`,null,[t[13]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/day`,-1),V(`dd`,tT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(hw,{key:1,value:e.original.tokensInPerDay},null,8,[`value`]))])]),V(`div`,null,[t[14]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/day`,-1),V(`dd`,nT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(hw,{key:1,value:e.original.tokensOutPerDay},null,8,[`value`]))])]),V(`div`,null,[t[15]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/month`,-1),V(`dd`,rT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(hw,{key:1,value:e.original.tokensInPerMonth},null,8,[`value`]))])]),V(`div`,null,[t[16]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/month`,-1),V(`dd`,iT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(hw,{key:1,value:e.original.tokensOutPerMonth},null,8,[`value`]))])]),V(`div`,null,[t[17]||=V(`dt`,{class:`text-xs text-muted-foreground`},`cost/month`,-1),V(`dd`,aT,k(e.original.storeDown?`?`:N(aC)(e.original.costPerMonthMicroUsd)),1)])]),t[18]||=V(`p`,{class:`mb-1.5 text-xs font-medium text-muted-foreground`},`Members`,-1),H(Dw,{"id-label":`Name`,"secondary-column-label":`Group`,entries:d(e.original),"secondary-value":i},null,8,[`entries`])]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):(R(),z(`p`,oT,k(f.value),1))]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[19]||=[U(`Users`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H(Dw,{"id-label":`Name`,"secondary-column-label":`Group`,entries:p.value,"secondary-value":i,"empty-message":m.value},null,8,[`entries`,`empty-message`])]),_:1})]),_:1})]))}});function lT(e,t,n){let r=e.startsWith(`#`)?e.slice(1):e;return t.includes(r)?r:n}function uT(e){return`#${e}`}function dT({validTabs:e,defaultTab:t}){let n=typeof window<`u`,r=M(n?lT(window.location.hash,e,t):t);Er(r,e=>{if(!n)return;let t=uT(e);window.location.hash!==t&&window.history.replaceState(null,``,t)});function i(){r.value=lT(window.location.hash,e,t)}return n&&(Zi(()=>window.addEventListener(`hashchange`,i)),ta(()=>window.removeEventListener(`hashchange`,i))),r}var fT=(function(){let e=typeof document<`u`&&document.createElement(`link`).relList;return e&&e.supports&&e.supports(`modulepreload`)?`modulepreload`:`preload`})(),pT=function(e){return`/admin/`+e},mT={},hT=function(e,t,n){let r=Promise.resolve();if(t&&t.length>0){let e=document.getElementsByTagName(`link`),i=document.querySelector(`meta[property=csp-nonce]`),a=i?.nonce||i?.getAttribute(`nonce`);function o(e){return Promise.all(e.map(e=>Promise.resolve(e).then(e=>({status:`fulfilled`,value:e}),e=>({status:`rejected`,reason:e}))))}function s(e){return import.meta.resolve?import.meta.resolve(e):new URL(e,import.meta.url).href}r=o(t.map(t=>{if(t=pT(t,n),t=s(t),t in mT)return;mT[t]=!0;let r=t.endsWith(`.css`);for(let n=e.length-1;n>=0;n--){let i=e[n];if(i.href===t&&(!r||i.rel===`stylesheet`))return}let i=document.createElement(`link`);if(i.rel=r?`stylesheet`:fT,r||(i.as=`script`),i.crossOrigin=``,i.href=t,a&&i.setAttribute(`nonce`,a),document.head.appendChild(i),r)return new Promise((e,n)=>{i.addEventListener(`load`,e),i.addEventListener(`error`,()=>n(Error(`Unable to preload CSS for ${t}`)))})}))}function i(e){let t=new Event(`vite:preloadError`,{cancelable:!0});if(t.payload=e,window.dispatchEvent(t),!t.defaultPrevented)throw e}return r.then(t=>{for(let e of t||[])e.status===`rejected`&&i(e.reason);return e().catch(i)})},gT={class:`flex w-full flex-col gap-6 px-4 py-8 sm:px-6 lg:px-8`},_T={class:`flex flex-col gap-1`},vT={class:`flex items-center justify-between gap-2`},yT={class:`flex items-center gap-1.5 text-sm text-muted-foreground`},bT=`https://github.com/lukaszraczylo/traefik-llmgateway`,xT=hu(F({__name:`App`,setup(e){let t=Li(()=>hT(()=>import(`./ChartsView-BVocJsry.js`),[])),n=rx(),r=sx(),i=dT({validTabs:[`providers`,`usage`,`charts`,`targets`],defaultTab:`providers`}),a=W(()=>r.error?`refresh failed: ${r.error}`:r.lastUpdated?`last updated ${r.lastUpdated.toLocaleTimeString()}`:`loading...`);return Zi(()=>{r.startPolling()}),(e,o)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`div`,gT,[V(`header`,_T,[V(`div`,vT,[o[1]||=V(`h1`,{class:`text-xl font-semibold tracking-tight`},`LLM Gateway — Admin`,-1),H(N(Wb),{as:`a`,href:bT,target:`_blank`,rel:`noopener noreferrer`,variant:`ghost`,size:`icon`,"aria-label":`GitHub repository`,class:`text-muted-foreground hover:text-foreground`},{default:P(()=>[H(s,{icon:N(r_),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`])]),_:1})]),V(`p`,yT,[N(r).error?(R(),B(s,{key:0,icon:N(u_),class:`size-3.5 text-destructive`},null,8,[`icon`])):Ts(``,!0),V(`span`,{class:O(N(r).error?`text-destructive`:void 0)},k(a.value),3)])]),N(n).isAuthenticated?(R(),B(N(bw),{key:1,modelValue:N(i),"onUpdate:modelValue":o[0]||=e=>j(i)?i.value=e:null},{default:P(()=>[H(N(Sw),null,{default:P(()=>[H(N(Cw),{value:`providers`},{default:P(()=>[...o[2]||=[U(`Providers`,-1)]]),_:1}),H(N(Cw),{value:`usage`},{default:P(()=>[...o[3]||=[U(`Usage`,-1)]]),_:1}),H(N(Cw),{value:`charts`},{default:P(()=>[...o[4]||=[U(`Charts`,-1)]]),_:1}),H(N(Cw),{value:`targets`},{default:P(()=>[...o[5]||=[U(`MCP & Agents`,-1)]]),_:1})]),_:1}),H(N(xw),{value:`providers`},{default:P(()=>[H(dw)]),_:1}),H(N(xw),{value:`usage`},{default:P(()=>[H(cT)]),_:1}),H(N(xw),{value:`charts`},{default:P(()=>[H(N(t))]),_:1}),H(N(xw),{value:`targets`},{default:P(()=>[H(yw)]),_:1})]),_:1},8,[`modelValue`])):(R(),B(gx,{key:0}))])}}}));xT.use(Hg()),xT.component(`FontAwesomeIcon`,wg),xT.mount(`#app`);export{Vr as $,ky as A,Zt as At,Ty as B,ge as Bt,qy as C,wr as Ct,Vy as D,on as Dt,Uy as E,Fe as Et,by as F,yn as Ft,Z as G,sy as H,fy as I,mn as It,c_ as J,d_ as K,gy as L,N as Lt,Fy as M,en as Mt,Iy as N,un as Nt,Ny as O,j as Ot,dy as P,A as Pt,L as Q,Cy as R,O as Rt,Yy as S,Cr as St,Gy as T,rc as Tt,oy as U,cy as V,k as Vt,ay as W,wg as X,n_ as Y,au as Z,Jb as _,ma as _t,bw as a,U as at,nb as b,ac as bt,bC as c,Ss as ct,sx as d,ks as dt,W as et,ix as f,Qn as ft,Xb as g,R as gt,Zb as h,ta as ht,Sw as i,z as it,Ay as j,M as jt,Oy as k,Ie as kt,sC as l,tc as lt,rx as m,Zi as mt,Ow as n,B as nt,LC as o,H as ot,ax as p,ea as pt,h_ as q,Cw as r,Ts as rt,MC as s,F as st,Mw as t,V as tt,oC as u,Pa as ut,qb as v,I as vt,Ky as w,P as wt,$y as x,Er as xt,wb as y,ua as yt,wy as z,xe as zt};", + "var e=Object.defineProperty,t=(t,n)=>{let r={};for(var i in t)e(r,i,{get:t[i],enumerable:!0});return n||e(r,Symbol.toStringTag,{value:`Module`}),r};function n(e){let t=Object.create(null);for(let n of e.split(`,`))t[n]=1;return e=>e in t}var r={},i=[],a=()=>{},o=()=>!1,s=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&(e.charCodeAt(2)>122||e.charCodeAt(2)<97),c=e=>e.startsWith(`onUpdate:`),l=Object.assign,u=(e,t)=>{let n=e.indexOf(t);n>-1&&e.splice(n,1)},d=Object.prototype.hasOwnProperty,f=(e,t)=>d.call(e,t),p=Array.isArray,m=e=>w(e)===`[object Map]`,h=e=>w(e)===`[object Set]`,g=e=>w(e)===`[object Date]`,_=e=>w(e)===`[object RegExp]`,v=e=>typeof e==`function`,y=e=>typeof e==`string`,b=e=>typeof e==`symbol`,x=e=>typeof e==`object`&&!!e,S=e=>(x(e)||v(e))&&v(e.then)&&v(e.catch),C=Object.prototype.toString,w=e=>C.call(e),ee=e=>w(e).slice(8,-1),te=e=>w(e)===`[object Object]`,T=e=>y(e)&&e!==`NaN`&&e[0]!==`-`&&``+parseInt(e,10)===e,ne=n(`,key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted`),re=e=>{let t=Object.create(null);return(n=>t[n]||(t[n]=e(n)))},ie=/-\w/g,E=re(e=>e.replace(ie,e=>e.slice(1).toUpperCase())),ae=/\B([A-Z])/g,oe=re(e=>e.replace(ae,`-$1`).toLowerCase()),se=re(e=>e.charAt(0).toUpperCase()+e.slice(1)),ce=re(e=>e?`on${se(e)}`:``),D=(e,t)=>!Object.is(e,t),le=(e,...t)=>{for(let n=0;n<e.length;n++)e[n](...t)},ue=(e,t,n,r=!1)=>{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:r,value:n})},de=e=>{let t=parseFloat(e);return isNaN(t)?e:t},fe=e=>{let t=y(e)?Number(e):NaN;return isNaN(t)?e:t},pe,me=()=>pe||=typeof globalThis<`u`?globalThis:typeof self<`u`?self:typeof window<`u`?window:typeof global<`u`?global:{},he=n(`Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol`);function ge(e){if(p(e)){let t={};for(let n=0;n<e.length;n++){let r=e[n],i=y(r)?be(r):ge(r);if(i)for(let e in i)t[e]=i[e]}return t}if(y(e)||x(e))return e}var _e=/;(?![^(]*\))/g,ve=/:([^]+)/,ye=/\/\*[^]*?\*\//g;function be(e){let t={};return e.replace(ye,``).split(_e).forEach(e=>{if(e){let n=e.split(ve);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}function O(e){let t=``;if(y(e))t=e;else if(p(e))for(let n=0;n<e.length;n++){let r=O(e[n]);r&&(t+=r+` `)}else if(x(e))for(let n in e)e[n]&&(t+=n+` `);return t.trim()}function xe(e){if(!e)return null;let{class:t,style:n}=e;return t&&!y(t)&&(e.class=O(t)),n&&(e.style=ge(n)),e}var Se=`itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`,Ce=n(Se);Se+``;function we(e){return!!e||e===``}function Te(e,t){if(e.length!==t.length)return!1;let n=!0;for(let r=0;n&&r<e.length;r++)n=Ee(e[r],t[r]);return n}function Ee(e,t){if(e===t)return!0;let n=g(e),r=g(t);if(n||r)return n&&r?e.getTime()===t.getTime():!1;if(n=b(e),r=b(t),n||r)return e===t;if(n=p(e),r=p(t),n||r)return n&&r?Te(e,t):!1;if(n=x(e),r=x(t),n||r){if(!n||!r||Object.keys(e).length!==Object.keys(t).length)return!1;for(let n in e){let r=e.hasOwnProperty(n),i=t.hasOwnProperty(n);if(r&&!i||!r&&i||!Ee(e[n],t[n]))return!1}}return String(e)===String(t)}function De(e,t){return e.findIndex(e=>Ee(e,t))}var Oe=e=>!!(e&&e.__v_isRef===!0),k=e=>y(e)?e:e==null?``:p(e)||x(e)&&(e.toString===C||!v(e.toString))?Oe(e)?k(e.value):JSON.stringify(e,ke,2):String(e),ke=(e,t)=>Oe(t)?ke(e,t.value):m(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((e,[t,n],r)=>(e[Ae(t,r)+` =>`]=n,e),{})}:h(t)?{[`Set(${t.size})`]:[...t.values()].map(e=>Ae(e))}:b(t)?Ae(t):x(t)&&!p(t)&&!te(t)?String(t):t,Ae=(e,t=``)=>b(e)?`Symbol(${e.description??t})`:e;function je(e){return e==null?`initial`:typeof e==`string`?e===``?` `:e:String(e)}var Me,Ne=class{constructor(e=!1){this.detached=e,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this._warnOnRun=!0,this.__v_skip=!0,!e&&Me&&(Me.active?(this.parent=Me,this.index=(Me.scopes||(Me.scopes=[])).push(this)-1):(this._active=!1,this._warnOnRun=!1))}get active(){return this._active}pause(){if(this._active){this._isPaused=!0;let e,t;if(this.scopes){let n=this.scopes.slice();for(e=0,t=n.length;e<t;e++)n[e].pause()}for(e=0,t=this.effects.length;e<t;e++)this.effects[e].pause()}}resume(){if(this._active&&this._isPaused){this._isPaused=!1;let e,t;if(this.scopes){let n=this.scopes.slice();for(e=0,t=n.length;e<t;e++)n[e].resume()}let n=this.effects.slice();for(e=0,t=n.length;e<t;e++)n[e].resume()}}run(e){if(this._active){let t=Me;try{return Me=this,e()}finally{Me=t}}}on(){++this._on===1&&(this.prevScope=Me,Me=this)}off(){if(this._on>0&&--this._on===0){if(Me===this)Me=this.prevScope;else{let e=Me;for(;e;){if(e.prevScope===this){e.prevScope=this.prevScope;break}e=e.prevScope}}this.prevScope=void 0}}stop(e){if(this._active){this._active=!1;let t,n;for(t=0,n=this.effects.length;t<n;t++)this.effects[t].stop();for(this.effects.length=0,t=0,n=this.cleanups.length;t<n;t++)this.cleanups[t]();if(this.cleanups.length=0,this.scopes){let e=this.scopes.slice();for(t=0,n=e.length;t<n;t++)e[t].stop(!0);this.scopes.length=0}if(!this.detached&&this.parent&&!e){let e=this.parent.scopes.pop();e&&e!==this&&(this.parent.scopes[this.index]=e,e.index=this.index)}this.parent=void 0}}};function Pe(e){return new Ne(e)}function Fe(){return Me}function Ie(e,t=!1){Me&&Me.cleanups.push(e)}var Le,Re=new WeakSet,ze=class{constructor(e){this.fn=e,this.deps=void 0,this.depsTail=void 0,this.flags=5,this.next=void 0,this.cleanup=void 0,this.scheduler=void 0,Me&&(Me.active?Me.effects.push(this):this.flags&=-2)}pause(){this.flags|=64}resume(){this.flags&64&&(this.flags&=-65,Re.has(this)&&(Re.delete(this),this.trigger()))}notify(){this.flags&2&&!(this.flags&32)||this.flags&8||Ue(this)}run(){if(!(this.flags&1))return this.fn();this.flags|=2,it(this),Ke(this);let e=Le,t=et;Le=this,et=!0;try{return this.fn()}finally{qe(this),Le=e,et=t,this.flags&=-3}}stop(){if(this.flags&1){for(let e=this.deps;e;e=e.nextDep)Xe(e);this.deps=this.depsTail=void 0,it(this),this.onStop&&this.onStop(),this.flags&=-2}}trigger(){this.flags&64?Re.add(this):this.scheduler?this.scheduler():this.runIfDirty()}runIfDirty(){Je(this)&&this.run()}get dirty(){return Je(this)}},Be=0,Ve,He;function Ue(e,t=!1){if(e.flags|=8,t){e.next=He,He=e;return}e.next=Ve,Ve=e}function We(){Be++}function Ge(){if(--Be>0)return;if(He){let e=He;for(He=void 0;e;){let t=e.next;e.next=void 0,e.flags&=-9,e=t}}let e;for(;Ve;){let t=Ve;for(Ve=void 0;t;){let n=t.next;if(t.next=void 0,t.flags&=-9,t.flags&1)try{t.trigger()}catch(t){e||=t}t=n}}if(e)throw e}function Ke(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function qe(e){let t,n=e.depsTail,r=n;for(;r;){let e=r.prevDep;r.version===-1?(r===n&&(n=e),Xe(r),Ze(r)):t=r,r.dep.activeLink=r.prevActiveLink,r.prevActiveLink=void 0,r=e}e.deps=t,e.depsTail=n}function Je(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(Ye(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function Ye(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===at)||(e.globalVersion=at,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!Je(e))))return;e.flags|=2;let t=e.dep,n=Le,r=et;Le=e,et=!0;try{Ke(e);let n=e.fn(e._value);(t.version===0||D(n,e._value))&&(e.flags|=128,e._value=n,t.version++)}catch(e){throw t.version++,e}finally{Le=n,et=r,qe(e),e.flags&=-3}}function Xe(e,t=!1){let{dep:n,prevSub:r,nextSub:i}=e;if(r&&(r.nextSub=i,e.prevSub=void 0),i&&(i.prevSub=r,e.nextSub=void 0),n.subs===e&&(n.subs=r,!r&&n.computed)){n.computed.flags&=-5;for(let e=n.computed.deps;e;e=e.nextDep)Xe(e,!0)}!t&&!--n.sc&&n.map&&n.map.delete(n.key)}function Ze(e){let{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}function Qe(e,t){e.effect instanceof ze&&(e=e.effect.fn);let n=new ze(e);t&&l(n,t);try{n.run()}catch(e){throw n.stop(),e}let r=n.run.bind(n);return r.effect=n,r}function $e(e){e.effect.stop()}var et=!0,tt=[];function nt(){tt.push(et),et=!1}function rt(){let e=tt.pop();et=e===void 0||e}function it(e){let{cleanup:t}=e;if(e.cleanup=void 0,t){let e=Le;Le=void 0;try{t()}finally{Le=e}}}var at=0,ot=class{constructor(e,t){this.sub=e,this.dep=t,this.version=t.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}},st=class{constructor(e){this.computed=e,this.version=0,this.activeLink=void 0,this.subs=void 0,this.map=void 0,this.key=void 0,this.sc=0,this.__v_skip=!0}track(e){if(!Le||!et||Le===this.computed)return;let t=this.activeLink;if(t===void 0||t.sub!==Le)t=this.activeLink=new ot(Le,this),Le.deps?(t.prevDep=Le.depsTail,Le.depsTail.nextDep=t,Le.depsTail=t):Le.deps=Le.depsTail=t,ct(t);else if(t.version===-1&&(t.version=this.version,t.nextDep)){let e=t.nextDep;e.prevDep=t.prevDep,t.prevDep&&(t.prevDep.nextDep=e),t.prevDep=Le.depsTail,t.nextDep=void 0,Le.depsTail.nextDep=t,Le.depsTail=t,Le.deps===t&&(Le.deps=e)}return t}trigger(e){this.version++,at++,this.notify(e)}notify(e){We();try{for(let e=this.subs;e;e=e.prevSub)e.sub.notify()&&e.sub.dep.notify()}finally{Ge()}}};function ct(e){if(e.dep.sc++,e.sub.flags&4){let t=e.dep.computed;if(t&&!e.dep.subs){t.flags|=20;for(let e=t.deps;e;e=e.nextDep)ct(e)}let n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}var lt=new WeakMap,ut=Symbol(``),dt=Symbol(``),ft=Symbol(``);function pt(e,t,n){if(et&&Le){let t=lt.get(e);t||lt.set(e,t=new Map);let r=t.get(n);r||(t.set(n,r=new st),r.map=t,r.key=n),r.track()}}function mt(e,t,n,r,i,a){let o=lt.get(e);if(!o){at++;return}let s=e=>{e&&e.trigger()};if(We(),t===`clear`)o.forEach(s);else{let i=p(e),a=i&&T(n);if(i&&n===`length`){let e=Number(r);o.forEach((t,n)=>{(n===`length`||n===ft||!b(n)&&n>=e)&&s(t)})}else switch((n!==void 0||o.has(void 0))&&s(o.get(n)),a&&s(o.get(ft)),t){case`add`:i?a&&s(o.get(`length`)):(s(o.get(ut)),m(e)&&s(o.get(dt)));break;case`delete`:i||(s(o.get(ut)),m(e)&&s(o.get(dt)));break;case`set`:m(e)&&s(o.get(ut))}}Ge()}function ht(e,t){let n=lt.get(e);return n&&n.get(t)}function gt(e){let t=A(e);return t===e?t:(pt(t,`iterate`,ft),an(e)?t:t.map(cn))}function _t(e){return pt(e=A(e),`iterate`,ft),e}function vt(e,t){return rn(e)?ln(nn(e)?cn(t):t):cn(t)}var yt={__proto__:null,[Symbol.iterator](){return bt(this,Symbol.iterator,e=>vt(this,e))},concat(...e){return gt(this).concat(...e.map(e=>p(e)?gt(e):e))},entries(){return bt(this,`entries`,e=>(e[1]=vt(this,e[1]),e))},every(e,t){return St(this,`every`,e,t,void 0,arguments)},filter(e,t){return St(this,`filter`,e,t,e=>e.map(e=>vt(this,e)),arguments)},find(e,t){return St(this,`find`,e,t,e=>vt(this,e),arguments)},findIndex(e,t){return St(this,`findIndex`,e,t,void 0,arguments)},findLast(e,t){return St(this,`findLast`,e,t,e=>vt(this,e),arguments)},findLastIndex(e,t){return St(this,`findLastIndex`,e,t,void 0,arguments)},forEach(e,t){return St(this,`forEach`,e,t,void 0,arguments)},includes(...e){return wt(this,`includes`,e)},indexOf(...e){return wt(this,`indexOf`,e)},join(e){return gt(this).join(e)},lastIndexOf(...e){return wt(this,`lastIndexOf`,e)},map(e,t){return St(this,`map`,e,t,void 0,arguments)},pop(){return Tt(this,`pop`)},push(...e){return Tt(this,`push`,e)},reduce(e,...t){return Ct(this,`reduce`,e,t)},reduceRight(e,...t){return Ct(this,`reduceRight`,e,t)},shift(){return Tt(this,`shift`)},some(e,t){return St(this,`some`,e,t,void 0,arguments)},splice(...e){return Tt(this,`splice`,e)},toReversed(){return gt(this).toReversed()},toSorted(e){return gt(this).toSorted(e)},toSpliced(...e){return gt(this).toSpliced(...e)},unshift(...e){return Tt(this,`unshift`,e)},values(){return bt(this,`values`,e=>vt(this,e))}};function bt(e,t,n){let r=_t(e),i=r[t]();return r!==e&&!an(e)&&(i._next=i.next,i.next=()=>{let e=i._next();return e.done||(e.value=n(e.value)),e}),i}var xt=Array.prototype;function St(e,t,n,r,i,a){let o=_t(e),s=o!==e&&!an(e),c=o[t];if(c!==xt[t]){let t=c.apply(e,a);return s?cn(t):t}let l=n;o!==e&&(s?l=function(t,r){return n.call(this,vt(e,t),r,e)}:n.length>2&&(l=function(t,r){return n.call(this,t,r,e)}));let u=c.call(o,l,r);return s&&i?i(u):u}function Ct(e,t,n,r){let i=_t(e),a=i!==e&&!an(e),o=n,s=!1;i!==e&&(a?(s=r.length===0,o=function(t,r,i){return s&&(s=!1,t=vt(e,t)),n.call(this,t,vt(e,r),i,e)}):n.length>3&&(o=function(t,r,i){return n.call(this,t,r,i,e)}));let c=i[t](o,...r);return s?vt(e,c):c}function wt(e,t,n){let r=A(e);pt(r,`iterate`,ft);let i=r[t](...n);return(i===-1||i===!1)&&on(n[0])?(n[0]=A(n[0]),r[t](...n)):i}function Tt(e,t,n=[]){nt(),We();let r=A(e)[t].apply(e,n);return Ge(),rt(),r}var Et=n(`__proto__,__v_isRef,__isVue`),Dt=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!==`arguments`&&e!==`caller`).map(e=>Symbol[e]).filter(b));function Ot(e){b(e)||(e=String(e));let t=A(this);return pt(t,`has`,e),t.hasOwnProperty(e)}var kt=class{constructor(e=!1,t=!1){this._isReadonly=e,this._isShallow=t}get(e,t,n){if(t===`__v_skip`)return e.__v_skip;let r=this._isReadonly,i=this._isShallow;if(t===`__v_isReactive`)return!r;if(t===`__v_isReadonly`)return r;if(t===`__v_isShallow`)return i;if(t===`__v_raw`)return n===(r?i?Yt:Jt:i?qt:Kt).get(e)||Object.getPrototypeOf(e)===Object.getPrototypeOf(n)?e:void 0;let a=p(e);if(!r){let e;if(a&&(e=yt[t]))return e;if(t===`hasOwnProperty`)return Ot}let o=Reflect.get(e,t,j(e)?e:n);if((b(t)?Dt.has(t):Et(t))||(r||pt(e,`get`,t),i))return o;if(j(o)){let e=a&&T(t)?o:o.value;return r&&x(e)?$t(e):e}return x(o)?r?$t(o):Zt(o):o}},At=class extends kt{constructor(e=!1){super(!1,e)}set(e,t,n,r){let i=e[t],a=p(e)&&T(t);if(!this._isShallow){let e=rn(i);if(!an(n)&&!rn(n)&&(i=A(i),n=A(n)),!a&&j(i)&&!j(n))return e||(i.value=n),!0}let o=a?Number(t)<e.length:f(e,t),s=Reflect.set(e,t,n,j(e)?e:r);return e===A(r)&&s&&(o?D(n,i)&&mt(e,`set`,t,n,i):mt(e,`add`,t,n)),s}deleteProperty(e,t){let n=f(e,t),r=e[t],i=Reflect.deleteProperty(e,t);return i&&n&&mt(e,`delete`,t,void 0,r),i}has(e,t){let n=Reflect.has(e,t);return(!b(t)||!Dt.has(t))&&pt(e,`has`,t),n}ownKeys(e){return pt(e,`iterate`,p(e)?`length`:ut),Reflect.ownKeys(e)}},jt=class extends kt{constructor(e=!1){super(!0,e)}set(e,t){return!0}deleteProperty(e,t){return!0}},Mt=new At,Nt=new jt,Pt=new At(!0),Ft=new jt(!0),It=e=>e,Lt=e=>Reflect.getPrototypeOf(e);function Rt(e,t,n){return function(...r){let i=this.__v_raw,a=A(i),o=m(a),s=e===`entries`||e===Symbol.iterator&&o,c=e===`keys`&&o,u=i[e](...r),d=n?It:t?ln:cn;return!t&&pt(a,`iterate`,c?dt:ut),l(Object.create(u),{next(){let{value:e,done:t}=u.next();return t?{value:e,done:t}:{value:s?[d(e[0]),d(e[1])]:d(e),done:t}}})}}function zt(e){return function(...t){return e===`delete`?!1:e===`clear`?void 0:this}}function Bt(e,t){let n={get(n){let r=this.__v_raw,i=A(r),a=A(n);e||(D(n,a)&&pt(i,`get`,n),pt(i,`get`,a));let{has:o}=Lt(i),s=t?It:e?ln:cn;if(o.call(i,n))return s(r.get(n));if(o.call(i,a))return s(r.get(a));r!==i&&r.get(n)},get size(){let t=this.__v_raw;return!e&&pt(A(t),`iterate`,ut),t.size},has(t){let n=this.__v_raw,r=A(n),i=A(t);return e||(D(t,i)&&pt(r,`has`,t),pt(r,`has`,i)),t===i?n.has(t):n.has(t)||n.has(i)},forEach(n,r){let i=this,a=i.__v_raw,o=A(a),s=t?It:e?ln:cn;return!e&&pt(o,`iterate`,ut),a.forEach((e,t)=>n.call(r,s(e),s(t),i))}};return l(n,e?{add:zt(`add`),set:zt(`set`),delete:zt(`delete`),clear:zt(`clear`)}:{add(e){let n=A(this),r=Lt(n),i=A(e),a=!t&&!an(e)&&!rn(e)?i:e;return r.has.call(n,a)||D(e,a)&&r.has.call(n,e)||D(i,a)&&r.has.call(n,i)||(n.add(a),mt(n,`add`,a,a)),this},set(e,n){!t&&!an(n)&&!rn(n)&&(n=A(n));let r=A(this),{has:i,get:a}=Lt(r),o=i.call(r,e);o||=(e=A(e),i.call(r,e));let s=a.call(r,e);return r.set(e,n),o?D(n,s)&&mt(r,`set`,e,n,s):mt(r,`add`,e,n),this},delete(e){let t=A(this),{has:n,get:r}=Lt(t),i=n.call(t,e);i||=(e=A(e),n.call(t,e));let a=r?r.call(t,e):void 0,o=t.delete(e);return i&&mt(t,`delete`,e,void 0,a),o},clear(){let e=A(this),t=e.size!==0,n=e.clear();return t&&mt(e,`clear`,void 0,void 0,void 0),n}}),[`keys`,`values`,`entries`,Symbol.iterator].forEach(r=>{n[r]=Rt(r,e,t)}),n}function Vt(e,t){let n=Bt(e,t);return(t,r,i)=>r===`__v_isReactive`?!e:r===`__v_isReadonly`?e:r===`__v_raw`?t:Reflect.get(f(n,r)&&r in t?n:t,r,i)}var Ht={get:Vt(!1,!1)},Ut={get:Vt(!1,!0)},Wt={get:Vt(!0,!1)},Gt={get:Vt(!0,!0)},Kt=new WeakMap,qt=new WeakMap,Jt=new WeakMap,Yt=new WeakMap;function Xt(e){switch(e){case`Object`:case`Array`:return 1;case`Map`:case`Set`:case`WeakMap`:case`WeakSet`:return 2;default:return 0}}function Zt(e){return rn(e)?e:tn(e,!1,Mt,Ht,Kt)}function Qt(e){return tn(e,!1,Pt,Ut,qt)}function $t(e){return tn(e,!0,Nt,Wt,Jt)}function en(e){return tn(e,!0,Ft,Gt,Yt)}function tn(e,t,n,r,i){if(!x(e)||e.__v_raw&&!(t&&e.__v_isReactive)||e.__v_skip||!Object.isExtensible(e))return e;let a=i.get(e);if(a)return a;let o=Xt(ee(e));if(o===0)return e;let s=new Proxy(e,o===2?r:n);return i.set(e,s),s}function nn(e){return rn(e)?nn(e.__v_raw):!!(e&&e.__v_isReactive)}function rn(e){return!!(e&&e.__v_isReadonly)}function an(e){return!!(e&&e.__v_isShallow)}function on(e){return e?!!e.__v_raw:!1}function A(e){let t=e&&e.__v_raw;return t?A(t):e}function sn(e){return!f(e,`__v_skip`)&&Object.isExtensible(e)&&ue(e,`__v_skip`,!0),e}var cn=e=>x(e)?Zt(e):e,ln=e=>x(e)?$t(e):e;function j(e){return e?e.__v_isRef===!0:!1}function M(e){return dn(e,!1)}function un(e){return dn(e,!0)}function dn(e,t){return j(e)?e:new fn(e,t)}var fn=class{constructor(e,t){this.dep=new st,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=t?e:A(e),this._value=t?e:cn(e),this.__v_isShallow=t}get value(){return this.dep.track(),this._value}set value(e){let t=this._rawValue,n=this.__v_isShallow||an(e)||rn(e);e=n?e:A(e),D(e,t)&&(this._rawValue=e,this._value=n?e:cn(e),this.dep.trigger())}};function pn(e){e.dep&&e.dep.trigger()}function N(e){return j(e)?e.value:e}function mn(e){return v(e)?e():N(e)}var hn={get:(e,t,n)=>t===`__v_raw`?e:N(Reflect.get(e,t,n)),set:(e,t,n,r)=>{let i=e[t];return j(i)&&!j(n)?(i.value=n,!0):Reflect.set(e,t,n,r)}};function gn(e){return nn(e)?e:new Proxy(e,hn)}var _n=class{constructor(e){this.__v_isRef=!0,this._value=void 0;let t=this.dep=new st,{get:n,set:r}=e(t.track.bind(t),t.trigger.bind(t));this._get=n,this._set=r}get value(){return this._value=this._get()}set value(e){this._set(e)}};function vn(e){return new _n(e)}function yn(e){let t=p(e)?Array(e.length):{};for(let n in e)t[n]=Cn(e,n);return t}var bn=class{constructor(e,t,n){this._object=e,this._defaultValue=n,this.__v_isRef=!0,this._value=void 0,this._key=b(t)?t:String(t),this._raw=A(e);let r=!0,i=e;if(!p(e)||b(this._key)||!T(this._key))do r=!on(i)||an(i);while(r&&(i=i.__v_raw));this._shallow=r}get value(){let e=this._object[this._key];return this._shallow&&(e=N(e)),this._value=e===void 0?this._defaultValue:e}set value(e){if(this._shallow&&j(this._raw[this._key])){let t=this._object[this._key];if(j(t)){t.value=e;return}}this._object[this._key]=e}get dep(){return ht(this._raw,this._key)}},xn=class{constructor(e){this._getter=e,this.__v_isRef=!0,this.__v_isReadonly=!0,this._value=void 0}get value(){return this._value=this._getter()}};function Sn(e,t,n){return j(e)?e:v(e)?new xn(e):x(e)&&arguments.length>1?Cn(e,t,n):M(e)}function Cn(e,t,n){return new bn(e,t,n)}var wn=class{constructor(e,t,n){this.fn=e,this.setter=t,this._value=void 0,this.dep=new st(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=at-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!t,this.isSSR=n}notify(){if(this.flags|=16,!(this.flags&8)&&Le!==this)return Ue(this,!0),!0}get value(){let e=this.dep.track();return Ye(this),e&&(e.version=this.dep.version),this._value}set value(e){this.setter&&this.setter(e)}};function Tn(e,t,n=!1){let r,i;return v(e)?r=e:(r=e.get,i=e.set),new wn(r,i,n)}var En={GET:`get`,HAS:`has`,ITERATE:`iterate`},Dn={SET:`set`,ADD:`add`,DELETE:`delete`,CLEAR:`clear`},On={},kn=new WeakMap,An=void 0;function jn(){return An}function Mn(e,t=!1,n=An){if(n){let t=kn.get(n);t||kn.set(n,t=[]),t.push(e)}}function Nn(e,t,n=r){let{immediate:i,deep:o,once:s,scheduler:c,augmentJob:l,call:d}=n,f=e=>o?e:an(e)||o===!1||o===0?Pn(e,1):Pn(e),m,h,g,_,y=!1,b=!1;if(j(e)?(h=()=>e.value,y=an(e)):nn(e)?(h=()=>f(e),y=!0):p(e)?(b=!0,y=e.some(e=>nn(e)||an(e)),h=()=>e.map(e=>{if(j(e))return e.value;if(nn(e))return f(e);if(v(e))return d?d(e,2):e()})):h=v(e)?t?d?()=>d(e,2):e:()=>{if(g){nt();try{g()}finally{rt()}}let t=An;An=m;try{return d?d(e,3,[_]):e(_)}finally{An=t}}:a,t&&o){let e=h,t=o===!0?1/0:o;h=()=>Pn(e(),t)}let x=Fe(),S=()=>{m.stop(),x&&x.active&&u(x.effects,m)};if(s&&t){let e=t;t=(...t)=>{let n=e(...t);return S(),n}}let C=b?Array(e.length).fill(On):On,w=e=>{if(!(!(m.flags&1)||!m.dirty&&!e)){if(t){let n=m.run();if(e||o||y||(b?n.some((e,t)=>D(e,C[t])):D(n,C))){g&&g();let e=An;An=m;try{let e=[n,C===On?void 0:b&&C[0]===On?[]:C,_];C=n,d?d(t,3,e):t(...e)}finally{An=e}}}else m.run()}};return l&&l(w),m=new ze(h),m.scheduler=c?()=>c(w,!1):w,_=e=>Mn(e,!1,m),g=m.onStop=()=>{let e=kn.get(m);if(e){if(d)d(e,4);else for(let t of e)t();kn.delete(m)}},t?i?w(!0):C=m.run():c?c(w.bind(null,!0),!0):m.run(),S.pause=m.pause.bind(m),S.resume=m.resume.bind(m),S.stop=S,S}function Pn(e,t=1/0,n){if(t<=0||!x(e)||e.__v_skip||(n||=new Map,(n.get(e)||0)>=t))return e;if(n.set(e,t),t--,j(e))Pn(e.value,t,n);else if(p(e))for(let r=0;r<e.length;r++)Pn(e[r],t,n);else if(h(e)||m(e))e.forEach(e=>{Pn(e,t,n)});else if(te(e)){for(let r in e)Pn(e[r],t,n);for(let r of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,r)&&Pn(e[r],t,n)}return e}var Fn=[];function In(e){Fn.push(e)}function Ln(){Fn.pop()}function Rn(e,t){}var zn={SETUP_FUNCTION:0,0:`SETUP_FUNCTION`,RENDER_FUNCTION:1,1:`RENDER_FUNCTION`,NATIVE_EVENT_HANDLER:5,5:`NATIVE_EVENT_HANDLER`,COMPONENT_EVENT_HANDLER:6,6:`COMPONENT_EVENT_HANDLER`,VNODE_HOOK:7,7:`VNODE_HOOK`,DIRECTIVE_HOOK:8,8:`DIRECTIVE_HOOK`,TRANSITION_HOOK:9,9:`TRANSITION_HOOK`,APP_ERROR_HANDLER:10,10:`APP_ERROR_HANDLER`,APP_WARN_HANDLER:11,11:`APP_WARN_HANDLER`,FUNCTION_REF:12,12:`FUNCTION_REF`,ASYNC_COMPONENT_LOADER:13,13:`ASYNC_COMPONENT_LOADER`,SCHEDULER:14,14:`SCHEDULER`,COMPONENT_UPDATE:15,15:`COMPONENT_UPDATE`,APP_UNMOUNT_CLEANUP:16,16:`APP_UNMOUNT_CLEANUP`},Bn={sp:`serverPrefetch hook`,bc:`beforeCreate hook`,c:`created hook`,bm:`beforeMount hook`,m:`mounted hook`,bu:`beforeUpdate hook`,u:`updated`,bum:`beforeUnmount hook`,um:`unmounted hook`,a:`activated hook`,da:`deactivated hook`,ec:`errorCaptured hook`,rtc:`renderTracked hook`,rtg:`renderTriggered hook`,0:`setup function`,1:`render function`,2:`watcher getter`,3:`watcher callback`,4:`watcher cleanup function`,5:`native event handler`,6:`component event handler`,7:`vnode hook`,8:`directive hook`,9:`transition hook`,10:`app errorHandler`,11:`app warnHandler`,12:`ref function`,13:`async component loader`,14:`scheduler flush`,15:`component update`,16:`app unmount cleanup function`};function Vn(e,t,n,r){try{return r?e(...r):e()}catch(e){Un(e,t,n)}}function Hn(e,t,n,r){if(v(e)){let i=Vn(e,t,n,r);return i&&S(i)&&i.catch(e=>{Un(e,t,n)}),i}if(p(e)){let i=[];for(let a=0;a<e.length;a++)i.push(Hn(e[a],t,n,r));return i}}function Un(e,t,n,i=!0){let a=t?t.vnode:null,{errorHandler:o,throwUnhandledErrorInProduction:s}=t&&t.appContext.config||r;if(t){let r=t.parent,i=t.proxy,a=`https://vuejs.org/error-reference/#runtime-${n}`;for(;r;){let t=r.ec;if(t){for(let n=0;n<t.length;n++)if(t[n](e,i,a)===!1)return}r=r.parent}if(o){nt(),Vn(o,null,10,[e,i,a]),rt();return}}Wn(e,n,a,i,s)}function Wn(e,t,n,r=!0,i=!1){if(i)throw e;console.error(e)}var Gn=[],Kn=-1,qn=[],Jn=null,Yn=0,Xn=Promise.resolve(),Zn=null;function Qn(e){let t=Zn||Xn;return e?t.then(this?e.bind(this):e):t}function $n(e){let t=Kn+1,n=Gn.length;for(;t<n;){let r=t+n>>>1,i=Gn[r],a=ar(i);a<e||a===e&&i.flags&2?t=r+1:n=r}return t}function er(e){if(!(e.flags&1)){let t=ar(e),n=Gn[Gn.length-1];!n||!(e.flags&2)&&t>=ar(n)?Gn.push(e):Gn.splice($n(t),0,e),e.flags|=1,tr()}}function tr(){Zn||=Xn.then(or)}function nr(e){if(!p(e))Jn&&e.id===-1?Jn.splice(Yn+1,0,e):e.flags&1||(qn.push(e),e.flags|=1);else for(let t=0;t<e.length;t++)qn.push(e[t]);tr()}function rr(e,t,n=Kn+1){for(;n<Gn.length;n++){let t=Gn[n];if(t&&t.flags&2){if(e&&t.id!==e.uid)continue;Gn.splice(n,1),n--,t.flags&4&&(t.flags&=-2),t(),t.flags&4||(t.flags&=-2)}}}function ir(e){if(qn.length){let e=[...new Set(qn)].sort((e,t)=>ar(e)-ar(t));if(qn.length=0,Jn){for(let t=0;t<e.length;t++)Jn.push(e[t]);return}for(Jn=e,Yn=0;Yn<Jn.length;Yn++){let e=Jn[Yn];e.flags&4&&(e.flags&=-2),e.flags&8||e(),e.flags&=-2}Jn=null,Yn=0}}var ar=e=>e.id==null?e.flags&2?-1:1/0:e.id;function or(e){try{for(Kn=0;Kn<Gn.length;Kn++){let e=Gn[Kn];e&&!(e.flags&8)&&(e.flags&4&&(e.flags&=-2),Vn(e,e.i,e.i?15:14),e.flags&4||(e.flags&=-2))}}finally{for(;Kn<Gn.length;Kn++){let e=Gn[Kn];e&&(e.flags&=-2)}Kn=-1,Gn.length=0,ir(e),Zn=null,(Gn.length||qn.length)&&or(e)}}var sr,cr=[];function lr(e,t){sr=e,sr?(sr.enabled=!0,cr.forEach(({event:e,args:t})=>sr.emit(e,...t)),cr=[]):typeof window<`u`&&window.HTMLElement&&!(window.navigator?.userAgent)?.includes(`jsdom`)?((t.__VUE_DEVTOOLS_HOOK_REPLAY__=t.__VUE_DEVTOOLS_HOOK_REPLAY__||[]).push(e=>{lr(e,t)}),setTimeout(()=>{sr||(t.__VUE_DEVTOOLS_HOOK_REPLAY__=null,cr=[])},3e3)):cr=[]}var ur=null,dr=null;function fr(e){let t=ur;return ur=e,dr=e&&e.type.__scopeId||null,t}function pr(e){dr=e}function mr(){dr=null}var hr=e=>P;function P(e,t=ur,n){if(!t||e._n)return e;let r=(...n)=>{r._d&&ms(-1);let i=fr(t),a=us.length,o;try{o=e(...n)}finally{for(let e=us.length;e>a;e--)fs();fr(i),r._d&&ms(1)}return o};return r._n=!0,r._c=!0,r._d=!0,r}function gr(e,t){if(ur===null)return e;let n=Qs(ur),i=e.dirs||=[];for(let e=0;e<t.length;e++){let[a,o,s,c=r]=t[e];a&&(v(a)&&(a={mounted:a,updated:a}),a.deep&&Pn(o),i.push({dir:a,instance:n,value:o,oldValue:void 0,arg:s,modifiers:c}))}return e}function _r(e,t,n,r){let i=e.dirs,a=t&&t.dirs;for(let o=0;o<i.length;o++){let s=i[o];a&&(s.oldValue=a[o].value);let c=s.dir[r];c&&(nt(),Hn(c,n,8,[e.el,s,e,t]),rt())}}function vr(e,t){if(Ps){let n=Ps.provides,r=Ps.parent&&Ps.parent.provides;r===n&&(n=Ps.provides=Object.create(r)),n[e]=t}}function yr(e,t,n=!1){let r=Fs();if(r||no){let i=no?no._context.provides:r?r.parent==null||r.ce?r.vnode.appContext&&r.vnode.appContext.provides:r.parent.provides:void 0;if(i&&e in i)return i[e];if(arguments.length>1)return n&&v(t)?t.call(r&&r.proxy):t}}function br(){return!!(Fs()||no)}var xr=Symbol.for(`v-scx`),Sr=()=>yr(xr);function Cr(e,t){return Dr(e,null,t)}function wr(e,t){return Dr(e,null,{flush:`post`})}function Tr(e,t){return Dr(e,null,{flush:`sync`})}function Er(e,t,n){return Dr(e,t,n)}function Dr(e,t,n=r){let{immediate:i,deep:o,flush:s,once:c}=n,u=l({},n),d=t&&i||!t&&s!==`post`,f;if(Vs){if(s===`sync`){let e=Sr();f=e.__watcherHandles||=[]}else if(!d){let e=()=>{};return e.stop=a,e.resume=a,e.pause=a,e}}let p=Ps;u.call=(e,t,n)=>Hn(e,p,t,n);let m=!1;s===`post`?u.scheduler=e=>{Io(e,p&&p.suspense)}:s!==`sync`&&(m=!0,u.scheduler=(e,t)=>{t?e():er(e)}),u.augmentJob=e=>{t&&(e.flags|=4),m&&(e.flags|=2,p&&(e.id=p.uid,e.i=p))};let h=Nn(e,t,u);return Vs&&(f?f.push(h):d&&h()),h}function Or(e,t,n){let r=this.proxy,i=y(e)?e.includes(`.`)?kr(r,e):()=>r[e]:e.bind(r,r),a;v(t)?a=t:(a=t.handler,n=t);let o=Rs(this),s=Dr(i,a.bind(r),n);return o(),s}function kr(e,t){let n=t.split(`.`);return()=>{let t=e;for(let e=0;e<n.length&&t;e++)t=t[n[e]];return t}}var Ar=new WeakMap,jr=Symbol(`_vte`),Mr=e=>e.__isTeleport,Nr=e=>e&&(e.disabled||e.disabled===``),Pr=e=>e&&(e.defer||e.defer===``),Fr=e=>typeof SVGElement<`u`&&e instanceof SVGElement,Ir=e=>typeof MathMLElement==`function`&&e instanceof MathMLElement,Lr=(e,t)=>{let n=e&&e.to;return y(n)?t?t(n):null:n},Rr={name:`Teleport`,__isTeleport:!0,process(e,t,n,r,i,a,o,s,c,l){let{mc:u,pc:d,pbc:f,o:{insert:p,querySelector:m,createText:h,createComment:g,parentNode:_}}=l,v=Nr(t.props),{dynamicChildren:y}=t,b=(e,t,n)=>{e.shapeFlag&16&&u(e.children,t,n,i,a,o,s,c)},x=(e=t)=>{let n=Nr(e.props),r=e.target=Lr(e.props,m),a=Ur(r,e,h,p);r&&(o!==`svg`&&Fr(r)?o=`svg`:o!==`mathml`&&Ir(r)&&(o=`mathml`),i&&i.isCE&&(i.ce._teleportTargets||(i.ce._teleportTargets=new Set)).add(r),n||(b(e,r,a),Hr(e,!1)))},S=e=>{let t=()=>{if(Ar.get(e)===t){if(Ar.delete(e),Nr(e.props)){let t=_(e.el)||n;b(e,t,e.anchor),Hr(e,!0)}x(e)}};Ar.set(e,t),Io(t,a)};if(e==null){let e=t.el=h(``),i=t.anchor=h(``);if(p(e,n,r),p(i,n,r),Pr(t.props)||a&&a.pendingBranch){S(t);return}v&&(b(t,n,i),Hr(t,!0)),x()}else{t.el=e.el;let r=t.anchor=e.anchor,u=Ar.get(e);if(u){u.flags|=8,Ar.delete(e),S(t);return}t.targetStart=e.targetStart;let p=t.target=e.target,h=t.targetAnchor=e.targetAnchor,g=Nr(e.props),_=g?n:p,b=g?r:h;if(o===`svg`||Fr(p)?o=`svg`:(o===`mathml`||Ir(p))&&(o=`mathml`),y?(f(e.dynamicChildren,y,_,i,a,o,s),Uo(e,t,!0)):c||d(e,t,_,b,i,a,o,s,!1),v)g?t.props&&e.props&&t.props.to!==e.props.to&&(t.props.to=e.props.to):zr(t,n,r,l,1);else if((t.props&&t.props.to)!==(e.props&&e.props.to)){let e=Lr(t.props,m);e&&(t.target=e,zr(t,e,null,l,0))}else g&&zr(t,p,h,l,1);Hr(t,v)}},remove(e,t,n,{um:r,o:{remove:i}},a){let{shapeFlag:o,children:s,anchor:c,targetStart:l,targetAnchor:u,target:d,props:f}=e,p=Nr(f),m=a||!p,h=Ar.get(e);if(h&&(h.flags|=8,Ar.delete(e)),d&&(i(l),i(u)),a&&i(c),!h&&(p||d)&&o&16)for(let e=0;e<s.length;e++){let i=s[e];r(i,t,n,m,!!i.dynamicChildren)}},move:zr,hydrate:Br};function zr(e,t,n,{o:{insert:r},m:i},a=2){a===0&&r(e.targetAnchor,t,n);let{el:o,anchor:s,shapeFlag:c,children:l,props:u}=e,d=a===2;if(d&&r(o,t,n),!Ar.has(e)&&(!d||Nr(u))&&c&16)for(let e=0;e<l.length;e++)i(l[e],t,n,2);d&&r(s,t,n)}function Br(e,t,n,r,i,a,{o:{nextSibling:o,parentNode:s,querySelector:c,insert:l,createText:u}},d){function f(e,n){let r=n;for(;r;){if(r&&r.nodeType===8){if(r.data===`teleport start anchor`)t.targetStart=r;else if(r.data===`teleport anchor`){t.targetAnchor=r,e._lpa=t.targetAnchor&&o(t.targetAnchor);break}}r=o(r)}}function p(e,t){t.anchor=d(o(e),t,s(e),n,r,i,a)}let m=t.target=Lr(t.props,c),h=Nr(t.props);if(m){let c=m._lpa||m.firstChild;t.shapeFlag&16&&(h?(p(e,t),f(m,c),t.targetAnchor||Ur(m,t,u,l,s(e)===m?e:null)):(t.anchor=o(e),f(m,c),t.targetAnchor||Ur(m,t,u,l),d(c&&o(c),t,m,n,r,i,a))),Hr(t,h)}else h&&t.shapeFlag&16&&(p(e,t),t.targetStart=e,t.targetAnchor=o(e));return t.anchor&&o(t.anchor)}var Vr=Rr;function Hr(e,t){let n=e.ctx;if(n&&n.ut){let r,i;for(t?(r=e.el,i=e.anchor):(r=e.targetStart,i=e.targetAnchor);r&&r!==i;)r.nodeType===1&&r.setAttribute(`data-v-owner`,n.uid),r=r.nextSibling;n.ut()}}function Ur(e,t,n,r,i=null){let a=t.targetStart=n(``),o=t.targetAnchor=n(``);return a[jr]=o,e&&(r(a,e,i),r(o,e,i)),o}var Wr=Symbol(`_leaveCb`),Gr=Symbol(`_enterCb`);function Kr(){let e={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return Zi(()=>{e.isMounted=!0}),ea(()=>{e.isUnmounting=!0}),e}var qr=[Function,Array],Jr={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:qr,onEnter:qr,onAfterEnter:qr,onEnterCancelled:qr,onBeforeLeave:qr,onLeave:qr,onAfterLeave:qr,onLeaveCancelled:qr,onBeforeAppear:qr,onAppear:qr,onAfterAppear:qr,onAppearCancelled:qr},Yr=e=>{let t=e.subTree;return t.component?Yr(t.component):t},Xr={name:`BaseTransition`,props:Jr,setup(e,{slots:t}){let n=Fs(),r=Kr();return()=>{let i=t.default&&ii(t.default(),!0),a=i&&i.length?Zr(i):n.subTree?Ts():void 0;if(!a)return;let o=A(e),{mode:s}=o;if(r.isLeaving)return ti(a);let c=ni(a);if(!c)return ti(a);let l=ei(c,o,r,n,e=>l=e);c.type!==cs&&ri(c,l);let u=n.subTree&&ni(n.subTree);if(u&&u.type!==cs&&!_s(u,c)&&Yr(n).type!==cs){let e=ei(u,o,r,n);if(ri(u,e),s===`out-in`&&c.type!==cs)return r.isLeaving=!0,e.afterLeave=()=>{r.isLeaving=!1,n.job.flags&8||n.update(),delete e.afterLeave,u=void 0},ti(a);s===`in-out`&&c.type!==cs?e.delayLeave=(e,t,n)=>{let i=$r(r,u);i[String(u.key)]=u,e[Wr]=()=>{t(),e[Wr]=void 0,delete l.delayedLeave,u=void 0},l.delayedLeave=()=>{n(),delete l.delayedLeave,u=void 0}}:u=void 0}else u&&=void 0;return a}}};function Zr(e){let t=e[0];if(e.length>1){for(let n of e)if(n.type!==cs){t=n;break}}return t}var Qr=Xr;function $r(e,t){let{leavingVNodes:n}=e,r=n.get(t.type);return r||(r=Object.create(null),n.set(t.type,r)),r}function ei(e,t,n,r,i){let{appear:a,mode:o,persisted:s=!1,onBeforeEnter:c,onEnter:l,onAfterEnter:u,onEnterCancelled:d,onBeforeLeave:f,onLeave:m,onAfterLeave:h,onLeaveCancelled:g,onBeforeAppear:_,onAppear:v,onAfterAppear:y,onAppearCancelled:b}=t,x=String(e.key),S=$r(n,e),C=(e,t)=>{e&&Hn(e,r,9,t)},w=(e,t)=>{let n=t[1];C(e,t),p(e)?e.every(e=>e.length<=1)&&n():e.length<=1&&n()},ee={mode:o,persisted:s,beforeEnter(t){let r=c;if(!n.isMounted){if(a)r=_||c;else return}t[Wr]&&t[Wr](!0);let i=S[x];i&&_s(e,i)&&i.el[Wr]&&i.el[Wr](),C(r,[t])},enter(t){if(S[x]===e)return;let r=l,i=u,o=d;if(!n.isMounted){if(a)r=v||l,i=y||u,o=b||d;else return}let s=!1;t[Gr]=e=>{s||(s=!0,C(e?o:i,[t]),ee.delayedLeave&&ee.delayedLeave(),t[Gr]=void 0)};let c=t[Gr].bind(null,!1);r?w(r,[t,c]):c()},leave(t,r){let i=String(e.key);if(t[Gr]&&t[Gr](!0),n.isUnmounting)return r();C(f,[t]);let a=!1;t[Wr]=n=>{a||(a=!0,r(),C(n?g:h,[t]),t[Wr]=void 0,S[i]===e&&delete S[i])};let o=t[Wr].bind(null,!1);S[i]=e,m?w(m,[t,o]):o()},clone(e){let a=ei(e,t,n,r,i);return i&&i(a),a}};return ee}function ti(e){if(zi(e))return e=Cs(e),e.children=null,e}function ni(e){if(!zi(e))return Mr(e.type)&&e.children?Zr(e.children):e;if(e.component)return e.component.subTree;let{shapeFlag:t,children:n}=e;if(n){if(t&16)return n[0];if(t&32&&v(n.default))return n.default()}}function ri(e,t){if(e.shapeFlag&6&&e.component){e.transition=t;let n=e.component.subTree;ri(Mr(n.type)&&ni(n)||n,t)}else e.shapeFlag&128?(e.ssContent.transition=t.clone(e.ssContent),e.ssFallback.transition=t.clone(e.ssFallback)):e.transition=t}function ii(e,t=!1,n){let r=[],i=0;for(let a=0;a<e.length;a++){let o=e[a],s=n==null?o.key:String(n)+String(o.key==null?a:o.key);o.type===L?(o.patchFlag&128&&i++,r=r.concat(ii(o.children,t,s))):(t||o.type!==cs)&&r.push(s==null?o:Cs(o,{key:s}))}if(i>1)for(let e=0;e<r.length;e++)r[e].patchFlag=-2;return r}function F(e,t){return v(e)?l({name:e.name},t,{setup:e}):e}function ai(){let e=Fs();return e?(e.appContext.config.idPrefix||`v`)+`-`+e.ids[0]+e.ids[1]++:``}function oi(e){e.ids=[e.ids[0]+e.ids[2]+++`-`,0,0]}function si(e){let t=Fs(),n=un(null);if(t){let i=t.refs===r?t.refs={}:t.refs;Object.defineProperty(i,e,{enumerable:!0,get:()=>n.value,set:e=>n.value=e})}return n}function ci(e,t){let n;return!!((n=Object.getOwnPropertyDescriptor(e,t))&&!n.configurable)}var li=new WeakMap;function ui(e,t,n,i,a=!1){if(p(e)){e.forEach((e,r)=>ui(e,t&&(p(t)?t[r]:t),n,i,a));return}if(Ii(i)&&!a){i.shapeFlag&512&&i.type.__asyncResolved&&i.component.subTree.component&&ui(e,t,n,i.component.subTree);return}let s=i.shapeFlag&4?Qs(i.component):i.el,c=a?null:s,{i:l,r:d}=e,m=t&&t.r,h=l.refs===r?l.refs={}:l.refs,g=l.setupState,_=A(g),b=g===r?o:e=>!ci(h,e)&&f(_,e),x=(e,t)=>!(t&&ci(h,t));if(m!=null&&m!==d){if(di(t),y(m))h[m]=null,b(m)&&(g[m]=null);else if(j(m)){let e=t;x(m,e.k)&&(m.value=null),e.k&&(h[e.k]=null)}}if(v(d))Vn(d,l,12,[c,h]);else{let t=y(d),r=j(d);if(t||r){let i=()=>{if(e.f){let n=t?b(d)?g[d]:h[d]:x(d)||!e.k?d.value:h[e.k];if(a)p(n)&&u(n,s);else if(p(n))n.includes(s)||n.push(s);else if(t)h[d]=[s],b(d)&&(g[d]=h[d]);else{let t=[s];x(d,e.k)&&(d.value=t),e.k&&(h[e.k]=t)}}else t?(h[d]=c,b(d)&&(g[d]=c)):r&&(x(d,e.k)&&(d.value=c),e.k&&(h[e.k]=c))};if(c){let t=()=>{i(),li.delete(e)};t.id=-1,li.set(e,t),Io(t,n)}else di(e),i()}}}function di(e){let t=li.get(e);t&&(t.flags|=8,li.delete(e))}var fi=!1,pi=()=>{fi||=(console.error(`Hydration completed but contains mismatches.`),!0)},mi=e=>e.namespaceURI.includes(`svg`)&&e.tagName!==`foreignObject`,hi=e=>e.namespaceURI.includes(`MathML`),gi=e=>{if(e.nodeType===1){if(mi(e))return`svg`;if(hi(e))return`mathml`}},_i=e=>e.nodeType===8;function vi(e){let{mt:t,p:n,o:{patchProp:r,createText:i,nextSibling:a,parentNode:o,remove:c,insert:l,createComment:u}}=e,d=(e,t)=>{if(!t.hasChildNodes()){n(null,e,t),ir(),t._vnode=e;return}f(t.firstChild,e,null,null,null),ir(),t._vnode=e},f=(n,r,s,c,u,d=!1)=>{d||=!!r.dynamicChildren;let b=_i(n)&&n.data===`[`,x=()=>g(n,r,s,c,u,b),{type:S,ref:C,shapeFlag:w,patchFlag:ee}=r,te=n.nodeType;r.el=n,ee===-2&&(d=!1,r.dynamicChildren=null);let T=null;switch(S){case ss:te===3?(n.data!==r.children&&(pi(),n.data=r.children),T=a(n)):r.children===``?(l(r.el=i(``),o(n),n),T=n):T=x();break;case cs:y(n)?(T=a(n),v(r.el=n.content.firstChild,n,s)):T=te!==8||b?x():a(n);break;case ls:if(b&&(n=a(n),te=n.nodeType),te===1||te===3){T=n;let e=!r.children.length;for(let t=0;t<r.staticCount;t++)e&&(r.children+=T.nodeType===1?T.outerHTML:T.data),t===r.staticCount-1&&(r.anchor=T),T=a(T);return b?a(T):T}x();break;case L:T=b?h(n,r,s,c,u,d):x();break;default:if(w&1)T=(te!==1||r.type.toLowerCase()!==n.tagName.toLowerCase())&&!y(n)?x():p(n,r,s,c,u,d);else if(w&6){r.slotScopeIds=u;let e=o(n);if(T=b?_(n):_i(n)&&n.data===`teleport start`?_(n,n.data,`teleport end`):a(n),t(r,e,null,s,c,gi(e),d),Ii(r)&&!r.type.__asyncResolved){let t;b?(t=H(L),t.anchor=T?T.previousSibling:e.lastChild):t=n.nodeType===3?U(``):H(`div`),t.el=n,r.component.subTree=t}}else w&64?T=te===8?r.type.hydrate(n,r,s,c,u,d,e,m):x():w&128&&(T=r.type.hydrate(n,r,s,c,gi(o(n)),u,d,e,f))}return C!=null&&ui(C,null,c,r),T},p=(e,t,n,i,a,o)=>{o||=!!t.dynamicChildren;let{type:l,dynamicProps:u,props:d,patchFlag:f,shapeFlag:p,dirs:h,transition:g}=t,_=l===`input`||l===`option`,b=!!u;if(_||b||f!==-1){h&&_r(t,null,n,`created`);let l=!1;if(y(e)){l=Ho(null,g)&&n&&n.vnode.props&&n.vnode.props.appear;let r=e.content.firstChild;if(l){let e=r.getAttribute(`class`);e&&(r.$cls=e),g.beforeEnter(r)}v(r,e,n),t.el=e=r}if(p&16&&!(d&&(d.innerHTML||d.textContent))){let r=m(e.firstChild,t,e,n,i,a,o);for(r&&!Ci(e,1)&&pi();r;){let e=r;r=r.nextSibling,c(e)}}else if(p&8){let n=t.children;n[0]===`
`&&(e.tagName===`PRE`||e.tagName===`TEXTAREA`)&&(n=n.slice(1));let{textContent:r}=e;r!==n&&r!==n.replace(/\r\n|\r/g,`
`)&&(Ci(e,0)||pi(),e.textContent=t.children)}if(d){if(_||b||!o||f&48){let t=e.tagName.includes(`-`),i=e.namespaceURI.includes(`svg`)?`svg`:e.namespaceURI.includes(`MathML`)?`mathml`:void 0;for(let a in d)if(_&&(a.endsWith(`value`)||a===`indeterminate`)||s(a)&&!ne(a)||a[0]===`.`||t&&!ne(a)||u&&u.includes(a)){if(bi(e,a,d[a]))continue;r(e,a,null,d[a],i,n)}}else if(d.onClick)r(e,`onClick`,null,d.onClick,void 0,n);else if(f&4&&nn(d.style))for(let e in d.style)d.style[e]}let x;(x=d&&d.onVnodeBeforeMount)&&As(x,n,t),h&&_r(t,null,n,`beforeMount`),((x=d&&d.onVnodeMounted)||h||l)&&is(()=>{x&&As(x,n,t),l&&g.enter(e),h&&_r(t,null,n,`mounted`)},i)}return e.nextSibling},m=(e,t,r,o,s,c,u)=>{u||=!!t.dynamicChildren;let d=t.children,p=d.length,m=!1;for(let t=0;t<p;t++){let h=u?d[t]:d[t]=Es(d[t]),g=h.type===ss;e?(g&&!u&&t+1<p&&Es(d[t+1]).type===ss&&(l(i(e.data.slice(h.children.length)),r,a(e)),e.data=h.children),e=f(e,h,o,s,c,u)):g&&!h.children?l(h.el=i(``),r):(m||(m=!0,Ci(r,1)||pi()),n(null,h,r,null,o,s,gi(r),c))}return e},h=(e,t,n,r,i,s)=>{let{slotScopeIds:c}=t;c&&(i=i?i.concat(c):c);let d=o(e),f=m(a(e),t,d,n,r,i,s);return f&&_i(f)&&f.data===`]`?a(t.anchor=f):(pi(),l(t.anchor=u(`]`),d,f),f)},g=(e,t,r,i,s,l)=>{if(Ti(e,t)||pi(),t.el=null,l){let t=_(e);for(;;){let n=a(e);if(n&&n!==t)c(n);else break}}let u=a(e),d=o(e);return c(e),n(null,t,d,u,r,i,gi(d),s),r&&(r.vnode.el=t.el,_o(r,t.el)),u},_=(e,t=`[`,n=`]`)=>{let r=0;for(;e;)if(e=a(e),e&&_i(e)&&(e.data===t&&r++,e.data===n)){if(r===0)return a(e);r--}return e},v=(e,t,n)=>{let r=t.parentNode;r&&r.replaceChild(e,t);let i=n;for(;i;)i.vnode.el===t&&(i.vnode.el=i.subTree.el=e),i=i.parent},y=e=>e.nodeType===1&&e.tagName===`TEMPLATE`;return[d,f]}var yi=new Set([`src`,`srcset`,`href`,`poster`]);function bi(e,t,n){return yi.has(t)?e.getAttribute(t)===(n==null?null:`${n}`):!1}var xi=`data-allow-mismatch`,Si={0:`text`,1:`children`,2:`class`,3:`style`,4:`attribute`};function Ci(e,t){if(t===0||t===1)for(;e&&!e.hasAttribute(xi);)e=e.parentElement;return wi(e&&e.getAttribute(xi),t)}function wi(e,t){if(e==null)return!1;if(e===``)return!0;{let n=e.split(`,`);return t===0&&n.includes(`children`)?!0:n.includes(Si[t])}}function Ti(e,t){return Ci(e.parentElement,1)||Ei(e)||Di(t)}function Ei(e){return e.nodeType===1&&wi(e.getAttribute(xi),1)}function Di({props:e}){let t=e&&e[xi];return typeof t==`string`&&wi(t,1)}var Oi=me().requestIdleCallback||(e=>setTimeout(e,1)),ki=me().cancelIdleCallback||(e=>clearTimeout(e)),Ai=(e=1e4)=>t=>{let n=Oi(t,{timeout:e});return()=>ki(n)};function ji(e){let{top:t,left:n,bottom:r,right:i}=e.getBoundingClientRect(),{innerHeight:a,innerWidth:o}=window;return(t>0&&t<a||r>0&&r<a)&&(n>0&&n<o||i>0&&i<o)}var Mi=e=>(t,n)=>{let r=new IntersectionObserver(e=>{for(let n of e)if(n.isIntersecting){r.disconnect(),t();break}},e);return n(e=>{if(e instanceof Element){if(ji(e))return t(),r.disconnect(),!1;r.observe(e)}}),()=>r.disconnect()},Ni=e=>t=>{if(e){let n=matchMedia(e);if(n.matches)t();else return n.addEventListener(`change`,t,{once:!0}),()=>n.removeEventListener(`change`,t)}},Pi=(e=[])=>(t,n)=>{y(e)&&(e=[e]);let r=!1,i=e=>{r||(r=!0,a(),t(),e.target.dispatchEvent(new e.constructor(e.type,e)))},a=()=>{n(t=>{for(let n of e)t.removeEventListener(n,i)})};return n(t=>{for(let n of e)t.addEventListener(n,i,{once:!0})}),a};function Fi(e,t){if(_i(e)&&e.data===`[`){let n=1,r=e.nextSibling;for(;r;){if(r.nodeType===1){if(t(r)===!1)break}else if(_i(r)){if(r.data===`]`){if(--n===0)break}else r.data===`[`&&n++}r=r.nextSibling}}else t(e)}var Ii=e=>!!e.type.__asyncLoader;function Li(e){v(e)&&(e={loader:e});let{loader:t,loadingComponent:n,errorComponent:r,delay:i=200,hydrate:a,timeout:o,suspensible:s=!0,onError:c}=e,l=null,u,d=0,f=()=>(d++,l=null,p()),p=()=>{let e;return l||(e=l=t().catch(e=>{if(e=e instanceof Error?e:Error(String(e)),c)return new Promise((t,n)=>{c(e,()=>t(f()),()=>n(e),d+1)});throw e}).then(t=>e!==l&&l?l:(t&&(t.__esModule||t[Symbol.toStringTag]===`Module`)&&(t=t.default),u=t,t)))};return F({name:`AsyncComponentWrapper`,__asyncLoader:p,__asyncHydrate(e,t,n){let r=e.isConnected,i=!1;(t.bu||=[]).push(()=>i=!0);let o=()=>{i||!e.parentNode||r&&!e.isConnected||n()},s=a?()=>{let n=a(o,t=>Fi(e,t));n&&(t.bum||=[]).push(n)}:o;u?s():p().then(()=>!t.isUnmounted&&s())},get __asyncResolved(){return u},setup(){let e=Ps;if(oi(e),u)return()=>Ri(u,e);let t=t=>{l=null,Un(t,e,13,!r)};if(s&&e.suspense||Vs)return p().then(t=>()=>Ri(t,e)).catch(e=>(t(e),()=>r?H(r,{error:e}):null));let a=M(!1),c=M(),d=M(!!i),f,m;return ta(()=>{f!=null&&clearTimeout(f),m!=null&&clearTimeout(m)}),i&&(m=setTimeout(()=>{e.isUnmounted||(d.value=!1)},i)),o!=null&&(f=setTimeout(()=>{if(!e.isUnmounted&&!a.value&&!c.value){let e=Error(`Async component timed out after ${o}ms.`);t(e),c.value=e}},o)),p().then(()=>{e.isUnmounted||(a.value=!0,e.parent&&zi(e.parent.vnode)&&e.parent.update())}).catch(n=>{if(e.isUnmounted){l=null;return}t(n),c.value=n}),()=>{if(a.value&&u)return Ri(u,e);if(c.value&&r)return H(r,{error:c.value});if(n&&!d.value)return Ri(n,e)}}})}function Ri(e,t){let{ref:n,props:r,children:i,ce:a}=t.vnode,o=H(e,r,i);return o.ref=n,o.ce=a,delete t.vnode.ce,o}var zi=e=>e.type.__isKeepAlive,Bi={name:`KeepAlive`,__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(e,{slots:t}){let n=Fs(),r=n.ctx;if(!r.renderer)return()=>{let e=t.default&&t.default();return e&&e.length===1?e[0]:e};let i=new Map,a=new Set,o=null,s=n.suspense,{renderer:{p:c,m:l,um:u,o:{createElement:d}}}=r,f=d(`div`);r.activate=(e,t,n,r,i)=>{let a=e.component;l(e,t,n,0,s),c(a.vnode,e,t,n,a,s,r,e.slotScopeIds,i),Io(()=>{a.isDeactivated=!1,a.a&&le(a.a);let t=e.props&&e.props.onVnodeMounted;t&&As(t,a.parent,e)},s)},r.deactivate=e=>{let t=e.component;Ko(t.m),Ko(t.a),l(e,f,null,1,s),Io(()=>{t.da&&le(t.da);let n=e.props&&e.props.onVnodeUnmounted;n&&As(n,t.parent,e),t.isDeactivated=!0},s)};function p(e){Ki(e),u(e,n,s,!0)}function m(e){i.forEach((t,n)=>{let r=$s(Ii(t)?t.type.__asyncResolved||{}:t.type);r&&!e(r)&&h(n)})}function h(e){let t=i.get(e);t&&(!o||!_s(t,o))?p(t):o&&Ki(o),i.delete(e),a.delete(e)}Er(()=>[e.include,e.exclude],([e,t])=>{e&&m(t=>Vi(e,t)),t&&m(e=>!Vi(t,e))},{flush:`post`,deep:!0});let g=null,_=()=>{g!=null&&(Jo(n.subTree.type)?Io(()=>{i.set(g,qi(n.subTree))},n.subTree.suspense):i.set(g,qi(n.subTree)))};return Zi(_),$i(_),ea(()=>{i.forEach(e=>{let{subTree:t,suspense:r}=n,i=qi(t);if(e.type===i.type&&e.key===i.key){Ki(i);let e=i.component.da;e&&Io(e,r);return}p(e)})}),()=>{if(g=null,!t.default)return o=null;let n=t.default(),r=n[0];if(n.length>1)return o=null,n;if(!gs(r)||!(r.shapeFlag&4)&&!(r.shapeFlag&128))return o=null,r;let s=qi(r);if(s.type===cs)return o=null,s;let c=s.type,l=$s(Ii(s)?s.type.__asyncResolved||{}:c),{include:u,exclude:d,max:f}=e;if(u&&(!l||!Vi(u,l))||d&&l&&Vi(d,l))return s.shapeFlag&=-257,o=s,r;let p=s.key==null?c:s.key,m=i.get(p);return s.el&&(s=Cs(s),r.shapeFlag&128&&(r.ssContent=s)),g=p,m?(s.el=m.el,s.component=m.component,s.transition&&ri(s,s.transition),s.shapeFlag|=512,a.delete(p),a.add(p)):(a.add(p),f&&a.size>parseInt(f,10)&&h(a.values().next().value)),s.shapeFlag|=256,o=s,Jo(r.type)?r:s}}};function Vi(e,t){return p(e)?e.some(e=>Vi(e,t)):y(e)?e.split(`,`).includes(t):_(e)?(e.lastIndex=0,e.test(t)):!1}function Hi(e,t){Wi(e,`a`,t)}function Ui(e,t){Wi(e,`da`,t)}function Wi(e,t,n=Ps){let r=e.__wdc||=()=>{let t=n;for(;t;){if(t.isDeactivated)return;t=t.parent}return e()};if(Ji(t,r,n),n){let e=n.parent;for(;e&&e.parent;)zi(e.parent.vnode)&&Gi(r,t,n,e),e=e.parent}}function Gi(e,t,n,r){let i=Ji(t,e,r,!0);ta(()=>{u(r[t],i)},n)}function Ki(e){e.shapeFlag&=-257,e.shapeFlag&=-513}function qi(e){return e.shapeFlag&128?e.ssContent:e}function Ji(e,t,n=Ps,r=!1){if(n){let i=n[e]||(n[e]=[]),a=t.__weh||=(...r)=>{nt();let i=Rs(n),a=Hn(t,n,e,r);return i(),rt(),a};return r?i.unshift(a):i.push(a),a}}var Yi=e=>(t,n=Ps)=>{(!Vs||e===`sp`)&&Ji(e,(...e)=>t(...e),n)},Xi=Yi(`bm`),Zi=Yi(`m`),Qi=Yi(`bu`),$i=Yi(`u`),ea=Yi(`bum`),ta=Yi(`um`),na=Yi(`sp`),ra=Yi(`rtg`),ia=Yi(`rtc`);function aa(e,t=Ps){Ji(`ec`,e,t)}var oa=`components`,sa=`directives`;function ca(e,t){return fa(oa,e,!0,t)||e}var la=Symbol.for(`v-ndc`);function ua(e){return y(e)?fa(oa,e,!1)||e:e||la}function da(e){return fa(sa,e)}function fa(e,t,n=!0,r=!1){let i=ur||Ps;if(i){let n=i.type;if(e===oa){let e=$s(n,!1);if(e&&(e===t||e===E(t)||e===se(E(t))))return n}let a=pa(i[e]||n[e],t)||pa(i.appContext[e],t);return!a&&r?n:a}}function pa(e,t){return e&&(e[t]||e[E(t)]||e[se(E(t))])}function ma(e,t,n,r){let i,a=n&&n[r],o=p(e);if(o||y(e)){let n=o&&nn(e),r=!1,s=!1;n&&(r=!an(e),s=rn(e),e=_t(e)),i=Array(e.length);for(let n=0,o=e.length;n<o;n++)i[n]=t(r?s?ln(cn(e[n])):cn(e[n]):e[n],n,void 0,a&&a[n])}else if(typeof e==`number`){i=Array(e);for(let n=0;n<e;n++)i[n]=t(n+1,n,void 0,a&&a[n])}else if(x(e)){if(e[Symbol.iterator])i=Array.from(e,(e,n)=>t(e,n,void 0,a&&a[n]));else{let n=Object.keys(e);i=Array(n.length);for(let r=0,o=n.length;r<o;r++){let o=n[r];i[r]=t(e[o],o,r,a&&a[r])}}}else i=[];return n&&(n[r]=i),i}function ha(e,t){for(let n=0;n<t.length;n++){let r=t[n];if(p(r))for(let t=0;t<r.length;t++)e[r[t].name]=r[t].fn;else r&&(e[r.name]=r.key?(...e)=>{let t=r.fn(...e);return t&&(t.key=r.key),t}:r.fn)}return e}function I(e,t,n,r,i,a){if(n??={},ur.ce||ur.parent&&Ii(ur.parent)&&ur.parent.ce){let e=a!=null&&n.key==null?l({},n,{key:a}):n,i=Object.keys(e).length>0;return t!=="default"&&(e.name=t),R(),B(L,null,[H(`slot`,e,r&&r())],i?-2:64)}let o=e[t];o&&o._c&&(o._d=!1);let s=us.length;R();let c;try{let i=o&&ga(o(n)),s=n.key||a||i&&i.key;c=B(L,{key:(s&&!b(s)?s:`_${t}`)+(!i&&r?`_fb`:``)},i||(r?r():[]),i&&e._===1?64:-2)}catch(e){for(let e=us.length;e>s;e--)fs();throw e}finally{o&&o._c&&(o._d=!0)}return!i&&c.scopeId&&(c.slotScopeIds=[c.scopeId+`-s`]),c}function ga(e){return e.some(e=>!gs(e)||!(e.type===cs||e.type===L&&!ga(e.children)))?e:null}function _a(e,t){let n={};for(let r in e)n[t&&/[A-Z]/.test(r)?`on:${r}`:ce(r)]=e[r];return n}var va=e=>e?Bs(e)?Qs(e):va(e.parent):null,ya=l(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>e.props,$attrs:e=>e.attrs,$slots:e=>e.slots,$refs:e=>e.refs,$parent:e=>va(e.parent),$root:e=>va(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>Ua(e),$forceUpdate:e=>e.f||=()=>{er(e.update)},$nextTick:e=>e.n||=Qn.bind(e.proxy),$watch:e=>Or.bind(e)}),ba=(e,t)=>e!==r&&!e.__isScriptSetup&&f(e,t),xa={get({_:e},t){if(t===`__v_skip`)return!0;let{ctx:n,setupState:i,data:a,props:o,accessCache:s,type:c,appContext:l}=e;if(t[0]!==`$`){let e=s[t];if(e!==void 0)switch(e){case 1:return i[t];case 2:return a[t];case 4:return n[t];case 3:return o[t]}else if(ba(i,t))return s[t]=1,i[t];else if(a!==r&&f(a,t))return s[t]=2,a[t];else if(f(o,t))return s[t]=3,o[t];else if(n!==r&&f(n,t))return s[t]=4,n[t];else Ra&&(s[t]=0)}let u=ya[t],d,p;if(u)return t===`$attrs`&&pt(e.attrs,`get`,``),u(e);if((d=c.__cssModules)&&(d=d[t]))return d;if(n!==r&&f(n,t))return s[t]=4,n[t];if(p=l.config.globalProperties,f(p,t))return p[t]},set({_:e},t,n){let{data:i,setupState:a,ctx:o}=e;return ba(a,t)?(a[t]=n,!0):i!==r&&f(i,t)?(i[t]=n,!0):f(e.props,t)||t[0]===`$`&&t.slice(1)in e?!1:(o[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:i,appContext:a,props:o,type:s}},c){let l;return!!(n[c]||e!==r&&c[0]!==`$`&&f(e,c)||ba(t,c)||f(o,c)||f(i,c)||f(ya,c)||f(a.config.globalProperties,c)||(l=s.__cssModules)&&l[c])},defineProperty(e,t,n){return n.get==null?f(n,`value`)&&this.set(e,t,n.value,null):e._.accessCache[t]=0,Reflect.defineProperty(e,t,n)}},Sa=l({},xa,{get(e,t){if(t!==Symbol.unscopables)return xa.get(e,t,e)},has(e,t){return t[0]!==`_`&&!he(t)}});function Ca(){return null}function wa(){return null}function Ta(e){}function Ea(e){}function Da(){return null}function Oa(){}function ka(e,t){return null}function Aa(){return Ma(`useSlots`).slots}function ja(){return Ma(`useAttrs`).attrs}function Ma(e){let t=Fs();return t.setupContext||=Zs(t)}function Na(e){return p(e)?e.reduce((e,t)=>(e[t]=null,e),{}):e}function Pa(e,t){let n=Na(e);for(let e in t){if(e.startsWith(`__skip`))continue;let r=n[e];r?p(r)||v(r)?r=n[e]={type:r,default:t[e]}:r.default=t[e]:r===null&&(r=n[e]={default:t[e]}),r&&t[`__skip_${e}`]&&(r.skipFactory=!0)}return n}function Fa(e,t){return!e||!t?e||t:p(e)&&p(t)?e.concat(t):l({},Na(e),Na(t))}function Ia(e,t){let n={};for(let r in e)t.includes(r)||Object.defineProperty(n,r,{enumerable:!0,get:()=>e[r]});return n}function La(e){let t=Fs(),n=Vs,r=e();zs(),n&&Ls(!1);let i=()=>{Rs(t),n&&Ls(!0)},a=()=>{Fs()!==t&&t.scope.off(),zs(),n&&Ls(!1)};return S(r)&&(r=r.catch(e=>{throw i(),Promise.resolve().then(()=>Promise.resolve().then(a)),e})),[r,()=>{i(),Promise.resolve().then(a)}]}var Ra=!0;function za(e){let t=Ua(e),n=e.proxy,r=e.ctx;Ra=!1,t.beforeCreate&&Va(t.beforeCreate,e,`bc`);let{data:i,computed:o,methods:s,watch:c,provide:l,inject:u,created:d,beforeMount:f,mounted:m,beforeUpdate:h,updated:g,activated:_,deactivated:y,beforeDestroy:b,beforeUnmount:S,destroyed:C,unmounted:w,render:ee,renderTracked:te,renderTriggered:T,errorCaptured:ne,serverPrefetch:re,expose:ie,inheritAttrs:E,components:ae,directives:oe,filters:se}=t;if(u&&Ba(u,r,null),s)for(let e in s){let t=s[e];v(t)&&(r[e]=t.bind(n))}if(i){let t=i.call(n,n);x(t)&&(e.data=Zt(t))}if(Ra=!0,o)for(let e in o){let t=o[e],i=W({get:v(t)?t.bind(n,n):v(t.get)?t.get.bind(n,n):a,set:!v(t)&&v(t.set)?t.set.bind(n):a});Object.defineProperty(r,e,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e})}if(c)for(let e in c)Ha(c[e],r,n,e);if(l){let e=v(l)?l.call(n):l;Reflect.ownKeys(e).forEach(t=>{vr(t,e[t])})}d&&Va(d,e,`c`);function ce(e,t){p(t)?t.forEach(t=>e(t.bind(n))):t&&e(t.bind(n))}if(ce(Xi,f),ce(Zi,m),ce(Qi,h),ce($i,g),ce(Hi,_),ce(Ui,y),ce(aa,ne),ce(ia,te),ce(ra,T),ce(ea,S),ce(ta,w),ce(na,re),p(ie)){if(ie.length){let t=e.exposed||={};ie.forEach(e=>{Object.defineProperty(t,e,{get:()=>n[e],set:t=>n[e]=t,enumerable:!0})})}else e.exposed||={}}ee&&e.render===a&&(e.render=ee),E!=null&&(e.inheritAttrs=E),ae&&(e.components=ae),oe&&(e.directives=oe),re&&oi(e)}function Ba(e,t,n=a){p(e)&&(e=Ja(e));for(let n in e){let r=e[n],i;i=x(r)?`default`in r?yr(r.from||n,r.default,!0):yr(r.from||n):yr(r),j(i)?Object.defineProperty(t,n,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e}):t[n]=i}}function Va(e,t,n){Hn(p(e)?e.map(e=>e.bind(t.proxy)):e.bind(t.proxy),t,n)}function Ha(e,t,n,r){let i=r.includes(`.`)?kr(n,r):()=>n[r];if(y(e)){let n=t[e];v(n)&&Er(i,n)}else if(v(e))Er(i,e.bind(n));else if(x(e)){if(p(e))e.forEach(e=>Ha(e,t,n,r));else{let r=v(e.handler)?e.handler.bind(n):t[e.handler];v(r)&&Er(i,r,e)}}}function Ua(e){let t=e.type,{mixins:n,extends:r}=t,{mixins:i,optionsCache:a,config:{optionMergeStrategies:o}}=e.appContext,s=a.get(t),c;return s?c=s:!i.length&&!n&&!r?c=t:(c={},i.length&&i.forEach(e=>Wa(c,e,o,!0)),Wa(c,t,o)),x(t)&&a.set(t,c),c}function Wa(e,t,n,r=!1){let{mixins:i,extends:a}=t;a&&Wa(e,a,n,!0),i&&i.forEach(t=>Wa(e,t,n,!0));for(let i in t)if(!(r&&i===`expose`)){let r=Ga[i]||n&&n[i];e[i]=r?r(e[i],t[i]):t[i]}return e}var Ga={data:Ka,props:Za,emits:Za,methods:Xa,computed:Xa,beforeCreate:Ya,created:Ya,beforeMount:Ya,mounted:Ya,beforeUpdate:Ya,updated:Ya,beforeDestroy:Ya,beforeUnmount:Ya,destroyed:Ya,unmounted:Ya,activated:Ya,deactivated:Ya,errorCaptured:Ya,serverPrefetch:Ya,components:Xa,directives:Xa,watch:Qa,provide:Ka,inject:qa};function Ka(e,t){return t?e?function(){return l(v(e)?e.call(this,this):e,v(t)?t.call(this,this):t)}:t:e}function qa(e,t){return Xa(Ja(e),Ja(t))}function Ja(e){if(p(e)){let t={};for(let n=0;n<e.length;n++)t[e[n]]=e[n];return t}return e}function Ya(e,t){return e?[...new Set([].concat(e,t))]:t}function Xa(e,t){return e?l(Object.create(null),e,t):t}function Za(e,t){return e?p(e)&&p(t)?[...new Set([...e,...t])]:l(Object.create(null),Na(e),Na(t??{})):t}function Qa(e,t){if(!e)return t;if(!t)return e;let n=l(Object.create(null),e);for(let r in t)n[r]=Ya(e[r],t[r]);return n}function $a(){return{app:null,config:{isNativeTag:o,performance:!1,globalProperties:{},optionMergeStrategies:{},errorHandler:void 0,warnHandler:void 0,compilerOptions:{}},mixins:[],components:{},directives:{},provides:Object.create(null),optionsCache:new WeakMap,propsCache:new WeakMap,emitsCache:new WeakMap}}var eo=0;function to(e,t){return function(n,r=null){v(n)||(n=l({},n)),r!=null&&!x(r)&&(r=null);let i=$a(),a=new WeakSet,o=[],s=!1,c=i.app={_uid:eo++,_component:n,_props:r,_container:null,_context:i,_instance:null,version:ic,get config(){return i.config},set config(e){},use(e,...t){return a.has(e)||(e&&v(e.install)?(a.add(e),e.install(c,...t)):v(e)&&(a.add(e),e(c,...t))),c},mixin(e){return i.mixins.includes(e)||i.mixins.push(e),c},component(e,t){return t?(i.components[e]=t,c):i.components[e]},directive(e,t){return t?(i.directives[e]=t,c):i.directives[e]},mount(a,o,l){if(!s){let u=c._ceVNode||H(n,r);return u.appContext=i,l===!0?l=`svg`:l===!1&&(l=void 0),o&&t?t(u,a):e(u,a,l),s=!0,c._container=a,a.__vue_app__=c,Qs(u.component)}},onUnmount(e){o.push(e)},unmount(){s&&(Hn(o,c._instance,16),e(null,c._container),delete c._container.__vue_app__)},provide(e,t){return i.provides[e]=t,c},runWithContext(e){let t=no;no=c;try{return e()}finally{no=t}}};return c}}var no=null;function ro(e,t,n=r){let i=Fs(),a=E(t),o=oe(t),s=io(e,a),c=vn((s,c)=>{let l,u=r,d;return Tr(()=>{let t=e[a];D(l,t)&&(l=t,c())}),{get(){return s(),n.get?n.get(l):l},set(e){let s=n.set?n.set(e):e;if(!D(s,l)&&!(u!==r&&D(e,u)))return;let f=i.vnode.props,p=!!(f&&(t in f||a in f||o in f)&&(`onUpdate:${t}`in f||`onUpdate:${a}`in f||`onUpdate:${o}`in f));p||(l=e,c()),i.emit(`update:${t}`,s),D(e,u)&&(D(e,s)&&!D(s,d)||p&&u!==r&&!D(s,l))&&c(),u=e,d=s}}});return c[Symbol.iterator]=()=>{let e=0;return{next(){return e<2?{value:e++?s||r:c,done:!1}:{done:!0}}}},c}var io=(e,t)=>t===`modelValue`||t===`model-value`?e.modelModifiers:e[`${t}Modifiers`]||e[`${E(t)}Modifiers`]||e[`${oe(t)}Modifiers`];function ao(e,t,...n){if(e.isUnmounted)return;let i=e.vnode.props||r,a=n,o=t.startsWith(`update:`),s=o&&io(i,t.slice(7));s&&(s.trim&&(a=n.map(e=>y(e)?e.trim():e)),s.number&&(a=n.map(de)));let c,l=i[c=ce(t)]||i[c=ce(E(t))];!l&&o&&(l=i[c=ce(oe(t))]),l&&Hn(l,e,6,a);let u=i[c+`Once`];if(u){if(!e.emitted)e.emitted={};else if(e.emitted[c])return;e.emitted[c]=!0,Hn(u,e,6,a)}}var oo=new WeakMap;function so(e,t,n=!1){let r=n?oo:t.emitsCache,i=r.get(e);if(i!==void 0)return i;let a=e.emits,o={},s=!1;if(!v(e)){let r=e=>{let n=so(e,t,!0);n&&(s=!0,l(o,n))};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}return!a&&!s?(x(e)&&r.set(e,null),null):(p(a)?a.forEach(e=>o[e]=null):l(o,a),x(e)&&r.set(e,o),o)}function co(e,t){return!e||!s(t)?!1:(t=t.slice(2),t=t===`Once`?t:t.replace(/Once$/,``),f(e,t[0].toLowerCase()+t.slice(1))||f(e,oe(t))||f(e,t))}function lo(e){let{type:t,vnode:n,proxy:r,withProxy:i,propsOptions:[a],slots:o,attrs:s,emit:l,render:u,renderCache:d,props:f,data:p,setupState:m,ctx:h,inheritAttrs:g}=e,_=fr(e),v,y;try{if(n.shapeFlag&4){let e=i||r,t=e;v=Es(u.call(t,e,d,f,m,p,h)),y=s}else{let e=t;v=Es(e.length>1?e(f,{attrs:s,slots:o,emit:l}):e(f,null)),y=t.props?s:fo(s)}}catch(t){us.length=0,Un(t,e,1),v=H(cs)}let b=v;if(y&&g!==!1){let e=Object.keys(y),{shapeFlag:t}=b;e.length&&t&7&&(a&&e.some(c)&&(y=po(y,a)),b=Cs(b,y,!1,!0))}return n.dirs&&(b=Cs(b,null,!1,!0),b.dirs=b.dirs?b.dirs.concat(n.dirs):n.dirs),n.transition&&ri(Mr(b.type)&&ni(b)||b,n.transition),v=b,fr(_),v}function uo(e,t=!0){let n;for(let t=0;t<e.length;t++){let r=e[t];if(gs(r)){if(r.type!==cs||r.children===`v-if`){if(n)return;n=r}}else return}return n}var fo=e=>{let t;for(let n in e)(n===`class`||n===`style`||s(n))&&((t||={})[n]=e[n]);return t},po=(e,t)=>{let n={};for(let r in e)(!c(r)||!(r.slice(9)in t))&&(n[r]=e[r]);return n};function mo(e,t,n){let{props:r,children:i,component:a}=e,{props:o,children:s,patchFlag:c}=t,l=a.emitsOptions;if(t.dirs||t.transition)return!0;if(n&&c>=0){if(c&1024)return!0;if(c&16)return r?ho(r,o,l):!!o;if(c&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let n=e[t];if(go(o,r,n)&&!co(l,n))return!0}}}else return(i||s)&&(!s||!s.$stable)?!0:r===o?!1:r?!o||ho(r,o,l):!!o;return!1}function ho(e,t,n){let r=Object.keys(t);if(r.length!==Object.keys(e).length)return!0;for(let i=0;i<r.length;i++){let a=r[i];if(go(t,e,a)&&!co(n,a))return!0}return!1}function go(e,t,n){let r=e[n],i=t[n];return n===`style`&&x(r)&&x(i)?!Ee(r,i):r!==i}function _o({vnode:e,parent:t,suspense:n},r){for(;t;){let n=t.subTree;if(n.suspense&&n.suspense.activeBranch===e&&(n.suspense.vnode.el=n.el=r,e=n),n===e)(e=t.vnode).el=r,t=t.parent;else break}n&&n.activeBranch===e&&(n.vnode.el=r)}var vo={},yo=()=>Object.create(vo),bo=e=>Object.getPrototypeOf(e)===vo;function xo(e,t,n,r=!1){let i={},a=yo();e.propsDefaults=Object.create(null),Co(e,t,i,a);for(let t in e.propsOptions[0])t in i||(i[t]=void 0);e.props=n?r?i:Qt(i):e.type.props?i:a,e.attrs=a}function So(e,t,n,r){let{props:i,attrs:a,vnode:{patchFlag:o}}=e,s=A(i),[c]=e.propsOptions,l=!1;if((r||o>0)&&!(o&16)){if(o&8){let n=e.vnode.dynamicProps;for(let r=0;r<n.length;r++){let o=n[r];if(co(e.emitsOptions,o))continue;let u=t[o];if(c){if(f(a,o))u!==a[o]&&(a[o]=u,l=!0);else{let t=E(o);i[t]=wo(c,s,t,u,e,!1)}}else u!==a[o]&&(a[o]=u,l=!0)}}}else{Co(e,t,i,a)&&(l=!0);let r;for(let a in s)(!t||!f(t,a)&&((r=oe(a))===a||!f(t,r)))&&(c?n&&(n[a]!==void 0||n[r]!==void 0)&&(i[a]=wo(c,s,a,void 0,e,!0)):delete i[a]);if(a!==s)for(let e in a)(!t||!f(t,e))&&(delete a[e],l=!0)}l&&mt(e.attrs,`set`,``)}function Co(e,t,n,i){let[a,o]=e.propsOptions,s=!1,c;if(t)for(let r in t){if(ne(r))continue;let l=t[r],u;a&&f(a,u=E(r))?!o||!o.includes(u)?n[u]=l:(c||={})[u]=l:co(e.emitsOptions,r)||(!(r in i)||l!==i[r])&&(i[r]=l,s=!0)}if(o){let t=A(n),i=c||r;for(let r=0;r<o.length;r++){let s=o[r];n[s]=wo(a,t,s,i[s],e,!f(i,s))}}return s}function wo(e,t,n,r,i,a){let o=e[n];if(o!=null){let e=f(o,`default`);if(e&&r===void 0){let e=o.default;if(o.type!==Function&&!o.skipFactory&&v(e)){let{propsDefaults:a}=i;if(n in a)r=a[n];else{let o=Rs(i);r=a[n]=e.call(null,t),o()}}else r=e;i.ce&&i.ce._setProp(n,r)}o[0]&&(a&&!e?r=!1:o[1]&&(r===``||r===oe(n))&&(r=!0))}return r}var To=new WeakMap;function Eo(e,t,n=!1){let a=n?To:t.propsCache,o=a.get(e);if(o)return o;let s=e.props,c={},u=[],d=!1;if(!v(e)){let r=e=>{d=!0;let[n,r]=Eo(e,t,!0);l(c,n),r&&u.push(...r)};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}if(!s&&!d)return x(e)&&a.set(e,i),i;if(p(s))for(let e=0;e<s.length;e++){let t=E(s[e]);Do(t)&&(c[t]=r)}else if(s)for(let e in s){let t=E(e);if(Do(t)){let n=s[e],r=c[t]=p(n)||v(n)?{type:n}:l({},n),i=r.type,a=!1,o=!0;if(p(i))for(let e=0;e<i.length;++e){let t=i[e],n=v(t)&&t.name;if(n===`Boolean`){a=!0;break}n===`String`&&(o=!1)}else a=v(i)&&i.name===`Boolean`;r[0]=a,r[1]=o,(a||f(r,`default`))&&u.push(t)}}let m=[c,u];return x(e)&&a.set(e,m),m}function Do(e){return e[0]!==`$`&&!ne(e)}var Oo=e=>e===`_`||e===`_ctx`||e===`$stable`,ko=e=>p(e)?e.map(Es):[Es(e)],Ao=(e,t,n)=>{if(t._n)return t;let r=P((...e)=>ko(t(...e)),n);return r._c=!1,r},jo=(e,t,n)=>{let r=e._ctx;for(let n in e){if(Oo(n))continue;let i=e[n];if(v(i))t[n]=Ao(n,i,r);else if(i!=null){let e=ko(i);t[n]=()=>e}}},Mo=(e,t)=>{let n=ko(t);e.slots.default=()=>n},No=(e,t,n)=>{for(let r in t)(n||!Oo(r))&&(e[r]=t[r])},Po=(e,t,n)=>{let r=e.slots=yo();if(e.vnode.shapeFlag&32){let e=t._;e?(No(r,t,n),n&&ue(r,`_`,e,!0)):jo(t,r)}else t&&Mo(e,t)},Fo=(e,t,n)=>{let{vnode:i,slots:a}=e,o=!0,s=r;if(i.shapeFlag&32){let e=t._;e?n&&e===1?o=!1:No(a,t,n):(o=!t.$stable,jo(t,a)),s=t}else t&&(Mo(e,t),s={default:1});if(o)for(let e in a)!Oo(e)&&s[e]==null&&delete a[e]},Io=is;function Lo(e){return zo(e)}function Ro(e){return zo(e,vi)}function zo(e,t){let n=me();n.__VUE__=!0;let{insert:o,remove:s,patchProp:c,createElement:l,createText:u,createComment:d,setText:f,setElementText:p,parentNode:m,nextSibling:h,setScopeId:g=a,insertStaticContent:_}=e,v=(e,t,n,r=null,i=null,a=null,o=void 0,s=null,c=!!t.dynamicChildren)=>{if(e===t)return;e&&!_s(e,t)&&(r=O(e),ge(e,i,a,!0),e=null),t.patchFlag===-2&&(c=!1,t.dynamicChildren=null);let{type:l,ref:u,shapeFlag:d}=t;switch(l){case ss:y(e,t,n,r);break;case cs:b(e,t,n,r);break;case ls:e??x(t,n,r,o);break;case L:ae(e,t,n,r,i,a,o,s,c);break;default:d&1?w(e,t,n,r,i,a,o,s,c):d&6?oe(e,t,n,r,i,a,o,s,c):(d&64||d&128)&&l.process(e,t,n,r,i,a,o,s,c,Ce)}u!=null&&i?ui(u,e&&e.ref,a,t||e,!t):u==null&&e&&e.ref!=null&&ui(e.ref,null,a,e,!0)},y=(e,t,n,r)=>{if(e==null)o(t.el=u(t.children),n,r);else{let n=t.el=e.el;t.children!==e.children&&f(n,t.children)}},b=(e,t,n,r)=>{e==null?o(t.el=d(t.children||``),n,r):t.el=e.el},x=(e,t,n,r)=>{[e.el,e.anchor]=_(e.children,t,n,r,e.el,e.anchor)},S=({el:e,anchor:t},n,r)=>{let i;for(;e&&e!==t;)i=h(e),o(e,n,r),e=i;o(t,n,r)},C=({el:e,anchor:t})=>{let n;for(;e&&e!==t;)n=h(e),s(e),e=n;s(t)},w=(e,t,n,r,i,a,o,s,c)=>{if(t.type===`svg`?o=`svg`:t.type===`math`&&(o=`mathml`),e==null)ee(t,n,r,i,a,o,s,c);else{let n=e.el&&e.el._isVueCE?e.el:null;try{n&&n._beginPatch(),re(e,t,i,a,o,s,c)}finally{n&&n._endPatch()}}},ee=(e,t,n,r,i,a,s,u)=>{let d,f,{props:m,shapeFlag:h,transition:g,dirs:_}=e;if(d=e.el=l(e.type,a,m&&m.is,m),h&8?p(d,e.children):h&16&&T(e.children,d,null,r,i,Bo(e,a),s,u),_&&_r(e,null,r,`created`),te(d,e,e.scopeId,s,r),m){for(let e in m)e!==`value`&&!ne(e)&&c(d,e,null,m[e],a,r);`value`in m&&c(d,`value`,null,m.value,a),(f=m.onVnodeBeforeMount)&&As(f,r,e)}_&&_r(e,null,r,`beforeMount`);let v=Ho(i,g);v&&g.beforeEnter(d),o(d,t,n),((f=m&&m.onVnodeMounted)||v||_)&&Io(()=>{try{f&&As(f,r,e),v&&g.enter(d),_&&_r(e,null,r,`mounted`)}finally{}},i)},te=(e,t,n,r,i)=>{if(n&&g(e,n),r)for(let t=0;t<r.length;t++)g(e,r[t]);if(i){let n=i.subTree;if(t===n||Jo(n.type)&&(n.ssContent===t||n.ssFallback===t)){let t=i.vnode;te(e,t,t.scopeId,t.slotScopeIds,i.parent)}}},T=(e,t,n,r,i,a,o,s,c=0)=>{for(let l=c;l<e.length;l++){let c=e[l]=s?Ds(e[l]):Es(e[l]);v(null,c,t,n,r,i,a,o,s)}},re=(e,t,n,i,a,o,s)=>{let l=t.el=e.el,{patchFlag:u,dynamicChildren:d,dirs:f}=t;u|=e.patchFlag&16;let m=e.props||r,h=t.props||r,g;if(n&&Vo(n,!1),(g=h.onVnodeBeforeUpdate)&&As(g,n,t,e),f&&_r(t,e,n,`beforeUpdate`),n&&Vo(n,!0),d&&(!e.dynamicChildren||e.dynamicChildren.length!==d.length)&&(u=0,s=!1,d=null),(m.innerHTML&&h.innerHTML==null||m.textContent&&h.textContent==null)&&p(l,``),d?ie(e.dynamicChildren,d,l,n,i,Bo(t,a),o):s||de(e,t,l,null,n,i,Bo(t,a),o,!1),u>0){if(u&16)E(l,m,h,n,a);else if(u&2&&m.class!==h.class&&c(l,`class`,null,h.class,a),u&4&&c(l,`style`,m.style,h.style,a),u&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let r=e[t],i=m[r],o=h[r];(o!==i||r===`value`)&&c(l,r,i,o,a,n)}}u&1&&e.children!==t.children&&p(l,t.children)}else!s&&d==null&&E(l,m,h,n,a);((g=h.onVnodeUpdated)||f)&&Io(()=>{g&&As(g,n,t,e),f&&_r(t,e,n,`updated`)},i)},ie=(e,t,n,r,i,a,o)=>{for(let s=0;s<t.length;s++){let c=e[s],l=t[s],u=c.el&&(c.type===L||!_s(c,l)||c.shapeFlag&198)?m(c.el):n;v(c,l,u,null,r,i,a,o,!0)}},E=(e,t,n,i,a)=>{if(t!==n){if(t!==r)for(let r in t)!ne(r)&&!(r in n)&&c(e,r,t[r],null,a,i);for(let r in n){if(ne(r))continue;let o=n[r],s=t[r];o!==s&&r!==`value`&&c(e,r,s,o,a,i)}`value`in n&&c(e,`value`,t.value,n.value,a)}},ae=(e,t,n,r,i,a,s,c,l)=>{let d=t.el=e?e.el:u(``),f=t.anchor=e?e.anchor:u(``),{patchFlag:p,dynamicChildren:m,slotScopeIds:h}=t;h&&(c=c?c.concat(h):h),e==null?(o(d,n,r),o(f,n,r),T(t.children||[],n,f,i,a,s,c,l)):p>0&&p&64&&m&&e.dynamicChildren&&e.dynamicChildren.length===m.length?(ie(e.dynamicChildren,m,n,i,a,s,c),(t.key!=null||i&&t===i.subTree)&&Uo(e,t,!0)):de(e,t,n,f,i,a,s,c,l)},oe=(e,t,n,r,i,a,o,s,c)=>{t.slotScopeIds=s,e==null?t.shapeFlag&512?i.ctx.activate(t,n,r,o,c):se(t,n,r,i,a,o,c):ce(e,t,c)},se=(e,t,n,r,i,a,o)=>{let s=e.component=Ns(e,r,i);if(zi(e)&&(s.ctx.renderer=Ce),Hs(s,!1,o),s.asyncDep){if(i&&i.registerDep(s,D,o),!e.el){let r=s.subTree=H(cs);b(null,r,t,n),e.placeholder=r.el}}else D(s,e,t,n,i,a,o)},ce=(e,t,n)=>{let r=t.component=e.component;if(mo(e,t,n)){if(r.asyncDep&&!r.asyncResolved){ue(r,t,n);return}r.next=t,r.update()}else t.el=e.el,r.vnode=t},D=(e,t,n,r,i,a,o)=>{let s=()=>{if(e.isMounted){let{next:t,bu:n,u:r,parent:s,vnode:c}=e;{let n=Go(e);if(n){t&&(t.el=c.el,ue(e,t,o)),n.asyncDep.then(()=>{Io(()=>{e.isUnmounted||l()},i)});return}}let u=t,d;Vo(e,!1),t?(t.el=c.el,ue(e,t,o)):t=c,n&&le(n),(d=t.props&&t.props.onVnodeBeforeUpdate)&&As(d,s,t,c),Vo(e,!0);let f=lo(e),p=e.subTree;e.subTree=f,v(p,f,m(p.el),O(p),e,i,a),t.el=f.el,u===null&&_o(e,f.el),r&&Io(r,i),(d=t.props&&t.props.onVnodeUpdated)&&Io(()=>As(d,s,t,c),i)}else{let o,{el:s,props:c}=t,{bm:l,m:u,parent:d,root:f,type:p}=e,m=Ii(t);if(Vo(e,!1),l&&le(l),!m&&(o=c&&c.onVnodeBeforeMount)&&As(o,d,t),Vo(e,!0),s&&Te){let t=()=>{e.subTree=lo(e),Te(s,e.subTree,e,i,null)};m&&p.__asyncHydrate?p.__asyncHydrate(s,e,t):t()}else{f.ce&&f.ce._hasShadowRoot()&&f.ce._injectChildStyle(p,e.parent?e.parent.type:void 0);let o=e.subTree=lo(e);v(null,o,n,r,e,i,a),t.el=o.el}if(u&&Io(u,i),!m&&(o=c&&c.onVnodeMounted)){let e=t;Io(()=>As(o,d,e),i)}(t.shapeFlag&256||d&&Ii(d.vnode)&&d.vnode.shapeFlag&256)&&e.a&&Io(e.a,i),e.isMounted=!0,t=n=r=null}};e.scope.on();let c=e.effect=new ze(s);e.scope.off();let l=e.update=c.run.bind(c),u=e.job=c.runIfDirty.bind(c);u.i=e,u.id=e.uid,c.scheduler=()=>er(u),Vo(e,!0),l()},ue=(e,t,n)=>{t.component=e;let r=e.vnode.props;e.vnode=t,e.next=null,So(e,t.props,r,n),Fo(e,t.children,n),nt(),rr(e),rt()},de=(e,t,n,r,i,a,o,s,c=!1)=>{let l=e&&e.children,u=e?e.shapeFlag:0,d=t.children,{patchFlag:f,shapeFlag:m}=t;if(f>0){if(f&128){pe(l,d,n,r,i,a,o,s,c);return}if(f&256){fe(l,d,n,r,i,a,o,s,c);return}}m&8?(u&16&&be(l,i,a),d!==l&&p(n,d)):u&16?m&16?pe(l,d,n,r,i,a,o,s,c):be(l,i,a,!0):(u&8&&p(n,``),m&16&&T(d,n,r,i,a,o,s,c))},fe=(e,t,n,r,a,o,s,c,l)=>{e||=i,t||=i;let u=e.length,d=t.length,f=Math.min(u,d),p;for(p=0;p<f;p++){let r=t[p]=l?Ds(t[p]):Es(t[p]);v(e[p],r,n,null,a,o,s,c,l)}u>d?be(e,a,o,!0,!1,f):T(t,n,r,a,o,s,c,l,f)},pe=(e,t,n,r,a,o,s,c,l)=>{let u=0,d=t.length,f=e.length-1,p=d-1;for(;u<=f&&u<=p;){let r=e[u],i=t[u]=l?Ds(t[u]):Es(t[u]);if(_s(r,i))v(r,i,n,null,a,o,s,c,l);else break;u++}for(;u<=f&&u<=p;){let r=e[f],i=t[p]=l?Ds(t[p]):Es(t[p]);if(_s(r,i))v(r,i,n,null,a,o,s,c,l);else break;f--,p--}if(u>f){if(u<=p){let e=p+1,i=e<d?t[e].el:r;for(;u<=p;)v(null,t[u]=l?Ds(t[u]):Es(t[u]),n,i,a,o,s,c,l),u++}}else if(u>p)for(;u<=f;)ge(e[u],a,o,!0),u++;else{let m=u,h=u,g=new Map;for(u=h;u<=p;u++){let e=t[u]=l?Ds(t[u]):Es(t[u]);e.key!=null&&g.set(e.key,u)}let _,y=0,b=p-h+1,x=!1,S=0,C=Array(b);for(u=0;u<b;u++)C[u]=0;for(u=m;u<=f;u++){let r=e[u];if(y>=b){ge(r,a,o,!0);continue}let i;if(r.key!=null)i=g.get(r.key);else for(_=h;_<=p;_++)if(C[_-h]===0&&_s(r,t[_])){i=_;break}i===void 0?ge(r,a,o,!0):(C[i-h]=u+1,i>=S?S=i:x=!0,v(r,t[i],n,null,a,o,s,c,l),y++)}let w=x?Wo(C):i;for(_=w.length-1,u=b-1;u>=0;u--){let e=h+u,i=t[e],f=t[e+1],p=e+1<d?f.el||qo(f):r;C[u]===0?v(null,i,n,p,a,o,s,c,l):x&&(_<0||u!==w[_]?he(i,n,p,2):_--)}}},he=(e,t,n,r,i=null)=>{let{el:a,type:c,transition:l,children:u,shapeFlag:d}=e;if(d&6){he(e.component.subTree,t,n,r);return}if(d&128){e.suspense.move(t,n,r);return}if(d&64){c.move(e,t,n,Ce);return}if(c===L){o(a,t,n);for(let e=0;e<u.length;e++)he(u[e],t,n,r);o(e.anchor,t,n);return}if(c===ls){S(e,t,n);return}if(r!==2&&d&1&&l){if(r===0)l.persisted&&!a[Wr]?o(a,t,n):(l.beforeEnter(a),o(a,t,n),Io(()=>l.enter(a),i));else{let{leave:r,delayLeave:i,afterLeave:c}=l,u=()=>{e.ctx.isUnmounted?s(a):o(a,t,n)},d=()=>{let e=a._isLeaving||!!a[Wr];a._isLeaving&&a[Wr](!0),l.persisted&&!e?u():r(a,()=>{u(),c&&c()})};i?i(a,u,d):d()}}else o(a,t,n)},ge=(e,t,n,r=!1,i=!1)=>{let{type:a,props:o,ref:s,children:c,dynamicChildren:l,shapeFlag:u,patchFlag:d,dirs:f,cacheIndex:p,memo:m}=e;if(d===-2&&(i=!1),s!=null&&(nt(),ui(s,null,n,e,!0),rt()),p!=null&&(t.renderCache[p]=void 0),u&256){t.ctx.deactivate(e);return}let h=u&1&&f,g=!Ii(e),_;if(g&&(_=o&&o.onVnodeBeforeUnmount)&&As(_,t,e),u&6)ye(e.component,n,r);else{if(u&128){e.suspense.unmount(n,r);return}h&&_r(e,null,t,`beforeUnmount`),u&64?e.type.remove(e,t,n,Ce,r):l&&!l.hasOnce&&(a!==L||d>0&&d&64)?be(l,t,n,!1,!0):(a===L&&d&384||!i&&u&16)&&be(c,t,n),r&&_e(e)}let v=m!=null&&p==null;(g&&(_=o&&o.onVnodeUnmounted)||h||v)&&Io(()=>{_&&As(_,t,e),h&&_r(e,null,t,`unmounted`),v&&(e.el=null)},n)},_e=e=>{let{type:t,el:n,anchor:r,transition:i}=e;if(t===L){ve(n,r);return}if(t===ls){C(e);return}let a=()=>{s(n),i&&!i.persisted&&i.afterLeave&&i.afterLeave()};if(e.shapeFlag&1&&i&&!i.persisted){let{leave:t,delayLeave:r}=i,o=()=>t(n,a);r?r(e.el,a,o):o()}else a()},ve=(e,t)=>{let n;for(;e!==t;)n=h(e),s(e),e=n;s(t)},ye=(e,t,n)=>{let{bum:r,scope:i,job:a,subTree:o,um:s,m:c,a:l}=e;Ko(c),Ko(l),r&&le(r),i.stop(),a&&(a.flags|=8,ge(o,e,t,n)),s&&Io(s,t),Io(()=>{e.isUnmounted=!0},t)},be=(e,t,n,r=!1,i=!1,a=0)=>{for(let o=a;o<e.length;o++)ge(e[o],t,n,r,i)},O=e=>{if(e.shapeFlag&6)return O(e.component.subTree);if(e.shapeFlag&128)return e.suspense.next();let t=h(e.anchor||e.el),n=t&&t[jr];return n?h(n):t},xe=!1,Se=(e,t,n)=>{let r;e==null?t._vnode&&(ge(t._vnode,null,null,!0),r=t._vnode.component):v(t._vnode||null,e,t,null,null,null,n),t._vnode=e,xe||=(xe=!0,rr(r),ir(),!1)},Ce={p:v,um:ge,m:he,r:_e,mt:se,mc:T,pc:de,pbc:ie,n:O,o:e},we,Te;return t&&([we,Te]=t(Ce)),{render:Se,hydrate:we,createApp:to(Se,we)}}function Bo({type:e,props:t},n){return n===`svg`&&e===`foreignObject`||n===`mathml`&&e===`annotation-xml`&&t&&t.encoding&&t.encoding.includes(`html`)?void 0:n}function Vo({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function Ho(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function Uo(e,t,n=!1){let r=e.children,i=t.children;if(p(r)&&p(i))for(let e=0;e<r.length;e++){let t=r[e],a=i[e];a.shapeFlag&1&&!a.dynamicChildren&&((a.patchFlag<=0||a.patchFlag===32)&&(a=i[e]=Ds(i[e]),a.el=t.el),!n&&a.patchFlag!==-2&&Uo(t,a)),a.type===ss&&(a.patchFlag===-1&&(a=i[e]=Ds(a)),a.el=t.el),a.type===cs&&!a.el&&(a.el=t.el)}}function Wo(e){let t=e.slice(),n=[0],r,i,a,o,s,c=e.length;for(r=0;r<c;r++){let c=e[r];if(c!==0){if(i=n[n.length-1],e[i]<c){t[r]=i,n.push(r);continue}for(a=0,o=n.length-1;a<o;)s=a+o>>1,e[n[s]]<c?a=s+1:o=s;c<e[n[a]]&&(a>0&&(t[r]=n[a-1]),n[a]=r)}}for(a=n.length,o=n[a-1];a-->0;)n[a]=o,o=t[o];return n}function Go(e){let t=e.subTree.component;if(t)return t.asyncDep&&!t.asyncResolved?t:Go(t)}function Ko(e){if(e)for(let t=0;t<e.length;t++)e[t].flags|=8}function qo(e){if(e.placeholder)return e.placeholder;let t=e.component;return t?qo(t.subTree):null}var Jo=e=>e.__isSuspense,Yo=0,Xo={name:`Suspense`,__isSuspense:!0,process(e,t,n,r,i,a,o,s,c,l){if(e==null)Qo(t,n,r,i,a,o,s,c,l);else{if(a&&a.deps>0&&!e.suspense.isInFallback){t.suspense=e.suspense,t.suspense.vnode=t,t.el=e.el;return}$o(e,t,n,r,i,o,s,c,l)}},hydrate:ts,normalize:ns};function Zo(e,t){let n=e.props&&e.props[t];v(n)&&n()}function Qo(e,t,n,r,i,a,o,s,c){let{p:l,o:{createElement:u}}=c,d=u(`div`),f=e.suspense=es(e,i,r,t,d,n,a,o,s,c);l(null,f.pendingBranch=e.ssContent,d,null,r,f,a,o),f.deps>0?(Zo(e,`onPending`),Zo(e,`onFallback`),l(null,e.ssFallback,t,n,r,null,a,o),as(f,e.ssFallback)):f.resolve(!1,!0)}function $o(e,t,n,r,i,a,o,s,{p:c,um:l,o:{createElement:u}}){let d=t.suspense=e.suspense;d.vnode=t,t.el=e.el;let f=t.ssContent,p=t.ssFallback,{activeBranch:m,pendingBranch:h,isInFallback:g,isHydrating:_}=d;if(h)d.pendingBranch=f,_s(h,f)?(c(h,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0?d.resolve():g&&(_||(c(m,p,n,r,i,null,a,o,s),as(d,p)))):(d.pendingId=Yo++,_?(d.isHydrating=!1,d.activeBranch=h):l(h,i,d),d.deps=0,d.effects.length=0,d.hiddenContainer=u(`div`),g?(c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0?d.resolve():(c(m,p,n,r,i,null,a,o,s),as(d,p))):m&&_s(m,f)?(c(m,f,n,r,i,d,a,o,s),d.resolve(!0)):(c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0&&d.resolve()));else if(m&&_s(m,f))c(m,f,n,r,i,d,a,o,s),as(d,f);else if(Zo(t,`onPending`),d.pendingBranch=f,d.pendingId=f.shapeFlag&512?f.component.suspenseId:Yo++,c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0)d.resolve();else{let{timeout:e,pendingId:t}=d;e>0?setTimeout(()=>{d.pendingId===t&&d.fallback(p)},e):e===0&&d.fallback(p)}}function es(e,t,n,r,i,a,o,s,c,l,u=!1){let{p:d,m:f,um:p,n:m,o:{parentNode:h,remove:g}}=l,_,v=os(e);v&&t&&t.pendingBranch&&(_=t.pendingId,t.deps++);let y=e.props?fe(e.props.timeout):void 0,b=a,x={vnode:e,parent:t,parentComponent:n,namespace:o,container:r,hiddenContainer:i,deps:0,pendingId:Yo++,timeout:typeof y==`number`?y:-1,activeBranch:null,isFallbackMountPending:!1,pendingBranch:null,isInFallback:!u,isHydrating:u,isUnmounted:!1,effects:[],resolve(e=!1,n=!1){let{vnode:r,activeBranch:i,pendingBranch:o,pendingId:s,effects:c,parentComponent:l,container:u,isInFallback:d}=x,g=!1;if(x.isHydrating)x.isHydrating=!1;else if(!e){g=i&&o.transition&&o.transition.mode===`out-in`;let e=!1;g&&(i.transition.afterLeave=()=>{s===x.pendingId&&(f(o,u,a===b&&!e?m(i):a,0),nr(c),d&&r.ssFallback&&(r.ssFallback.el=null))}),i&&!x.isFallbackMountPending&&(h(i.el)===u&&(a=m(i),e=!0),p(i,l,x,!0),!g&&d&&r.ssFallback&&Io(()=>r.ssFallback.el=null,x)),g||f(o,u,a,0)}x.isFallbackMountPending=!1,as(x,o),x.pendingBranch=null,x.isInFallback=!1;let y=x.parent,S=!1;for(;y;){if(y.pendingBranch){for(let e=0;e<c.length;e++)y.effects.push(c[e]);S=!0;break}y=y.parent}!S&&!g&&nr(c),x.effects=[],v&&t&&t.pendingBranch&&_===t.pendingId&&(t.deps--,t.deps===0&&!n&&t.resolve()),Zo(r,`onResolve`)},fallback(e){if(!x.pendingBranch)return;let{vnode:t,activeBranch:n,parentComponent:r,container:i,namespace:a}=x;Zo(t,`onFallback`);let o=m(n),l=()=>{x.isFallbackMountPending=!1,x.isInFallback&&(d(null,e,i,o,r,null,a,s,c),as(x,e))},u=e.transition&&e.transition.mode===`out-in`;u&&(x.isFallbackMountPending=!0,n.transition.afterLeave=l),x.isInFallback=!0,p(n,r,null,!0),u||l()},move(e,t,n){x.activeBranch&&f(x.activeBranch,e,t,n),x.container=e},next(){return x.activeBranch&&m(x.activeBranch)},registerDep(e,t,n){let r=!!x.pendingBranch;r&&x.deps++;let i=e.vnode.el;e.asyncDep.catch(t=>{Un(t,e,0)}).then(a=>{if(e.isUnmounted||x.isUnmounted||x.pendingId!==e.suspenseId)return;zs(),e.asyncResolved=!0;let{vnode:s}=e;Ws(e,a,!1),i&&(s.el=i);let c=!i&&e.subTree.el;t(e,s,h(i||e.subTree.el),i?null:m(e.subTree),x,o,n),c&&(s.placeholder=null,g(c)),_o(e,s.el),r&&--x.deps===0&&x.resolve()})},unmount(e,t){x.isUnmounted=!0,x.activeBranch&&p(x.activeBranch,n,e,t),x.pendingBranch&&p(x.pendingBranch,n,e,t)}};return x}function ts(e,t,n,r,i,a,o,s,c){let l=t.suspense=es(t,r,n,e.parentNode,document.createElement(`div`),null,i,a,o,s,!0),u=c(e,l.pendingBranch=t.ssContent,n,l,a,o);return l.deps===0&&l.resolve(!1,!0),u}function ns(e){let{shapeFlag:t,children:n}=e,r=t&32;e.ssContent=rs(r?n.default:n),e.ssFallback=r?rs(n.fallback):H(cs)}function rs(e){let t;if(v(e)){let n=ps&&e._c;n&&(e._d=!1,R()),e=e(),n&&(e._d=!0,t=ds,fs())}return p(e)&&(e=uo(e)),e=Es(e),t&&!e.dynamicChildren&&(e.dynamicChildren=t.filter(t=>t!==e)),e}function is(e,t){t&&t.pendingBranch?p(e)?t.effects.push(...e):t.effects.push(e):nr(e)}function as(e,t){e.activeBranch=t;let{vnode:n,parentComponent:r}=e,i=t.el;for(;!i&&t.component;)t=t.component.subTree,i=t.el;n.el=i,r&&r.subTree===n&&(r.vnode.el=i,_o(r,i))}function os(e){let t=e.props&&e.props.suspensible;return t!=null&&t!==!1}var L=Symbol.for(`v-fgt`),ss=Symbol.for(`v-txt`),cs=Symbol.for(`v-cmt`),ls=Symbol.for(`v-stc`),us=[],ds=null;function R(e=!1){us.push(ds=e?null:[])}function fs(){us.pop(),ds=us[us.length-1]||null}var ps=1;function ms(e,t=!1){ps+=e,e<0&&ds&&t&&(ds.hasOnce=!0)}function hs(e){return e.dynamicChildren=ps>0?ds||i:null,fs(),ps>0&&ds&&ds.push(e),e}function z(e,t,n,r,i,a){return hs(V(e,t,n,r,i,a,!0))}function B(e,t,n,r,i){return hs(H(e,t,n,r,i,!0))}function gs(e){return e?e.__v_isVNode===!0:!1}function _s(e,t){return e.type===t.type&&e.key===t.key}function vs(e){}var ys=({key:e})=>e??null,bs=({ref:e,ref_key:t,ref_for:n})=>(typeof e==`number`&&(e=``+e),e==null?null:y(e)||j(e)||v(e)?{i:ur,r:e,k:t,f:!!n}:e);function V(e,t=null,n=null,r=0,i=null,a=e===L?0:1,o=!1,s=!1){let c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&ys(t),ref:t&&bs(t),scopeId:dr,slotScopeIds:null,children:n,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetStart:null,targetAnchor:null,staticCount:0,shapeFlag:a,patchFlag:r,dynamicProps:i,dynamicChildren:null,appContext:null,ctx:ur};return s?(Os(c,n),a&128&&e.normalize(c)):n&&(c.shapeFlag|=y(n)?8:16),ps>0&&!o&&ds&&(c.patchFlag>0||a&6)&&c.patchFlag!==32&&ds.push(c),c}var H=xs;function xs(e,t=null,n=null,r=0,i=null,a=!1){if((!e||e===la)&&(e=cs),gs(e)){let r=Cs(e,t,!0);return n&&Os(r,n),ps>0&&!a&&ds&&(r.shapeFlag&6?ds[ds.indexOf(e)]=r:ds.push(r)),r.patchFlag=-2,r}if(ec(e)&&(e=e.__vccOpts),t){t=Ss(t);let{class:e,style:n}=t;e&&!y(e)&&(t.class=O(e)),x(n)&&(on(n)&&!p(n)&&(n=l({},n)),t.style=ge(n))}let o=y(e)?1:Jo(e)?128:Mr(e)?64:x(e)?4:v(e)?2:0;return V(e,t,n,r,i,o,a,!0)}function Ss(e){return e?on(e)||bo(e)?l({},e):e:null}function Cs(e,t,n=!1,r=!1){let{props:i,ref:a,patchFlag:o,children:s,transition:c}=e,l=t?ks(i||{},t):i,u={__v_isVNode:!0,__v_skip:!0,type:e.type,props:l,key:l&&ys(l),ref:t&&t.ref?n&&a?p(a)?a.concat(bs(t)):[a,bs(t)]:bs(t):a,scopeId:e.scopeId,slotScopeIds:e.slotScopeIds,children:s,target:e.target,targetStart:e.targetStart,targetAnchor:e.targetAnchor,staticCount:e.staticCount,shapeFlag:e.shapeFlag,patchFlag:t&&e.type!==L?o===-1?16:o|16:o,dynamicProps:e.dynamicProps,dynamicChildren:e.dynamicChildren,appContext:e.appContext,dirs:e.dirs,transition:c,component:e.component,suspense:e.suspense,ssContent:e.ssContent&&Cs(e.ssContent),ssFallback:e.ssFallback&&Cs(e.ssFallback),placeholder:e.placeholder,el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce};return c&&r&&ri(u,c.clone(u)),u}function U(e=` `,t=0){return H(ss,null,e,t)}function ws(e,t){let n=H(ls,null,e);return n.staticCount=t,n}function Ts(e=``,t=!1){return t?(R(),B(cs,null,e)):H(cs,null,e)}function Es(e){return e==null||typeof e==`boolean`?H(cs):p(e)?H(L,null,e.slice()):gs(e)?Ds(e):H(ss,null,String(e))}function Ds(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:Cs(e)}function Os(e,t){let n=0,{shapeFlag:r}=e;if(t==null)t=null;else if(p(t))n=16;else if(typeof t==`object`){if(r&65){let n=t.default;n&&(n._c&&(n._d=!1),Os(e,n()),n._c&&(n._d=!0));return}{n=32;let r=t._;!r&&!bo(t)?t._ctx=ur:r===3&&ur&&(ur.slots._===1?t._=1:(t._=2,e.patchFlag|=1024))}}else if(v(t)){if(r&65){Os(e,{default:t});return}t={default:t,_ctx:ur},n=32}else t=String(t),r&64?(n=16,t=[U(t)]):n=8;e.children=t,e.shapeFlag|=n}function ks(...e){let t={};for(let n=0;n<e.length;n++){let r=e[n];for(let e in r)if(e===`class`)t.class!==r.class&&(t.class=O([t.class,r.class]));else if(e===`style`)t.style=ge([t.style,r.style]);else if(s(e)){let n=t[e],i=r[e];i&&n!==i&&!(p(n)&&n.includes(i))?t[e]=n?[].concat(n,i):i:i==null&&n==null&&!c(e)&&(t[e]=i)}else e!==``&&(t[e]=r[e])}return t}function As(e,t,n,r=null){Hn(e,t,7,[n,r])}var js=$a(),Ms=0;function Ns(e,t,n){let i=e.type,a=(t?t.appContext:e.appContext)||js,o={uid:Ms++,vnode:e,type:i,parent:t,appContext:a,root:null,next:null,subTree:null,effect:null,update:null,job:null,scope:new Ne(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:t?t.provides:Object.create(a.provides),ids:t?t.ids:[``,0,0],accessCache:null,renderCache:[],components:null,directives:null,propsOptions:Eo(i,a),emitsOptions:so(i,a),emit:null,emitted:null,propsDefaults:r,inheritAttrs:i.inheritAttrs,ctx:r,data:r,props:r,attrs:r,slots:r,refs:r,setupState:r,setupContext:null,suspense:n,suspenseId:n?n.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return o.ctx={_:o},o.root=t?t.root:o,o.emit=ao.bind(null,o),e.ce&&e.ce(o),o}var Ps=null,Fs=()=>Ps||ur,Is,Ls;{let e=me(),t=(t,n)=>{let r;return(r=e[t])||(r=e[t]=[]),r.push(n),e=>{r.length>1?r.forEach(t=>t(e)):r[0](e)}};Is=t(`__VUE_INSTANCE_SETTERS__`,e=>Ps=e),Ls=t(`__VUE_SSR_SETTERS__`,e=>Vs=e)}var Rs=e=>{let t=Ps;return Is(e),e.scope.on(),()=>{e.scope.off(),Is(t)}},zs=()=>{Ps&&Ps.scope.off(),Is(null)};function Bs(e){return e.vnode.shapeFlag&4}var Vs=!1;function Hs(e,t=!1,n=!1){t&&Ls(t);let{props:r,children:i}=e.vnode,a=Bs(e);xo(e,r,a,t),Po(e,i,n||t);let o=a?Us(e,t):void 0;return t&&Ls(!1),o}function Us(e,t){let n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,xa);let{setup:r}=n;if(r){nt();let n=e.setupContext=r.length>1?Zs(e):null,i=Rs(e),a=Vn(r,e,0,[e.props,n]),o=S(a);if(rt(),i(),(o||e.sp)&&!Ii(e)&&oi(e),o){if(a.then(zs,zs),t)return a.then(n=>{Ls(!0);try{Ws(e,n,t)}finally{Ls(!1)}}).catch(t=>{Un(t,e,0)});e.asyncDep=a}else Ws(e,a,t)}else Ys(e,t)}function Ws(e,t,n){v(t)?e.type.__ssrInlineRender?e.ssrRender=t:e.render=t:x(t)&&(e.setupState=gn(t)),Ys(e,n)}var Gs,Ks;function qs(e){Gs=e,Ks=e=>{e.render._rc&&(e.withProxy=new Proxy(e.ctx,Sa))}}var Js=()=>!Gs;function Ys(e,t,n){let r=e.type;if(!e.render){if(!t&&Gs&&!r.render){let t=r.template||Ua(e).template;if(t){let{isCustomElement:n,compilerOptions:i}=e.appContext.config,{delimiters:a,compilerOptions:o}=r,s=l(l({isCustomElement:n,delimiters:a},i),o);r.render=Gs(t,s)}}e.render=r.render||a,Ks&&Ks(e)}{let t=Rs(e);nt();try{za(e)}finally{rt(),t()}}}var Xs={get(e,t){return pt(e,`get`,``),e[t]}};function Zs(e){return{attrs:new Proxy(e.attrs,Xs),slots:e.slots,emit:e.emit,expose:t=>{e.exposed=t||{}}}}function Qs(e){return e.exposed?e.exposeProxy||=new Proxy(gn(sn(e.exposed)),{get(t,n){if(n in t)return t[n];if(n in ya)return ya[n](e)},has(e,t){return t in e||t in ya}}):e.proxy}function $s(e,t=!0){return v(e)?e.displayName||e.name:e.name||t&&e.__name}function ec(e){return v(e)&&`__vccOpts`in e}var W=(e,t)=>Tn(e,t,Vs);function G(e,t,n){try{ms(-1);let r=arguments.length;return r===2?x(t)&&!p(t)?gs(t)?H(e,null,[t]):H(e,t):H(e,null,t):(r>3?n=Array.prototype.slice.call(arguments,2):r===3&&gs(n)&&(n=[n]),H(e,t,n))}finally{ms(1)}}function tc(){}function nc(e,t,n,r){let i=n[r];if(i&&rc(i,e))return i;let a=t();return a.memo=e.slice(),a.cacheIndex=r,n[r]=a}function rc(e,t){let n=e.memo;if(n.length!=t.length)return!1;for(let e=0;e<n.length;e++)if(D(n[e],t[e]))return!1;return ps>0&&ds&&ds.push(e),!0}var ic=`3.5.41`,ac=a,oc=Bn,sc=sr,cc=lr,lc={createComponentInstance:Ns,setupComponent:Hs,renderComponentRoot:lo,setCurrentRenderingInstance:fr,isVNode:gs,normalizeVNode:Es,getComponentPublicInstance:Qs,ensureValidVNode:ga,pushWarningContext:In,popWarningContext:Ln},uc=void 0,dc=typeof window<`u`&&window.trustedTypes;if(dc)try{uc=dc.createPolicy(`vue`,{createHTML:e=>e})}catch{}var fc=uc?e=>uc.createHTML(e):e=>e,pc=`http://www.w3.org/2000/svg`,mc=`http://www.w3.org/1998/Math/MathML`,hc=typeof document<`u`?document:null,gc=hc&&hc.createElement(`template`),_c={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{let t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,r)=>{let i=t===`svg`?hc.createElementNS(pc,e):t===`mathml`?hc.createElementNS(mc,e):n?hc.createElement(e,{is:n}):hc.createElement(e);return e===`select`&&r&&r.multiple!=null&&i.setAttribute(`multiple`,r.multiple),i},createText:e=>hc.createTextNode(e),createComment:e=>hc.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>hc.querySelector(e),setScopeId(e,t){e.setAttribute(t,``)},insertStaticContent(e,t,n,r,i,a){let o=n?n.previousSibling:t.lastChild;if(i&&(i===a||i.nextSibling))for(;t.insertBefore(i.cloneNode(!0),n),!(i===a||!(i=i.nextSibling)););else{gc.innerHTML=fc(r===`svg`?`<svg>${e}</svg>`:r===`mathml`?`<math>${e}</math>`:e);let i=gc.content;if(r===`svg`||r===`mathml`){let e=i.firstChild;for(;e.firstChild;)i.appendChild(e.firstChild);i.removeChild(e)}t.insertBefore(i,n)}return[o?o.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},vc=`transition`,yc=`animation`,bc=Symbol(`_vtc`),xc={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Sc=l({},Jr,xc),Cc=(e=>(e.displayName=`Transition`,e.props=Sc,e))((e,{slots:t})=>G(Qr,Ec(e),t)),wc=(e,t=[])=>{p(e)?e.forEach(e=>e(...t)):e&&e(...t)},Tc=e=>e?p(e)?e.some(e=>e.length>1):e.length>1:!1;function Ec(e){let t={};for(let n in e)n in xc||(t[n]=e[n]);if(e.css===!1)return t;let{name:n=`v`,type:r,duration:i,enterFromClass:a=`${n}-enter-from`,enterActiveClass:o=`${n}-enter-active`,enterToClass:s=`${n}-enter-to`,appearFromClass:c=a,appearActiveClass:u=o,appearToClass:d=s,leaveFromClass:f=`${n}-leave-from`,leaveActiveClass:p=`${n}-leave-active`,leaveToClass:m=`${n}-leave-to`}=e,h=Dc(i),g=h&&h[0],_=h&&h[1],{onBeforeEnter:v,onEnter:y,onEnterCancelled:b,onLeave:x,onLeaveCancelled:S,onBeforeAppear:C=v,onAppear:w=y,onAppearCancelled:ee=b}=t,te=(e,t,n,r)=>{e._enterCancelled=r,Ac(e,t?d:s),Ac(e,t?u:o),n&&n()},T=(e,t)=>{e._isLeaving=!1,Ac(e,f),Ac(e,m),Ac(e,p),t&&t()},ne=e=>(t,n)=>{let i=e?w:y,o=()=>te(t,e,n);wc(i,[t,o]),jc(()=>{Ac(t,e?c:a),kc(t,e?d:s),Tc(i)||Nc(t,r,g,o)})};return l(t,{onBeforeEnter(e){wc(v,[e]),kc(e,a),kc(e,o)},onBeforeAppear(e){wc(C,[e]),kc(e,c),kc(e,u)},onEnter:ne(!1),onAppear:ne(!0),onLeave(e,t){e._isLeaving=!0;let n=()=>T(e,t);kc(e,f),e._enterCancelled?(kc(e,p),Lc(e)):(Lc(e),kc(e,p)),jc(()=>{e._isLeaving&&(Ac(e,f),kc(e,m),Tc(x)||Nc(e,r,_,n))}),wc(x,[e,n])},onEnterCancelled(e){te(e,!1,void 0,!0),wc(b,[e])},onAppearCancelled(e){te(e,!0,void 0,!0),wc(ee,[e])},onLeaveCancelled(e){T(e),wc(S,[e])}})}function Dc(e){if(e==null)return null;if(x(e))return[Oc(e.enter),Oc(e.leave)];{let t=Oc(e);return[t,t]}}function Oc(e){return fe(e)}function kc(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.add(t)),(e[bc]||(e[bc]=new Set)).add(t)}function Ac(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.remove(t));let n=e[bc];n&&(n.delete(t),n.size||(e[bc]=void 0))}function jc(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}var Mc=0;function Nc(e,t,n,r){let i=e._endId=++Mc,a=()=>{i===e._endId&&r()};if(n!=null)return setTimeout(a,n);let{type:o,timeout:s,propCount:c}=Pc(e,t);if(!o)return r();let l=o+`end`,u=0,d=()=>{e.removeEventListener(l,f),a()},f=t=>{t.target===e&&++u>=c&&d()};setTimeout(()=>{u<c&&d()},s+1),e.addEventListener(l,f)}function Pc(e,t){let n=window.getComputedStyle(e),r=e=>(n[e]||``).split(`, `),i=r(`${vc}Delay`),a=r(`${vc}Duration`),o=Fc(i,a),s=r(`${yc}Delay`),c=r(`${yc}Duration`),l=Fc(s,c),u=null,d=0,f=0;t===vc?o>0&&(u=vc,d=o,f=a.length):t===yc?l>0&&(u=yc,d=l,f=c.length):(d=Math.max(o,l),u=d>0?o>l?vc:yc:null,f=u?u===vc?a.length:c.length:0);let p=u===vc&&/\b(?:transform|all)(?:,|$)/.test(r(`${vc}Property`).toString());return{type:u,timeout:d,propCount:f,hasTransform:p}}function Fc(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max(...t.map((t,n)=>Ic(t)+Ic(e[n])))}function Ic(e){return e===`auto`?0:Number(e.slice(0,-1).replace(`,`,`.`))*1e3}function Lc(e){return(e?e.ownerDocument:document).body.offsetHeight}function Rc(e,t,n){let r=e[bc];r&&(t=(t?[t,...r]:[...r]).join(` `)),t==null?e.removeAttribute(`class`):n?e.setAttribute(`class`,t):e.className=t}var zc=Symbol(`_vod`),Bc=Symbol(`_vsh`),Vc={name:`show`,beforeMount(e,{value:t},{transition:n}){e[zc]=e.style.display===`none`?``:e.style.display,n&&t?n.beforeEnter(e):Hc(e,t)},mounted(e,{value:t},{transition:n}){n&&t&&n.enter(e)},updated(e,{value:t,oldValue:n},{transition:r}){!t!=!n&&(r?t?(r.beforeEnter(e),Hc(e,!0),r.enter(e)):r.leave(e,()=>{Hc(e,!1)}):Hc(e,t))},beforeUnmount(e,{value:t}){Hc(e,t)}};function Hc(e,t){e.style.display=t?e[zc]:`none`,e[Bc]=!t}function Uc(){Vc.getSSRProps=({value:e})=>{if(!e)return{style:{display:`none`}}}}var Wc=Symbol(``);function Gc(e){let t=Fs();if(!t)return;let n=t.ut=(n=e(t.proxy))=>{Array.from(document.querySelectorAll(`[data-v-owner="${t.uid}"]`)).forEach(e=>qc(e,n))},r=()=>{let r=e(t.proxy);t.ce?qc(t.ce,r):Kc(t.subTree,r),n(r)};Qi(()=>{nr(r)}),Zi(()=>{Er(r,a,{flush:`post`});let e=new MutationObserver(r);e.observe(t.subTree.el.parentNode,{childList:!0}),ta(()=>e.disconnect())})}function Kc(e,t){if(e.shapeFlag&128){let n=e.suspense;e=n.activeBranch,n.pendingBranch&&!n.isHydrating&&n.effects.push(()=>{Kc(n.activeBranch,t)})}for(;e.component;)e=e.component.subTree;if(e.shapeFlag&1&&e.el)qc(e.el,t);else if(e.type===L)e.children.forEach(e=>Kc(e,t));else if(e.type===ls){let{el:n,anchor:r}=e;for(;n&&(qc(n,t),n!==r);)n=n.nextSibling}}function qc(e,t){if(e.nodeType===1){let n=e.style,r=``;for(let e in t){let i=je(t[e]);n.setProperty(`--${e}`,i),r+=`--${e}: ${i};`}n[Wc]=r}}var Jc=/(?:^|;)\s*display\s*:/;function Yc(e,t,n){let r=e.style,i=y(n),a=!1;if(n&&!i){if(t){if(y(t))for(let e of t.split(`;`)){let t=e.slice(0,e.indexOf(`:`)).trim();n[t]??Zc(r,t,``)}else for(let e in t)n[e]??Zc(r,e,``)}for(let i in n){i===`display`&&(a=!0);let o=n[i];o==null?Zc(r,i,``):tl(e,i,!y(t)&&t?t[i]:void 0,o)||Zc(r,i,o)}}else if(i){if(t!==n){let e=r[Wc];e&&(n+=`;`+e),r.cssText=n,a=Jc.test(n)}}else t&&e.removeAttribute(`style`);zc in e&&(e[zc]=a?r.display:``,e[Bc]&&(r.display=`none`))}var Xc=/\s*!important$/;function Zc(e,t,n){if(p(n))n.forEach(n=>Zc(e,t,n));else if(n??=``,t.startsWith(`--`))e.setProperty(t,n);else{let r=el(e,t);Xc.test(n)?e.setProperty(oe(r),n.replace(Xc,``),`important`):e[r]=n}}var Qc=[`Webkit`,`Moz`,`ms`],$c={};function el(e,t){let n=$c[t];if(n)return n;let r=E(t);if(r!==`filter`&&r in e)return $c[t]=r;r=se(r);for(let n=0;n<Qc.length;n++){let i=Qc[n]+r;if(i in e)return $c[t]=i}return t}function tl(e,t,n,r){return e.tagName===`TEXTAREA`&&(t===`width`||t===`height`)&&y(r)&&n===r}var nl=`http://www.w3.org/1999/xlink`;function rl(e,t,n,r,i,a=Ce(t)){r&&t.startsWith(`xlink:`)?n==null?e.removeAttributeNS(nl,t.slice(6,t.length)):e.setAttributeNS(nl,t,n):n==null||a&&!we(n)?e.removeAttribute(t):e.setAttribute(t,a?``:b(n)?String(n):n)}function il(e,t,n,r,i){if(t===`innerHTML`||t===`textContent`){n!=null&&(e[t]=t===`innerHTML`?fc(n):n);return}let a=e.tagName;if(t===`value`&&a!==`PROGRESS`&&!a.includes(`-`)){let r=a===`OPTION`?e.getAttribute(`value`)||``:e.value,i=n==null?e.type===`checkbox`?`on`:``:String(n);(r!==i||!(`_value`in e))&&(e.value=i),n??e.removeAttribute(t),e._value=n;return}let o=!1;if(n===``||n==null){let r=typeof e[t];r===`boolean`?n=we(n):n==null&&r===`string`?(n=``,o=!0):r===`number`&&(n=0,o=!0)}try{e[t]=n}catch{}o&&e.removeAttribute(i||t)}function al(e,t,n,r){e.addEventListener(t,n,r)}function ol(e,t,n,r){e.removeEventListener(t,n,r)}var sl=Symbol(`_vei`);function cl(e,t,n,r,i=null){let a=e[sl]||(e[sl]={}),o=a[t];if(r&&o)o.value=r;else{let[n,s]=dl(t);r?al(e,n,a[t]=hl(r,i),s):o&&(ol(e,n,o,s),a[t]=void 0)}}var ll=/(Once|Passive|Capture)$/,ul=/^on:?(?:Once|Passive|Capture)$/;function dl(e){let t,n;for(;(n=e.match(ll))&&!ul.test(e);)t||={},e=e.slice(0,e.length-n[1].length),t[n[1].toLowerCase()]=!0;return[e[2]===`:`?e.slice(3):oe(e.slice(2)),t]}var fl=0,pl=Promise.resolve(),ml=()=>fl||=(pl.then(()=>fl=0),Date.now());function hl(e,t){let n=e=>{if(!e._vts)e._vts=Date.now();else if(e._vts<=n.attached)return;let r=n.value;if(p(r)){let n=e.stopImmediatePropagation;e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0};let i=r.slice(),a=[e];for(let n=0;n<i.length&&!e._stopped;n++){let e=i[n];e&&Hn(e,t,5,a)}}else Hn(r,t,5,[e])};return n.value=e,n.attached=ml(),n}var gl=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,_l=(e,t,n,r,i,a)=>{let o=i===`svg`;t===`class`?Rc(e,r,o):t===`style`?Yc(e,n,r):s(t)?c(t)||cl(e,t,n,r,a):(t[0]===`.`?(t=t.slice(1),!0):t[0]===`^`?(t=t.slice(1),!1):vl(e,t,r,o))?(il(e,t,r),!e.tagName.includes(`-`)&&(t===`value`||t===`checked`||t===`selected`)&&rl(e,t,r,o,a,t!==`value`)):e._isVueCE&&(yl(e,t)||e._def.__asyncLoader&&(/[A-Z]/.test(t)||!y(r)))?il(e,E(t),r,a,t):(t===`true-value`?e._trueValue=r:t===`false-value`&&(e._falseValue=r),rl(e,t,r,o))};function vl(e,t,n,r){if(r)return!!(t===`innerHTML`||t===`textContent`||t in e&&gl(t)&&v(n));if(t===`spellcheck`||t===`draggable`||t===`translate`||t===`autocorrect`||t===`sandbox`&&e.tagName===`IFRAME`||t===`form`||t===`list`&&e.tagName===`INPUT`||t===`type`&&e.tagName===`TEXTAREA`)return!1;if(t===`width`||t===`height`){let t=e.tagName;if(t===`IMG`||t===`VIDEO`||t===`CANVAS`||t===`SOURCE`)return!1}return gl(t)&&y(n)?!1:t in e}function yl(e,t){let n=e._def.props;if(!n)return!1;let r=E(t);return Array.isArray(n)?n.some(e=>E(e)===r):Object.keys(n).some(e=>E(e)===r)}var bl={};function xl(e,t,n){let r=F(e,t);te(r)&&(r=l({},r,t));class i extends wl{constructor(e){super(r,e,n)}}return i.def=r,i}var Sl=((e,t)=>xl(e,t,hu)),Cl=typeof HTMLElement<`u`?HTMLElement:class{},wl=class e extends Cl{constructor(e,t={},n=mu){super(),this._def=e,this._props=t,this._createApp=n,this._isVueCE=!0,this._instance=null,this._app=null,this._nonce=this._def.nonce,this._connected=!1,this._resolved=!1,this._patching=!1,this._dirty=!1,this._numberProps=null,this._styleChildren=new WeakSet,this._styleAnchors=new WeakMap,this._ob=null,this.shadowRoot&&n!==mu?this._root=this.shadowRoot:e.shadowRoot===!1?this._root=this:(this.attachShadow(l({},e.shadowRootOptions,{mode:`open`})),this._root=this.shadowRoot)}connectedCallback(){if(!this.isConnected)return;!this.shadowRoot&&!this._resolved&&this._parseSlots(),this._connected=!0;let t=this;for(;t&&=t.assignedSlot||t.parentNode||t.host;)if(t instanceof e){this._parent=t;break}this._instance||(this._resolved?this._mount(this._def):t&&t._pendingResolve?this._pendingResolve=t._pendingResolve.then(()=>{if(this._pendingResolve=void 0,this.isConnected)return this._resolveDef()}):this._resolveDef())}_setParent(e=this._parent){e&&(this._instance.parent=e._instance,this._inheritParentContext(e))}_inheritParentContext(e=this._parent){e&&this._app&&Object.setPrototypeOf(this._app._context.provides,e._instance.provides)}disconnectedCallback(){this._connected=!1,Qn(()=>{this._connected||(this._ob&&=(this._ob.disconnect(),null),this._app&&this._app.unmount(),this._instance&&(this._instance.ce=void 0),this._app=this._instance=null,this._teleportTargets&&=(this._teleportTargets.clear(),void 0))})}_processMutations(e){for(let t of e)this._setAttr(t.attributeName)}_resolveDef(){if(this._pendingResolve)return this._pendingResolve;for(let e=0;e<this.attributes.length;e++)this._setAttr(this.attributes[e].name);this._ob=new MutationObserver(this._processMutations.bind(this)),this._ob.observe(this,{attributes:!0});let e=(e,t=!1)=>{this._resolved=!0,this._pendingResolve=void 0;let{props:n,styles:r}=e,i;if(n&&!p(n))for(let e in n){let t=n[e];(t===Number||t&&t.type===Number)&&(e in this._props&&(this._props[e]=fe(this._props[e])),(i||=Object.create(null))[E(e)]=!0)}this._numberProps=i,this._resolveProps(e),this.shadowRoot&&this._applyStyles(r),this._mount(e)},t=this._def.__asyncLoader;if(t)return this._pendingResolve=t().then(t=>{t.configureApp=this._def.configureApp,e(this._def=t,!0)}),this._pendingResolve;e(this._def)}_mount(e){this._app=this._createApp(e),this._inheritParentContext(),e.configureApp&&e.configureApp(this._app),this._app._ceVNode=this._createVNode(),this._app.mount(this._root);let t=this._instance&&this._instance.exposed;if(t)for(let e in t)f(this,e)||Object.defineProperty(this,e,{get:()=>N(t[e])})}_resolveProps(e){let{props:t}=e,n=p(t)?t:Object.keys(t||{});for(let e of Object.keys(this))e[0]!==`_`&&n.includes(e)&&this._setProp(e,this[e]);for(let e of n.map(E))Object.defineProperty(this,e,{get(){return this._getProp(e)},set(t){this._setProp(e,t,!0,!this._patching)}})}_setAttr(e){if(e.startsWith(`data-v-`))return;let t=this.hasAttribute(e),n=t?this.getAttribute(e):bl,r=E(e);t&&this._numberProps&&this._numberProps[r]&&(n=fe(n)),this._setProp(r,n,!1,!0)}_getProp(e){return this._props[e]}_setProp(e,t,n=!0,r=!1){if(t!==this._props[e]&&(this._dirty=!0,t===bl?delete this._props[e]:(this._props[e]=t,e===`key`&&this._app&&(this._app._ceVNode.key=t)),r&&this._instance&&this._update(),n)){let n=this._ob;n&&(this._processMutations(n.takeRecords()),n.disconnect()),t===!0?this.setAttribute(oe(e),``):typeof t==`string`||typeof t==`number`?this.setAttribute(oe(e),t+``):t||this.removeAttribute(oe(e)),n&&n.observe(this,{attributes:!0})}}_update(){let e=this._createVNode();this._app&&(e.appContext=this._app._context),fu(e,this._root)}_createVNode(){let e={};this.shadowRoot||(e.onVnodeMounted=e.onVnodeUpdated=this._renderSlots.bind(this));let t=H(this._def,l(e,this._props));return this._instance||(t.ce=e=>{this._instance=e,e.ce=this,e.isCE=!0;let t=(e,t)=>{this.dispatchEvent(new CustomEvent(e,te(t[0])?l({detail:t},t[0]):{detail:t}))};e.emit=(e,...n)=>{t(e,n),oe(e)!==e&&t(oe(e),n)},this._setParent()}),t}_applyStyles(e,t,n){if(!e)return;if(t){if(t===this._def||this._styleChildren.has(t))return;this._styleChildren.add(t)}let r=this._nonce,i=this.shadowRoot,a=n?this._getStyleAnchor(n)||this._getStyleAnchor(this._def):this._getRootStyleInsertionAnchor(i),o=null;for(let s=e.length-1;s>=0;s--){let c=document.createElement(`style`);r&&c.setAttribute(`nonce`,r),c.textContent=e[s],i.insertBefore(c,o||a),o=c,s===0&&(n||this._styleAnchors.set(this._def,c),t&&this._styleAnchors.set(t,c))}}_getStyleAnchor(e){if(!e)return null;let t=this._styleAnchors.get(e);return t&&t.parentNode===this.shadowRoot?t:(t&&this._styleAnchors.delete(e),null)}_getRootStyleInsertionAnchor(e){for(let t=0;t<e.childNodes.length;t++){let n=e.childNodes[t];if(!(n instanceof HTMLStyleElement))return n}return null}_parseSlots(){let e=this._slots={},t;for(;t=this.firstChild;){let n=t.nodeType===1&&t.getAttribute(`slot`)||`default`;(e[n]||(e[n]=[])).push(t),this.removeChild(t)}}_renderSlots(){let e=this._getSlots(),t=this._instance.type.__scopeId;for(let n=0;n<e.length;n++){let r=e[n],i=r.getAttribute(`name`)||`default`,a=this._slots[i],o=r.parentNode;if(a)for(let e of a){if(t&&e.nodeType===1){let n=t+`-s`,r=document.createTreeWalker(e,1);e.setAttribute(n,``);let i;for(;i=r.nextNode();)i.setAttribute(n,``)}o.insertBefore(e,r)}else for(;r.firstChild;)o.insertBefore(r.firstChild,r);o.removeChild(r)}}_getSlots(){let e=[this];this._teleportTargets&&e.push(...this._teleportTargets);let t=new Set;for(let n of e){let e=n.querySelectorAll(`slot`);for(let n=0;n<e.length;n++)t.add(e[n])}return Array.from(t)}_injectChildStyle(e,t){this._applyStyles(e.styles,e,t)}_beginPatch(){this._patching=!0,this._dirty=!1}_endPatch(){this._patching=!1,this._dirty&&this._instance&&this._update()}_hasShadowRoot(){return this._def.shadowRoot!==!1}_removeChildStyle(e){}};function Tl(e){let t=Fs();return t&&t.ce||null}function El(){let e=Tl();return e&&e.shadowRoot}function Dl(e=`$style`){{let t=Fs();if(!t)return r;let n=t.type.__cssModules;return n&&n[e]||r}}var Ol=new WeakMap,kl=new WeakMap,Al=Symbol(`_moveCb`),jl=Symbol(`_enterCb`),Ml=(e=>(delete e.props.mode,e))({name:`TransitionGroup`,props:l({},Sc,{tag:String,moveClass:String}),setup(e,{slots:t}){let n=Fs(),r=Kr(),i,a;return $i(()=>{if(!i.length)return;let t=e.moveClass||`${e.name||`v`}-move`;if(!Ll(i[0].el,n.vnode.el,t)){i=[];return}i.forEach(Nl),i.forEach(Pl);let r=i.filter(Fl);Lc(n.vnode.el),r.forEach(e=>{let n=e.el,r=n.style;kc(n,t),r.transform=r.webkitTransform=r.transitionDuration=``;let i=n[Al]=e=>{e&&e.target!==n||(!e||e.propertyName.endsWith(`transform`))&&(n.removeEventListener(`transitionend`,i),n[Al]=null,Ac(n,t))};n.addEventListener(`transitionend`,i)}),i=[]}),()=>{let o=A(e),s=Ec(o),c=o.tag||L;if(i=[],a)for(let e=0;e<a.length;e++){let t=a[e];t.el&&t.el instanceof Element&&!t.el[Bc]&&(i.push(t),ri(t,ei(t,s,r,n)),Ol.set(t,Il(t.el)))}a=t.default?ii(t.default()):[];for(let e=0;e<a.length;e++){let t=a[e];t.key!=null&&ri(t,ei(t,s,r,n))}return H(c,null,a)}}});function Nl(e){let t=e.el;t[Al]&&t[Al](),t[jl]&&t[jl]()}function Pl(e){kl.set(e,Il(e.el))}function Fl(e){let t=Ol.get(e),n=kl.get(e),r=t.left-n.left,i=t.top-n.top;if(r||i){let t=e.el,n=t.style,a=t.getBoundingClientRect(),o=1,s=1;return t.offsetWidth&&(o=a.width/t.offsetWidth),t.offsetHeight&&(s=a.height/t.offsetHeight),(!Number.isFinite(o)||o===0)&&(o=1),(!Number.isFinite(s)||s===0)&&(s=1),Math.abs(o-1)<.01&&(o=1),Math.abs(s-1)<.01&&(s=1),n.transform=n.webkitTransform=`translate(${r/o}px,${i/s}px)`,n.transitionDuration=`0s`,e}}function Il(e){let t=e.getBoundingClientRect();return{left:t.left,top:t.top}}function Ll(e,t,n){let r=e.cloneNode(),i=e[bc];i&&i.forEach(e=>{e.split(/\s+/).forEach(e=>e&&r.classList.remove(e))}),n.split(/\s+/).forEach(e=>e&&r.classList.add(e)),r.style.display=`none`;let a=t.nodeType===1?t:t.parentNode;a.appendChild(r);let{hasTransform:o}=Pc(r);return a.removeChild(r),o}var Rl=e=>{let t=e.props[`onUpdate:modelValue`]||!1;return p(t)?e=>le(t,e):t};function zl(e){e.target.composing=!0}function Bl(e){let t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event(`input`)))}var Vl=Symbol(`_assign`),Hl=Symbol(`_initialValue`);function Ul(e,t,n){return t&&(e=e.trim()),n&&(e=de(e)),e}var Wl={created(e,{modifiers:{lazy:t,trim:n,number:r}},i){e.parentNode&&(e.type===`text`?e[Hl]=e.defaultValue.replace(/[\r\n]/g,``):e.type===`textarea`&&(e[Hl]=e.defaultValue.replace(/\r\n?/g,`
`))),e[Vl]=Rl(i);let a=r||i.props&&i.props.type===`number`;al(e,t?`change`:`input`,t=>{t.target.composing||e[Vl](Ul(e.value,n,a))}),(n||a)&&al(e,`change`,()=>{e.value=Ul(e.value,n,a)}),t||(al(e,`compositionstart`,zl),al(e,`compositionend`,Bl),al(e,`change`,Bl))},mounted(e,{value:t,modifiers:{trim:n,number:r}}){let i=t??``,a=e[Hl];delete e[Hl],a!==void 0&&(e.type===`text`||e.type===`textarea`)&&e.value!==a?e[Vl](Ul(e.value,n,r)):e.value=i},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:r,trim:i,number:a}},o){if(e[Vl]=Rl(o),e.composing)return;let s=(a||e.type===`number`)&&!/^0\d/.test(e.value)?de(e.value):e.value,c=t??``;if(s===c)return;let l=e.getRootNode();(l instanceof Document||l instanceof ShadowRoot)&&l.activeElement===e&&e.type!==`range`&&(r&&t===n||i&&e.value.trim()===c)||(e.value=c)}},Gl={deep:!0,created(e,t,n){e[Vl]=Rl(n),al(e,`change`,()=>{let t=e._modelValue,n=Xl(e),r=e.checked,i=e[Vl];if(p(t)){let e=De(t,n),a=e!==-1;if(r&&!a)i(t.concat(n));else if(!r&&a){let n=[...t];n.splice(e,1),i(n)}}else if(h(t)){let e=new Set(t);r?e.add(n):e.delete(n),i(e)}else i(Zl(e,r))})},mounted:Kl,beforeUpdate(e,t,n){e[Vl]=Rl(n),Kl(e,t,n)}};function Kl(e,{value:t,oldValue:n},r){e._modelValue=t;let i;if(p(t))i=De(t,r.props.value)>-1;else if(h(t))i=t.has(r.props.value);else{if(t===n)return;i=Ee(t,Zl(e,!0))}e.checked!==i&&(e.checked=i)}var ql={created(e,{value:t},n){e.checked=Ee(t,n.props.value),e[Vl]=Rl(n),al(e,`change`,()=>{e[Vl](Xl(e))})},beforeUpdate(e,{value:t,oldValue:n},r){e[Vl]=Rl(r),t!==n&&(e.checked=Ee(t,r.props.value))}},Jl={deep:!0,created(e,{value:t,modifiers:{number:n}},r){e._modelValue=t,al(e,`change`,()=>{let t=Array.prototype.filter.call(e.options,e=>e.selected).map(e=>n?de(Xl(e)):Xl(e));e[Vl](e.multiple?h(e._modelValue)?new Set(t):t:t[0]),e._assigning=!0,Qn(()=>{e._assigning=!1})}),e[Vl]=Rl(r)},mounted(e,{value:t}){Yl(e,t)},beforeUpdate(e,{value:t},n){e._modelValue=t,e[Vl]=Rl(n)},updated(e,{value:t}){e._assigning||Yl(e,t)}};function Yl(e,t){let n=e.multiple,r=p(t);if(!(n&&!r&&!h(t))){for(let i=0,a=e.options.length;i<a;i++){let a=e.options[i],o=Xl(a);if(n){if(r){let e=typeof o;a.selected=e===`string`||e===`number`?t.some(e=>String(e)===String(o)):De(t,o)>-1}else a.selected=t.has(o)}else if(Ee(Xl(a),t)){e.selectedIndex!==i&&(e.selectedIndex=i);return}}!n&&e.selectedIndex!==-1&&(e.selectedIndex=-1)}}function Xl(e){return`_value`in e?e._value:e.value}function Zl(e,t){let n=t?`_trueValue`:`_falseValue`;return n in e?e[n]:t}var Ql={created(e,t,n){eu(e,t,n,null,`created`)},mounted(e,t,n){eu(e,t,n,null,`mounted`)},beforeUpdate(e,t,n,r){eu(e,t,n,r,`beforeUpdate`)},updated(e,t,n,r){eu(e,t,n,r,`updated`)}};function $l(e,t){switch(e){case`SELECT`:return Jl;case`TEXTAREA`:return Wl;default:switch(t){case`checkbox`:return Gl;case`radio`:return ql;default:return Wl}}}function eu(e,t,n,r,i){let a=$l(e.tagName,n.props&&n.props.type)[i];a&&a(e,t,n,r)}function tu(){Wl.getSSRProps=({value:e})=>({value:e}),ql.getSSRProps=({value:e},t)=>{if(t.props&&Ee(t.props.value,e))return{checked:!0}},Gl.getSSRProps=({value:e},t)=>{if(p(e)){if(t.props&&De(e,t.props.value)>-1)return{checked:!0}}else if(h(e)){if(t.props&&e.has(t.props.value))return{checked:!0}}else if(e)return{checked:!0}},Ql.getSSRProps=(e,t)=>{if(typeof t.type!=`string`)return;let n=$l(t.type.toUpperCase(),t.props&&t.props.type);if(n.getSSRProps)return n.getSSRProps(e,t)}}var nu=[`ctrl`,`shift`,`alt`,`meta`],ru={stop:e=>e.stopPropagation(),prevent:e=>e.preventDefault(),self:e=>e.target!==e.currentTarget,ctrl:e=>!e.ctrlKey,shift:e=>!e.shiftKey,alt:e=>!e.altKey,meta:e=>!e.metaKey,left:e=>`button`in e&&e.button!==0,middle:e=>`button`in e&&e.button!==1,right:e=>`button`in e&&e.button!==2,exact:(e,t)=>nu.some(n=>e[`${n}Key`]&&!t.includes(n))},iu=(e,t)=>{if(!e)return e;let n=e._withMods||={},r=t.join(`.`);return n[r]||(n[r]=((n,...r)=>{for(let e=0;e<t.length;e++){let r=ru[t[e]];if(r&&r(n,t))return}return e(n,...r)}))},au={esc:`escape`,space:` `,up:`arrow-up`,left:`arrow-left`,right:`arrow-right`,down:`arrow-down`,delete:`backspace`},ou=(e,t)=>{let n=e._withKeys||={},r=t.join(`.`);return n[r]||(n[r]=(n=>{if(!(`key`in n))return;let r=oe(n.key);if(t.some(e=>e===r||au[e]===r))return e(n)}))},su=l({patchProp:_l},_c),cu,lu=!1;function uu(){return cu||=Lo(su)}function du(){return cu=lu?cu:Ro(su),lu=!0,cu}var fu=((...e)=>{uu().render(...e)}),pu=((...e)=>{du().hydrate(...e)}),mu=((...e)=>{let t=uu().createApp(...e),{mount:n}=t;return t.mount=e=>{let r=_u(e);if(!r)return;let i=t._component;!v(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent=``);let a=n(r,!1,gu(r));return r instanceof Element&&(r.removeAttribute(`v-cloak`),r.setAttribute(`data-v-app`,``)),a},t}),hu=((...e)=>{let t=du().createApp(...e),{mount:n}=t;return t.mount=e=>{let t=_u(e);if(t)return n(t,!0,gu(t))},t});function gu(e){if(e instanceof SVGElement)return`svg`;if(typeof MathMLElement==`function`&&e instanceof MathMLElement)return`mathml`}function _u(e){return y(e)?document.querySelector(e):e}var vu=!1,yu=()=>{vu||(vu=!0,tu(),Uc())},bu=t({BaseTransition:()=>Qr,BaseTransitionPropsValidators:()=>Jr,Comment:()=>cs,DeprecationTypes:()=>null,EffectScope:()=>Ne,ErrorCodes:()=>zn,ErrorTypeStrings:()=>oc,Fragment:()=>L,KeepAlive:()=>Bi,ReactiveEffect:()=>ze,Static:()=>ls,Suspense:()=>Xo,Teleport:()=>Vr,Text:()=>ss,TrackOpTypes:()=>En,Transition:()=>Cc,TransitionGroup:()=>Ml,TriggerOpTypes:()=>Dn,VueElement:()=>wl,assertNumber:()=>Rn,callWithAsyncErrorHandling:()=>Hn,callWithErrorHandling:()=>Vn,camelize:()=>E,capitalize:()=>se,cloneVNode:()=>Cs,compatUtils:()=>null,compile:()=>xu,computed:()=>W,createApp:()=>mu,createBlock:()=>B,createCommentVNode:()=>Ts,createElementBlock:()=>z,createElementVNode:()=>V,createHydrationRenderer:()=>Ro,createPropsRestProxy:()=>Ia,createRenderer:()=>Lo,createSSRApp:()=>hu,createSlots:()=>ha,createStaticVNode:()=>ws,createTextVNode:()=>U,createVNode:()=>H,customRef:()=>vn,defineAsyncComponent:()=>Li,defineComponent:()=>F,defineCustomElement:()=>xl,defineEmits:()=>wa,defineExpose:()=>Ta,defineModel:()=>Oa,defineOptions:()=>Ea,defineProps:()=>Ca,defineSSRCustomElement:()=>Sl,defineSlots:()=>Da,devtools:()=>sc,effect:()=>Qe,effectScope:()=>Pe,getCurrentInstance:()=>Fs,getCurrentScope:()=>Fe,getCurrentWatcher:()=>jn,getTransitionRawChildren:()=>ii,guardReactiveProps:()=>Ss,h:()=>G,handleError:()=>Un,hasInjectionContext:()=>br,hydrate:()=>pu,hydrateOnIdle:()=>Ai,hydrateOnInteraction:()=>Pi,hydrateOnMediaQuery:()=>Ni,hydrateOnVisible:()=>Mi,initCustomFormatter:()=>tc,initDirectivesForSSR:()=>yu,inject:()=>yr,isMemoSame:()=>rc,isProxy:()=>on,isReactive:()=>nn,isReadonly:()=>rn,isRef:()=>j,isRuntimeOnly:()=>Js,isShallow:()=>an,isVNode:()=>gs,markRaw:()=>sn,mergeDefaults:()=>Pa,mergeModels:()=>Fa,mergeProps:()=>ks,nextTick:()=>Qn,nodeOps:()=>_c,normalizeClass:()=>O,normalizeProps:()=>xe,normalizeStyle:()=>ge,onActivated:()=>Hi,onBeforeMount:()=>Xi,onBeforeUnmount:()=>ea,onBeforeUpdate:()=>Qi,onDeactivated:()=>Ui,onErrorCaptured:()=>aa,onMounted:()=>Zi,onRenderTracked:()=>ia,onRenderTriggered:()=>ra,onScopeDispose:()=>Ie,onServerPrefetch:()=>na,onUnmounted:()=>ta,onUpdated:()=>$i,onWatcherCleanup:()=>Mn,openBlock:()=>R,patchProp:()=>_l,popScopeId:()=>mr,provide:()=>vr,proxyRefs:()=>gn,pushScopeId:()=>pr,queuePostFlushCb:()=>nr,reactive:()=>Zt,readonly:()=>$t,ref:()=>M,registerRuntimeCompiler:()=>qs,render:()=>fu,renderList:()=>ma,renderSlot:()=>I,resolveComponent:()=>ca,resolveDirective:()=>da,resolveDynamicComponent:()=>ua,resolveFilter:()=>null,resolveTransitionHooks:()=>ei,setBlockTracking:()=>ms,setDevtoolsHook:()=>cc,setTransitionHooks:()=>ri,shallowReactive:()=>Qt,shallowReadonly:()=>en,shallowRef:()=>un,ssrContextKey:()=>xr,ssrUtils:()=>lc,stop:()=>$e,toDisplayString:()=>k,toHandlerKey:()=>ce,toHandlers:()=>_a,toRaw:()=>A,toRef:()=>Sn,toRefs:()=>yn,toValue:()=>mn,transformVNodeArgs:()=>vs,triggerRef:()=>pn,unref:()=>N,useAttrs:()=>ja,useCssModule:()=>Dl,useCssVars:()=>Gc,useHost:()=>Tl,useId:()=>ai,useModel:()=>ro,useSSRContext:()=>Sr,useShadowRoot:()=>El,useSlots:()=>Aa,useTemplateRef:()=>si,useTransitionState:()=>Kr,vModelCheckbox:()=>Gl,vModelDynamic:()=>Ql,vModelRadio:()=>ql,vModelSelect:()=>Jl,vModelText:()=>Wl,vShow:()=>Vc,version:()=>ic,warn:()=>ac,watch:()=>Er,watchEffect:()=>Cr,watchPostEffect:()=>wr,watchSyncEffect:()=>Tr,withAsyncContext:()=>La,withCtx:()=>P,withDefaults:()=>ka,withDirectives:()=>gr,withKeys:()=>ou,withMemo:()=>nc,withModifiers:()=>iu,withScopeId:()=>hr}),xu=()=>{};function Su(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function Cu(e){if(Array.isArray(e))return e}function wu(e){if(Array.isArray(e))return Su(e)}function Tu(e,t){if(!(e instanceof t))throw TypeError(`Cannot call a class as a function`)}function Eu(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,`value`in r&&(r.writable=!0),Object.defineProperty(e,Lu(r.key),r)}}function Du(e,t,n){return t&&Eu(e.prototype,t),n&&Eu(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function Ou(e,t){var n=typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(!n){if(Array.isArray(e)||(n=zu(e))||t&&e&&typeof e.length==`number`){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw TypeError(`Invalid attempt to iterate non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||n.return==null||n.return()}finally{if(s)throw a}}}}function K(e,t,n){return(t=Lu(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function ku(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function Au(e,t){var n=e==null?null:typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(n!=null){var r,i,a,o,s=[],c=!0,l=!1;try{if(a=(n=n.call(e)).next,t===0){if(Object(n)!==n)return;c=!1}else for(;!(c=(r=a.call(n)).done)&&(s.push(r.value),s.length!==t);c=!0);}catch(e){l=!0,i=e}finally{try{if(!c&&n.return!=null&&(o=n.return(),Object(o)!==o))return}finally{if(l)throw i}}return s}}function ju(){throw TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Mu(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Nu(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function q(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Nu(Object(n),!0).forEach(function(t){K(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Nu(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function Pu(e,t){return Cu(e)||Au(e,t)||zu(e,t)||ju()}function Fu(e){return wu(e)||ku(e)||zu(e)||Mu()}function Iu(e,t){if(typeof e!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(typeof r!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function Lu(e){var t=Iu(e,`string`);return typeof t==`symbol`?t:t+``}function Ru(e){"@babel/helpers - typeof";return Ru=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},Ru(e)}function zu(e,t){if(e){if(typeof e==`string`)return Su(e,t);var n={}.toString.call(e).slice(8,-1);return n===`Object`&&e.constructor&&(n=e.constructor.name),n===`Map`||n===`Set`?Array.from(e):n===`Arguments`||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?Su(e,t):void 0}}var Bu=function(){},Vu={},Hu={},Uu=null,Wu={mark:Bu,measure:Bu};try{typeof window<`u`&&(Vu=window),typeof document<`u`&&(Hu=document),typeof MutationObserver<`u`&&(Uu=MutationObserver),typeof performance<`u`&&(Wu=performance)}catch{}var Gu=(Vu.navigator||{}).userAgent,Ku=Gu===void 0?``:Gu,qu=Vu,Ju=Hu,Yu=Uu,Xu=Wu;qu.document;var Zu=!!Ju.documentElement&&!!Ju.head&&typeof Ju.addEventListener==`function`&&typeof Ju.createElement==`function`,Qu=~Ku.indexOf(`MSIE`)||~Ku.indexOf(`Trident/`),$u,ed=/fa(k|kd|s|r|l|t|d|dr|dl|dt|b|slr|slpr|wsb|tl|ns|nds|es|gt|jr|jfr|jdr|usb|ufsb|udsb|cr|ss|sr|sl|st|sds|sdr|sdl|sdt|sldr|slpdr|pr|ms|vs)?[\-\ ]/,td=/Font ?Awesome ?([567 ]*)(Solid|Regular|Light|Thin|Duotone|Brands|Free|Pro|Sharp Duotone|Sharp|Kit|Notdog Duo|Notdog|Chisel|Etch|Graphite|Thumbprint|Jelly Fill|Jelly Duo|Jelly|Utility|Utility Fill|Utility Duo|Slab Press|Slab|Slab Duo|Slab Press Duo|Pixel|Mosaic|Vellum|Whiteboard)?.*/i,nd={classic:{fa:`solid`,fas:`solid`,"fa-solid":`solid`,far:`regular`,"fa-regular":`regular`,fal:`light`,"fa-light":`light`,fat:`thin`,"fa-thin":`thin`,fab:`brands`,"fa-brands":`brands`},duotone:{fa:`solid`,fad:`solid`,"fa-solid":`solid`,"fa-duotone":`solid`,fadr:`regular`,"fa-regular":`regular`,fadl:`light`,"fa-light":`light`,fadt:`thin`,"fa-thin":`thin`},sharp:{fa:`solid`,fass:`solid`,"fa-solid":`solid`,fasr:`regular`,"fa-regular":`regular`,fasl:`light`,"fa-light":`light`,fast:`thin`,"fa-thin":`thin`},"sharp-duotone":{fa:`solid`,fasds:`solid`,"fa-solid":`solid`,fasdr:`regular`,"fa-regular":`regular`,fasdl:`light`,"fa-light":`light`,fasdt:`thin`,"fa-thin":`thin`},slab:{"fa-regular":`regular`,faslr:`regular`},"slab-press":{"fa-regular":`regular`,faslpr:`regular`},"slab-duo":{"fa-regular":`regular`,fasldr:`regular`},"slab-press-duo":{"fa-regular":`regular`,faslpdr:`regular`},thumbprint:{"fa-light":`light`,fatl:`light`},vellum:{"fa-solid":`solid`,favs:`solid`},pixel:{"fa-regular":`regular`,fapr:`regular`},mosaic:{"fa-solid":`solid`,fams:`solid`},whiteboard:{"fa-semibold":`semibold`,fawsb:`semibold`},notdog:{"fa-solid":`solid`,fans:`solid`},"notdog-duo":{"fa-solid":`solid`,fands:`solid`},etch:{"fa-solid":`solid`,faes:`solid`},graphite:{"fa-thin":`thin`,fagt:`thin`},jelly:{"fa-regular":`regular`,fajr:`regular`},"jelly-fill":{"fa-regular":`regular`,fajfr:`regular`},"jelly-duo":{"fa-regular":`regular`,fajdr:`regular`},chisel:{"fa-regular":`regular`,facr:`regular`},utility:{"fa-semibold":`semibold`,fausb:`semibold`},"utility-duo":{"fa-semibold":`semibold`,faudsb:`semibold`},"utility-fill":{"fa-semibold":`semibold`,faufsb:`semibold`}},rd={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},id=[`fa-classic`,`fa-duotone`,`fa-sharp`,`fa-sharp-duotone`,`fa-thumbprint`,`fa-whiteboard`,`fa-notdog`,`fa-notdog-duo`,`fa-chisel`,`fa-etch`,`fa-graphite`,`fa-jelly`,`fa-jelly-fill`,`fa-jelly-duo`,`fa-slab`,`fa-slab-press`,`fa-slab-press-duo`,`fa-slab-duo`,`fa-mosaic`,`fa-pixel`,`fa-vellum`,`fa-utility`,`fa-utility-duo`,`fa-utility-fill`],ad=`classic`,od=`duotone`,sd=`sharp`,cd=`sharp-duotone`,ld=`chisel`,ud=`etch`,dd=`graphite`,fd=`jelly`,pd=`jelly-duo`,md=`jelly-fill`,hd=`mosaic`,gd=`notdog`,_d=`notdog-duo`,vd=`pixel`,yd=`slab`,bd=`slab-duo`,xd=`slab-press`,Sd=`slab-press-duo`,Cd=`thumbprint`,wd=`utility`,Td=`utility-duo`,Ed=`utility-fill`,Dd=`vellum`,Od=`whiteboard`,kd=`Classic`,Ad=`Duotone`,jd=`Sharp`,Md=`Sharp Duotone`,Nd=`Chisel`,Pd=`Etch`,Fd=`Graphite`,Id=`Jelly`,Ld=`Jelly Duo`,Rd=`Jelly Fill`,zd=`Mosaic`,Bd=`Notdog`,Vd=`Notdog Duo`,Hd=`Pixel`,Ud=`Slab`,Wd=`Slab Duo`,Gd=`Slab Press`,Kd=`Slab Press Duo`,qd=`Thumbprint`,Jd=`Utility`,Yd=`Utility Duo`,Xd=`Utility Fill`,Zd=`Vellum`,Qd=`Whiteboard`,$d=[ad,od,sd,cd,ld,ud,dd,fd,pd,md,hd,gd,_d,vd,yd,bd,xd,Sd,Cd,wd,Td,Ed,Dd,Od];$u={},K(K(K(K(K(K(K(K(K(K($u,ad,kd),od,Ad),sd,jd),cd,Md),ld,Nd),ud,Pd),dd,Fd),fd,Id),pd,Ld),md,Rd),K(K(K(K(K(K(K(K(K(K($u,hd,zd),gd,Bd),_d,Vd),vd,Hd),yd,Ud),bd,Wd),xd,Gd),Sd,Kd),Cd,qd),wd,Jd),K(K(K(K($u,Td,Yd),Ed,Xd),Dd,Zd),Od,Qd);var ef={classic:{900:`fas`,400:`far`,normal:`far`,300:`fal`,100:`fat`},duotone:{900:`fad`,400:`fadr`,300:`fadl`,100:`fadt`},sharp:{900:`fass`,400:`fasr`,300:`fasl`,100:`fast`},"sharp-duotone":{900:`fasds`,400:`fasdr`,300:`fasdl`,100:`fasdt`},slab:{400:`faslr`},"slab-press":{400:`faslpr`},"slab-duo":{400:`fasldr`},"slab-press-duo":{400:`faslpdr`},vellum:{900:`favs`},mosaic:{900:`fams`},pixel:{400:`fapr`},whiteboard:{600:`fawsb`},thumbprint:{300:`fatl`},notdog:{900:`fans`},"notdog-duo":{900:`fands`},etch:{900:`faes`},graphite:{100:`fagt`},chisel:{400:`facr`},jelly:{400:`fajr`},"jelly-fill":{400:`fajfr`},"jelly-duo":{400:`fajdr`},utility:{600:`fausb`},"utility-duo":{600:`faudsb`},"utility-fill":{600:`faufsb`}},tf={"Font Awesome 7 Free":{900:`fas`,400:`far`},"Font Awesome 7 Pro":{900:`fas`,400:`far`,normal:`far`,300:`fal`,100:`fat`},"Font Awesome 7 Brands":{400:`fab`,normal:`fab`},"Font Awesome 7 Duotone":{900:`fad`,400:`fadr`,normal:`fadr`,300:`fadl`,100:`fadt`},"Font Awesome 7 Sharp":{900:`fass`,400:`fasr`,normal:`fasr`,300:`fasl`,100:`fast`},"Font Awesome 7 Sharp Duotone":{900:`fasds`,400:`fasdr`,normal:`fasdr`,300:`fasdl`,100:`fasdt`},"Font Awesome 7 Jelly":{400:`fajr`,normal:`fajr`},"Font Awesome 7 Jelly Fill":{400:`fajfr`,normal:`fajfr`},"Font Awesome 7 Jelly Duo":{400:`fajdr`,normal:`fajdr`},"Font Awesome 7 Slab":{400:`faslr`,normal:`faslr`},"Font Awesome 7 Slab Press":{400:`faslpr`,normal:`faslpr`},"Font Awesome 7 Slab Duo":{400:`fasldr`,normal:`fasldr`},"Font Awesome 7 Slab Press Duo":{400:`faslpdr`,normal:`faslpdr`},"Font Awesome 7 Pixel":{400:`fapr`,normal:`fapr`},"Font Awesome 7 Mosaic":{900:`fams`,normal:`fams`},"Font Awesome 7 Vellum":{900:`favs`,normal:`favs`},"Font Awesome 7 Thumbprint":{300:`fatl`,normal:`fatl`},"Font Awesome 7 Notdog":{900:`fans`,normal:`fans`},"Font Awesome 7 Notdog Duo":{900:`fands`,normal:`fands`},"Font Awesome 7 Etch":{900:`faes`,normal:`faes`},"Font Awesome 7 Graphite":{100:`fagt`,normal:`fagt`},"Font Awesome 7 Chisel":{400:`facr`,normal:`facr`},"Font Awesome 7 Whiteboard":{600:`fawsb`,normal:`fawsb`},"Font Awesome 7 Utility":{600:`fausb`,normal:`fausb`},"Font Awesome 7 Utility Duo":{600:`faudsb`,normal:`faudsb`},"Font Awesome 7 Utility Fill":{600:`faufsb`,normal:`faufsb`}},nf=new Map([[`classic`,{defaultShortPrefixId:`fas`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`,`brands`],futureStyleIds:[],defaultFontWeight:900}],[`duotone`,{defaultShortPrefixId:`fad`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`sharp`,{defaultShortPrefixId:`fass`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`sharp-duotone`,{defaultShortPrefixId:`fasds`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`chisel`,{defaultShortPrefixId:`facr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`etch`,{defaultShortPrefixId:`faes`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`graphite`,{defaultShortPrefixId:`fagt`,defaultStyleId:`thin`,styleIds:[`thin`],futureStyleIds:[],defaultFontWeight:100}],[`jelly`,{defaultShortPrefixId:`fajr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`jelly-duo`,{defaultShortPrefixId:`fajdr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`jelly-fill`,{defaultShortPrefixId:`fajfr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`mosaic`,{defaultShortPrefixId:`fams`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`notdog`,{defaultShortPrefixId:`fans`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`notdog-duo`,{defaultShortPrefixId:`fands`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`pixel`,{defaultShortPrefixId:`fapr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab`,{defaultShortPrefixId:`faslr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-duo`,{defaultShortPrefixId:`fasldr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-press`,{defaultShortPrefixId:`faslpr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-press-duo`,{defaultShortPrefixId:`faslpdr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`thumbprint`,{defaultShortPrefixId:`fatl`,defaultStyleId:`light`,styleIds:[`light`],futureStyleIds:[],defaultFontWeight:300}],[`utility`,{defaultShortPrefixId:`fausb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`utility-duo`,{defaultShortPrefixId:`faudsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`utility-fill`,{defaultShortPrefixId:`faufsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`vellum`,{defaultShortPrefixId:`favs`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`whiteboard`,{defaultShortPrefixId:`fawsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}]]),rf={chisel:{regular:`facr`},classic:{brands:`fab`,light:`fal`,regular:`far`,solid:`fas`,thin:`fat`},duotone:{light:`fadl`,regular:`fadr`,solid:`fad`,thin:`fadt`},etch:{solid:`faes`},graphite:{thin:`fagt`},jelly:{regular:`fajr`},"jelly-duo":{regular:`fajdr`},"jelly-fill":{regular:`fajfr`},mosaic:{solid:`fams`},notdog:{solid:`fans`},"notdog-duo":{solid:`fands`},pixel:{regular:`fapr`},sharp:{light:`fasl`,regular:`fasr`,solid:`fass`,thin:`fast`},"sharp-duotone":{light:`fasdl`,regular:`fasdr`,solid:`fasds`,thin:`fasdt`},slab:{regular:`faslr`},"slab-duo":{regular:`fasldr`},"slab-press":{regular:`faslpr`},"slab-press-duo":{regular:`faslpdr`},thumbprint:{light:`fatl`},utility:{semibold:`fausb`},"utility-duo":{semibold:`faudsb`},"utility-fill":{semibold:`faufsb`},vellum:{solid:`favs`},whiteboard:{semibold:`fawsb`}},af=[`fak`,`fa-kit`,`fakd`,`fa-kit-duotone`],of={kit:{fak:`kit`,"fa-kit":`kit`},"kit-duotone":{fakd:`kit-duotone`,"fa-kit-duotone":`kit-duotone`}},sf=[`kit`];K(K({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var cf={kit:{"fa-kit":`fak`},"kit-duotone":{"fa-kit-duotone":`fakd`}},lf={"Font Awesome Kit":{400:`fak`,normal:`fak`},"Font Awesome Kit Duotone":{400:`fakd`,normal:`fakd`}},uf={kit:{fak:`fa-kit`},"kit-duotone":{fakd:`fa-kit-duotone`}},df={kit:{kit:`fak`},"kit-duotone":{"kit-duotone":`fakd`}},ff,pf={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},mf=[`fa-classic`,`fa-duotone`,`fa-sharp`,`fa-sharp-duotone`,`fa-thumbprint`,`fa-whiteboard`,`fa-notdog`,`fa-notdog-duo`,`fa-chisel`,`fa-etch`,`fa-graphite`,`fa-jelly`,`fa-jelly-fill`,`fa-jelly-duo`,`fa-slab`,`fa-slab-press`,`fa-slab-press-duo`,`fa-slab-duo`,`fa-mosaic`,`fa-pixel`,`fa-vellum`,`fa-utility`,`fa-utility-duo`,`fa-utility-fill`];ff={},K(K(K(K(K(K(K(K(K(K(ff,`classic`,`Classic`),`duotone`,`Duotone`),`sharp`,`Sharp`),`sharp-duotone`,`Sharp Duotone`),`chisel`,`Chisel`),`etch`,`Etch`),`graphite`,`Graphite`),`jelly`,`Jelly`),`jelly-duo`,`Jelly Duo`),`jelly-fill`,`Jelly Fill`),K(K(K(K(K(K(K(K(K(K(ff,`mosaic`,`Mosaic`),`notdog`,`Notdog`),`notdog-duo`,`Notdog Duo`),`pixel`,`Pixel`),`slab`,`Slab`),`slab-duo`,`Slab Duo`),`slab-press`,`Slab Press`),`slab-press-duo`,`Slab Press Duo`),`thumbprint`,`Thumbprint`),`utility`,`Utility`),K(K(K(K(ff,`utility-duo`,`Utility Duo`),`utility-fill`,`Utility Fill`),`vellum`,`Vellum`),`whiteboard`,`Whiteboard`),K(K({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var hf={classic:{"fa-brands":`fab`,"fa-duotone":`fad`,"fa-light":`fal`,"fa-regular":`far`,"fa-solid":`fas`,"fa-thin":`fat`},duotone:{"fa-regular":`fadr`,"fa-light":`fadl`,"fa-thin":`fadt`},sharp:{"fa-solid":`fass`,"fa-regular":`fasr`,"fa-light":`fasl`,"fa-thin":`fast`},"sharp-duotone":{"fa-solid":`fasds`,"fa-regular":`fasdr`,"fa-light":`fasdl`,"fa-thin":`fasdt`},slab:{"fa-regular":`faslr`},"slab-press":{"fa-regular":`faslpr`},"slab-duo":{"fa-regular":`fasldr`},"slab-press-duo":{"fa-regular":`faslpdr`},pixel:{"fa-regular":`fapr`},mosaic:{"fa-solid":`fams`},vellum:{"fa-solid":`favs`},whiteboard:{"fa-semibold":`fawsb`},thumbprint:{"fa-light":`fatl`},notdog:{"fa-solid":`fans`},"notdog-duo":{"fa-solid":`fands`},etch:{"fa-solid":`faes`},graphite:{"fa-thin":`fagt`},jelly:{"fa-regular":`fajr`},"jelly-fill":{"fa-regular":`fajfr`},"jelly-duo":{"fa-regular":`fajdr`},chisel:{"fa-regular":`facr`},utility:{"fa-semibold":`fausb`},"utility-duo":{"fa-semibold":`faudsb`},"utility-fill":{"fa-semibold":`faufsb`}},gf={classic:[`fas`,`far`,`fal`,`fat`,`fad`],duotone:[`fadr`,`fadl`,`fadt`],sharp:[`fass`,`fasr`,`fasl`,`fast`],"sharp-duotone":[`fasds`,`fasdr`,`fasdl`,`fasdt`],slab:[`faslr`],"slab-press":[`faslpr`],"slab-duo":[`fasldr`],"slab-press-duo":[`faslpdr`],pixel:[`fapr`],mosaic:[`fams`],vellum:[`favs`],whiteboard:[`fawsb`],thumbprint:[`fatl`],notdog:[`fans`],"notdog-duo":[`fands`],etch:[`faes`],graphite:[`fagt`],jelly:[`fajr`],"jelly-fill":[`fajfr`],"jelly-duo":[`fajdr`],chisel:[`facr`],utility:[`fausb`],"utility-duo":[`faudsb`],"utility-fill":[`faufsb`]},_f={classic:{fab:`fa-brands`,fad:`fa-duotone`,fal:`fa-light`,far:`fa-regular`,fas:`fa-solid`,fat:`fa-thin`},duotone:{fadr:`fa-regular`,fadl:`fa-light`,fadt:`fa-thin`},sharp:{fass:`fa-solid`,fasr:`fa-regular`,fasl:`fa-light`,fast:`fa-thin`},"sharp-duotone":{fasds:`fa-solid`,fasdr:`fa-regular`,fasdl:`fa-light`,fasdt:`fa-thin`},slab:{faslr:`fa-regular`},"slab-press":{faslpr:`fa-regular`},"slab-duo":{fasldr:`fa-regular`},"slab-press-duo":{faslpdr:`fa-regular`},pixel:{fapr:`fa-regular`},mosaic:{fams:`fa-solid`},vellum:{favs:`fa-solid`},whiteboard:{fawsb:`fa-semibold`},thumbprint:{fatl:`fa-light`},notdog:{fans:`fa-solid`},"notdog-duo":{fands:`fa-solid`},etch:{faes:`fa-solid`},graphite:{fagt:`fa-thin`},jelly:{fajr:`fa-regular`},"jelly-fill":{fajfr:`fa-regular`},"jelly-duo":{fajdr:`fa-regular`},chisel:{facr:`fa-regular`},utility:{fausb:`fa-semibold`},"utility-duo":{faudsb:`fa-semibold`},"utility-fill":{faufsb:`fa-semibold`}},vf=`fa.fas.far.fal.fat.fad.fadr.fadl.fadt.fab.fass.fasr.fasl.fast.fasds.fasdr.fasdl.fasdt.faslr.faslpr.fasldr.faslpdr.fapr.fams.favs.fawsb.fatl.fans.fands.faes.fagt.fajr.fajfr.fajdr.facr.fausb.faudsb.faufsb`.split(`.`).concat(mf,[`fa-solid`,`fa-regular`,`fa-light`,`fa-thin`,`fa-duotone`,`fa-brands`,`fa-semibold`]),yf=[`solid`,`regular`,`light`,`thin`,`duotone`,`brands`,`semibold`],bf=[1,2,3,4,5,6,7,8,9,10],xf=bf.concat([11,12,13,14,15,16,17,18,19,20]),Sf=[].concat(Fu(Object.keys(gf)),yf,[`aw`,`fw`,`pull-left`,`pull-right`],[`2xs`,`xs`,`sm`,`lg`,`xl`,`2xl`,`beat`,`beat-fade`,`border`,`bounce`,`buzz`,`canvas-square`,`canvas-roomy`,`fade`,`flip-360`,`flip-both`,`flip-horizontal`,`flip-vertical`,`flip`,`float`,`inverse`,`jello`,`layers`,`layers-bottom-left`,`layers-bottom-right`,`layers-counter`,`layers-text`,`layers-top-left`,`layers-top-right`,`li`,`pull-end`,`pull-start`,`pulse`,`rotate-180`,`rotate-270`,`rotate-90`,`rotate-by`,`shake`,`spin-pulse`,`spin-reverse`,`spin`,`spin-snap`,`spin-snap-4`,`spin-snap-8`,`stack-1x`,`stack-2x`,`stack`,`swing`,`ul`,`wag`,`width-auto`,`width-fixed`,pf.GROUP,pf.SWAP_OPACITY,pf.PRIMARY,pf.SECONDARY],bf.map(function(e){return`${e}x`}),xf.map(function(e){return`w-${e}`})),Cf={"Font Awesome 5 Free":{900:`fas`,400:`far`},"Font Awesome 5 Pro":{900:`fas`,400:`far`,normal:`far`,300:`fal`},"Font Awesome 5 Brands":{400:`fab`,normal:`fab`},"Font Awesome 5 Duotone":{900:`fad`}},wf=`___FONT_AWESOME___`,Tf=16,Ef=`fa`,Df=`svg-inline--fa`,Of=`data-fa-i2svg`,kf=`data-fa-pseudo-element`,Af=`data-fa-pseudo-element-pending`,jf=`data-prefix`,Mf=`data-icon`,Nf=`fontawesome-i2svg`,Pf=`async`,Ff=[`HTML`,`HEAD`,`STYLE`,`SCRIPT`],If=[`::before`,`::after`,`:before`,`:after`],Lf=function(){try{return!0}catch{return!1}}();function Rf(e){return new Proxy(e,{get:function(e,t){return t in e?e[t]:e[ad]}})}var zf=q({},nd);zf[ad]=q(q(q(q({},{"fa-duotone":`duotone`}),nd[ad]),of.kit),of[`kit-duotone`]);var Bf=Rf(zf),Vf=q({},rf);Vf[ad]=q(q(q(q({},{duotone:`fad`}),Vf[ad]),df.kit),df[`kit-duotone`]);var Hf=Rf(Vf),Uf=q({},_f);Uf[ad]=q(q({},Uf[ad]),uf.kit);var Wf=Rf(Uf),Gf=q({},hf);Gf[ad]=q(q({},Gf[ad]),cf.kit),Rf(Gf);var Kf=ed,qf=`fa-layers-text`,Jf=td;Rf(q({},ef));var Yf=[`class`,`data-prefix`,`data-icon`,`data-fa-transform`,`data-fa-mask`],Xf=rd,Zf=[].concat(Fu(sf),Fu(Sf)),Qf=qu.FontAwesomeConfig||{};function $f(e){var t=Ju.querySelector(`script[`+e+`]`);if(t)return t.getAttribute(e)}function ep(e){return e===``?!0:e===`false`?!1:e===`true`||e}Ju&&typeof Ju.querySelector==`function`&&[[`data-family-prefix`,`familyPrefix`],[`data-css-prefix`,`cssPrefix`],[`data-family-default`,`familyDefault`],[`data-style-default`,`styleDefault`],[`data-replacement-class`,`replacementClass`],[`data-auto-replace-svg`,`autoReplaceSvg`],[`data-auto-add-css`,`autoAddCss`],[`data-search-pseudo-elements`,`searchPseudoElements`],[`data-search-pseudo-elements-warnings`,`searchPseudoElementsWarnings`],[`data-search-pseudo-elements-full-scan`,`searchPseudoElementsFullScan`],[`data-observe-mutations`,`observeMutations`],[`data-mutate-approach`,`mutateApproach`],[`data-keep-original-source`,`keepOriginalSource`],[`data-measure-performance`,`measurePerformance`],[`data-show-missing-icons`,`showMissingIcons`]].forEach(function(e){var t=Pu(e,2),n=t[0],r=t[1],i=ep($f(n));i!=null&&(Qf[r]=i)});var tp={styleDefault:`solid`,familyDefault:ad,cssPrefix:Ef,replacementClass:Df,autoReplaceSvg:!0,autoAddCss:!0,searchPseudoElements:!1,searchPseudoElementsWarnings:!0,searchPseudoElementsFullScan:!1,observeMutations:!0,mutateApproach:`async`,keepOriginalSource:!0,measurePerformance:!1,showMissingIcons:!0};Qf.familyPrefix&&(Qf.cssPrefix=Qf.familyPrefix);var np=q(q({},tp),Qf);np.autoReplaceSvg||(np.observeMutations=!1);var J={};Object.keys(tp).forEach(function(e){Object.defineProperty(J,e,{enumerable:!0,set:function(t){np[e]=t,rp.forEach(function(e){return e(J)})},get:function(){return np[e]}})}),Object.defineProperty(J,"familyPrefix",{enumerable:!0,set:function(e){np.cssPrefix=e,rp.forEach(function(e){return e(J)})},get:function(){return np.cssPrefix}}),qu.FontAwesomeConfig=J;var rp=[];function ip(e){return rp.push(e),function(){rp.splice(rp.indexOf(e),1)}}var ap=Tf,op={size:16,x:0,y:0,rotate:0,flipX:!1,flipY:!1};function sp(e){if(!(!e||!Zu)){var t=Ju.createElement(`style`);t.setAttribute(`type`,`text/css`),t.innerHTML=e;for(var n=Ju.head.childNodes,r=null,i=n.length-1;i>-1;i--){var a=n[i],o=(a.tagName||``).toUpperCase();[`STYLE`,`LINK`].indexOf(o)>-1&&(r=a)}return Ju.head.insertBefore(t,r),e}}var cp=`0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`;function lp(){for(var e=12,t=``;e-->0;)t+=cp[Math.random()*62|0];return t}function up(e){for(var t=[],n=(e||[]).length>>>0;n--;)t[n]=e[n];return t}function dp(e){return e.classList?up(e.classList):(e.getAttribute(`class`)||``).split(` `).filter(function(e){return e})}function fp(e){return`${e}`.replace(/&/g,`&amp;`).replace(/"/g,`&quot;`).replace(/'/g,`&#39;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`)}function pp(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}="${fp(e[n])}" `},``).trim()}function mp(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}: ${e[n].trim()};`},``)}function hp(e){return e.size!==op.size||e.x!==op.x||e.y!==op.y||e.rotate!==op.rotate||e.flipX||e.flipY}function gp(e){var t=e.transform,n=e.containerWidth,r=e.iconWidth;return{outer:{transform:`translate(${n/2} 256)`},inner:{transform:`${`translate(${t.x*32}, ${t.y*32}) `} ${`scale(${t.size/16*(t.flipX?-1:1)}, ${t.size/16*(t.flipY?-1:1)}) `} ${`rotate(${t.rotate} 0 0)`}`},path:{transform:`translate(${r/2*-1} -256)`}}}function _p(e){var t=e.transform,n=e.width,r=n===void 0?Tf:n,i=e.height,a=i===void 0?Tf:i,o=e.startCentered,s=o!==void 0&&o,c=``;return c+=s&&Qu?`translate(${t.x/ap-r/2}em, ${t.y/ap-a/2}em) `:s?`translate(calc(-50% + ${t.x/ap}em), calc(-50% + ${t.y/ap}em)) `:`translate(${t.x/ap}em, ${t.y/ap}em) `,c+=`scale(${t.size/ap*(t.flipX?-1:1)}, ${t.size/ap*(t.flipY?-1:1)}) `,c+=`rotate(${t.rotate}deg) `,c}var vp=`:root, :host {
  --fa-font-solid: normal 900 1em/1 'Font Awesome 7 Free';
  --fa-font-regular: normal 400 1em/1 'Font Awesome 7 Free';
  --fa-font-light: normal 300 1em/1 'Font Awesome 7 Pro';
  --fa-font-thin: normal 100 1em/1 'Font Awesome 7 Pro';
  --fa-font-duotone: normal 900 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-regular: normal 400 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-light: normal 300 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-thin: normal 100 1em/1 'Font Awesome 7 Duotone';
  --fa-font-brands: normal 400 1em/1 'Font Awesome 7 Brands';
  --fa-font-sharp-solid: normal 900 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-regular: normal 400 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-light: normal 300 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-thin: normal 100 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-duotone-solid: normal 900 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-regular: normal 400 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-light: normal 300 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-thin: normal 100 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-slab-regular: normal 400 1em/1 'Font Awesome 7 Slab';
  --fa-font-slab-press-regular: normal 400 1em/1 'Font Awesome 7 Slab Press';
  --fa-font-slab-duo-regular: normal 400 1em/1 'Font Awesome 7 Slab Duo';
  --fa-font-slab-press-duo-regular: normal 400 1em/1 'Font Awesome 7 Slab Press Duo';
  --fa-font-pixel-regular: normal 400 1em/1 'Font Awesome 7 Pixel';
  --fa-font-mosaic-solid: normal 900 1em/1 'Font Awesome 7 Mosaic';
  --fa-font-vellum-solid: normal 900 1em/1 'Font Awesome 7 Vellum';
  --fa-font-whiteboard-semibold: normal 600 1em/1 'Font Awesome 7 Whiteboard';
  --fa-font-thumbprint-light: normal 300 1em/1 'Font Awesome 7 Thumbprint';
  --fa-font-notdog-solid: normal 900 1em/1 'Font Awesome 7 Notdog';
  --fa-font-notdog-duo-solid: normal 900 1em/1 'Font Awesome 7 Notdog Duo';
  --fa-font-etch-solid: normal 900 1em/1 'Font Awesome 7 Etch';
  --fa-font-graphite-thin: normal 100 1em/1 'Font Awesome 7 Graphite';
  --fa-font-jelly-regular: normal 400 1em/1 'Font Awesome 7 Jelly';
  --fa-font-jelly-fill-regular: normal 400 1em/1 'Font Awesome 7 Jelly Fill';
  --fa-font-jelly-duo-regular: normal 400 1em/1 'Font Awesome 7 Jelly Duo';
  --fa-font-chisel-regular: normal 400 1em/1 'Font Awesome 7 Chisel';
  --fa-font-utility-semibold: normal 600 1em/1 'Font Awesome 7 Utility';
  --fa-font-utility-duo-semibold: normal 600 1em/1 'Font Awesome 7 Utility Duo';
  --fa-font-utility-fill-semibold: normal 600 1em/1 'Font Awesome 7 Utility Fill';
}

.svg-inline--fa {
  box-sizing: content-box;
  display: var(--fa-display, inline-block);
  height: 1em;
  overflow: visible;
  vertical-align: -0.125em;
  width: var(--fa-width, 1.25em);
}
.svg-inline--fa.fa-2xs {
  vertical-align: 0.1em;
}
.svg-inline--fa.fa-xs {
  vertical-align: 0em;
}
.svg-inline--fa.fa-sm {
  vertical-align: -0.0714285714em;
}
.svg-inline--fa.fa-lg {
  vertical-align: -0.2em;
}
.svg-inline--fa.fa-xl {
  vertical-align: -0.25em;
}
.svg-inline--fa.fa-2xl {
  vertical-align: -0.3125em;
}
.svg-inline--fa.fa-pull-left,
.svg-inline--fa .fa-pull-start {
  float: inline-start;
  margin-inline-end: var(--fa-pull-margin, 0.3em);
}
.svg-inline--fa.fa-pull-right,
.svg-inline--fa .fa-pull-end {
  float: inline-end;
  margin-inline-start: var(--fa-pull-margin, 0.3em);
}
.svg-inline--fa.fa-li {
  width: var(--fa-li-width, 2em);
  inset-inline-start: calc(-1 * var(--fa-li-width, 2em));
  inset-block-start: 0.25em; /* syncing vertical alignment with Web Font rendering */
}

.fa-layers-counter, .fa-layers-text {
  display: inline-block;
  position: absolute;
  text-align: center;
}

.fa-layers {
  display: inline-block;
  height: 1em;
  position: relative;
  text-align: center;
  vertical-align: -0.125em;
  width: var(--fa-width, 1.25em);
}
.fa-layers .svg-inline--fa {
  inset: 0;
  margin: auto;
  position: absolute;
  transform-origin: center center;
}

.fa-layers-text {
  left: 50%;
  top: 50%;
  transform: translate(-50%, -50%);
  transform-origin: center center;
}

.fa-layers-counter {
  background-color: var(--fa-counter-background-color, #ff253a);
  border-radius: var(--fa-counter-border-radius, 1em);
  box-sizing: border-box;
  color: var(--fa-inverse, #fff);
  line-height: var(--fa-counter-line-height, 1);
  max-width: var(--fa-counter-max-width, 5em);
  min-width: var(--fa-counter-min-width, 1.5em);
  overflow: hidden;
  padding: var(--fa-counter-padding, 0.25em 0.5em);
  right: var(--fa-right, 0);
  text-overflow: ellipsis;
  top: var(--fa-top, 0);
  transform: scale(var(--fa-counter-scale, 0.25));
  transform-origin: top right;
}

.fa-layers-bottom-right {
  bottom: var(--fa-bottom, 0);
  right: var(--fa-right, 0);
  top: auto;
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: bottom right;
}

.fa-layers-bottom-left {
  bottom: var(--fa-bottom, 0);
  left: var(--fa-left, 0);
  right: auto;
  top: auto;
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: bottom left;
}

.fa-layers-top-right {
  top: var(--fa-top, 0);
  right: var(--fa-right, 0);
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: top right;
}

.fa-layers-top-left {
  left: var(--fa-left, 0);
  right: auto;
  top: var(--fa-top, 0);
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: top left;
}

.fa-1x {
  font-size: 1em;
}

.fa-2x {
  font-size: 2em;
}

.fa-3x {
  font-size: 3em;
}

.fa-4x {
  font-size: 4em;
}

.fa-5x {
  font-size: 5em;
}

.fa-6x {
  font-size: 6em;
}

.fa-7x {
  font-size: 7em;
}

.fa-8x {
  font-size: 8em;
}

.fa-9x {
  font-size: 9em;
}

.fa-10x {
  font-size: 10em;
}

.fa-2xs {
  font-size: calc(10 / 16 * 1em); /* converts a 10px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 10 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 10 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-xs {
  font-size: calc(12 / 16 * 1em); /* converts a 12px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 12 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 12 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-sm {
  font-size: calc(14 / 16 * 1em); /* converts a 14px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 14 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 14 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-lg {
  font-size: calc(20 / 16 * 1em); /* converts a 20px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 20 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 20 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-xl {
  font-size: calc(24 / 16 * 1em); /* converts a 24px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 24 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 24 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-2xl {
  font-size: calc(32 / 16 * 1em); /* converts a 32px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 32 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 32 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-width-auto {
  --fa-width: auto;
}

.fa-fw,
.fa-width-fixed {
  --fa-width: 1.25em;
}

.fa-canvas-square {
  padding-block: 0.125em;
  margin-block-end: -0.125em;
}

.fa-canvas-roomy {
  padding-block: 0.25em;
  padding-inline: 0.125em;
  margin-block-end: -0.25em;
  box-sizing: content-box;
}

.fa-ul {
  list-style-type: none;
  margin-inline-start: var(--fa-li-margin, 2.5em);
  padding-inline-start: 0;
}
.fa-ul > li {
  position: relative;
}

.fa-li {
  inset-inline-start: calc(-1 * var(--fa-li-width, 2em));
  position: absolute;
  text-align: center;
  width: var(--fa-li-width, 2em);
  line-height: inherit;
}

/* Heads Up: Bordered Icons will not be supported in the future!
  - This feature will be deprecated in the next major release of Font Awesome (v8)!
  - You may continue to use it in this version *v7), but it will not be supported in Font Awesome v8.
*/
/* Notes:
* --@{v.$css-prefix}-border-width = 1/16 by default (to render as ~1px based on a 16px default font-size)
* --@{v.$css-prefix}-border-padding =
  ** 3/16 for vertical padding (to give ~2px of vertical whitespace around an icon considering it's vertical alignment)
  ** 4/16 for horizontal padding (to give ~4px of horizontal whitespace around an icon)
*/
.fa-border {
  border-color: var(--fa-border-color, #eee);
  border-radius: var(--fa-border-radius, 0.1em);
  border-style: var(--fa-border-style, solid);
  border-width: var(--fa-border-width, 0.0625em);
  box-sizing: var(--fa-border-box-sizing, content-box);
  padding: var(--fa-border-padding, 0.1875em 0.25em);
}

.fa-pull-left,
.fa-pull-start {
  float: inline-start;
  margin-inline-end: var(--fa-pull-margin, 0.3em);
}

.fa-pull-right,
.fa-pull-end {
  float: inline-end;
  margin-inline-start: var(--fa-pull-margin, 0.3em);
}

.fa-beat {
  animation-name: fa-beat;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-bounce {
  animation-name: fa-bounce;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, cubic-bezier(0.28, 0.84, 0.42, 1));
}

.fa-fade {
  animation-name: fa-fade;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-beat-fade {
  animation-name: fa-beat-fade;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-flip {
  animation-name: fa-flip;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1.5s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-flip-360 {
  animation-name: fa-flip-360;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-shake {
  animation-name: fa-shake;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.75s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-spin {
  animation-name: fa-spin;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 2s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-reverse {
  --fa-animation-direction: reverse;
}

.fa-pulse,
.fa-spin-pulse {
  animation-name: fa-spin;
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, steps(8));
}

.fa-spin-snap {
  animation-name: fa-spin-snap;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 3s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-snap-4 {
  animation-name: fa-spin-snap-4;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 2.4s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-snap-8 {
  animation-name: fa-spin-snap-8;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 4s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-buzz {
  animation-name: fa-buzz;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.6s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-wag {
  animation-name: fa-wag;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.9s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
  transform-origin: bottom center;
}

.fa-float {
  animation-name: fa-float;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 3s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
  will-change: transform;
}

.fa-swing {
  animation-name: fa-swing;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1.2s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
  transform-origin: top center;
}

.fa-jello {
  animation-name: fa-jello;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.9s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
}

@media (prefers-reduced-motion: reduce) {
  .fa-beat,
  .fa-bounce,
  .fa-fade,
  .fa-beat-fade,
  .fa-flip,
  .fa-flip-360,
  .fa-pulse,
  .fa-shake,
  .fa-spin,
  .fa-spin-pulse,
  .fa-buzz,
  .fa-float,
  .fa-jello,
  .fa-spin-snap,
  .fa-spin-snap-4,
  .fa-spin-snap-8,
  .fa-swing,
  .fa-wag {
    animation: none !important;
    transition: none !important;
  }
}
@keyframes fa-beat {
  0% {
    transform: scale(1);
  }
  25% {
    transform: scale(calc(1.25 * var(--fa-beat-scale, 1.25)));
  }
  45% {
    transform: scale(calc(1.22 * var(--fa-beat-scale, 1.22)));
  }
  65% {
    transform: scale(calc(1.25 * var(--fa-beat-scale, 1.25)));
  }
  90% {
    transform: scale(1);
  }
}
@keyframes fa-bounce {
  0% {
    transform: scale(1, 1) translateY(0);
    animation-timing-function: var(--fa-animation-timing);
  }
  14% {
    transform: scale(var(--fa-bounce-start-scale-x, 1.06), var(--fa-bounce-start-scale-y, 0.94)) translateY(var(--fa-bounce-anticipation, 3px));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  32% {
    transform: scale(var(--fa-bounce-jump-scale-x, 0.94), var(--fa-bounce-jump-scale-y, 1.12)) translateY(calc(-1 * var(--fa-bounce-height, 0.5em)));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  52% {
    transform: scale(1, 1) translateY(calc(-1 * var(--fa-bounce-height, 0.5em) * 1.1));
    animation-timing-function: cubic-bezier(0.5, 0, 1, 0.5);
  }
  70% {
    transform: scale(var(--fa-bounce-land-scale-x, 1.06), var(--fa-bounce-land-scale-y, 0.92)) translateY(0);
    animation-timing-function: cubic-bezier(0.33, 0.33, 0.66, 1);
  }
  85% {
    transform: scale(0.98, 1.04) translateY(calc(-2px * var(--fa-bounce-rebound, 1)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: scale(1, 1) translateY(0);
  }
}
@keyframes fa-fade {
  0% {
    opacity: 1;
    transform: scale(1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  40% {
    opacity: var(--fa-fade-opacity, 0.4);
    transform: scale(0.98);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  100% {
    opacity: 1;
    transform: scale(1);
  }
}
@keyframes fa-beat-fade {
  0% {
    opacity: var(--fa-beat-fade-opacity, 0.4);
    transform: scale(1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  25% {
    opacity: calc(var(--fa-beat-fade-opacity, 0.4) + 0.4);
    transform: scale(var(--fa-beat-fade-scale, 1.28));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  45% {
    opacity: 1;
    transform: scale(var(--fa-beat-fade-scale, 1.25));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  65% {
    opacity: calc(var(--fa-beat-fade-opacity, 0.4) + 0.4);
    transform: scale(var(--fa-beat-fade-scale, 1.28));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  100% {
    opacity: var(--fa-beat-fade-opacity, 0.4);
    transform: scale(1);
  }
}
@keyframes fa-flip {
  0% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  8% {
    transform: perspective(2em) scale(var(--fa-flip-anticipation-scale, 0.95)) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  35% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.6));
    animation-timing-function: linear;
  }
  65% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.5));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  92% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * var(--fa-flip-overshoot, 1.04)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), var(--fa-flip-angle, -360deg));
  }
}
@keyframes fa-flip-360 {
  0% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  8% {
    transform: perspective(2em) scale(var(--fa-flip-anticipation-scale, 0.95)) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  50% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.6));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  80% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * var(--fa-flip-overshoot, 1.04)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), var(--fa-flip-angle, -360deg));
  }
}
@keyframes fa-shake {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  8% {
    transform: rotate(35deg) translateX(1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  20% {
    transform: rotate(-22deg) translateX(-1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  35% {
    transform: rotate(15deg) translateX(1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  50% {
    transform: rotate(-9deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  65% {
    transform: rotate(5deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  78% {
    transform: rotate(-3deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  90% {
    transform: rotate(1deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-spin {
  0% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  12% {
    transform: rotate(60deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  16.67% {
    transform: rotate(60deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  28.67% {
    transform: rotate(120deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  33.33% {
    transform: rotate(120deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  45.33% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  62% {
    transform: rotate(240deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  66.67% {
    transform: rotate(240deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  78.67% {
    transform: rotate(300deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  83.33% {
    transform: rotate(300deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  95.33% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap-4 {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  15% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  25% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  40% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  65% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  75% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  90% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap-8 {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  9% {
    transform: rotate(45deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  12.5% {
    transform: rotate(45deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  21.5% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  25% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  34% {
    transform: rotate(135deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  37.5% {
    transform: rotate(135deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  46.5% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  59% {
    transform: rotate(225deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  62.5% {
    transform: rotate(225deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  71.5% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  75% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  84% {
    transform: rotate(315deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  87.5% {
    transform: rotate(315deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  96.5% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-buzz {
  0% {
    transform: translateX(0) rotate(0deg);
    animation-timing-function: cubic-bezier(0.1, 0, 0.9, 1);
  }
  5% {
    transform: translateX(var(--fa-buzz-distance, 4px)) rotate(0.5deg);
  }
  10% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px))) rotate(-0.5deg);
  }
  15% {
    transform: translateX(var(--fa-buzz-distance, 4px)) rotate(0.3deg);
  }
  20% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px))) rotate(-0.3deg);
  }
  25% {
    transform: translateX(calc(var(--fa-buzz-distance, 4px) * 0.7)) rotate(0.2deg);
  }
  30% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px) * 0.7)) rotate(-0.2deg);
  }
  35% {
    transform: translateX(calc(var(--fa-buzz-distance, 4px) * 0.4)) rotate(0.1deg);
  }
  40% {
    transform: translateX(0) rotate(0deg);
  }
  100% {
    transform: translateX(0) rotate(0deg);
  }
}
@keyframes fa-wag {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  12% {
    transform: rotate(var(--fa-wag-angle, 12deg));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  24% {
    transform: rotate(2deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  36% {
    transform: rotate(calc(var(--fa-wag-angle, 12deg) * 0.85));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  48% {
    transform: rotate(1deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  58% {
    transform: rotate(calc(var(--fa-wag-angle, 12deg) * 0.6));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  68% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-float {
  0% {
    transform: translateY(0) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  15% {
    transform: translateY(calc(-0.4 * var(--fa-float-height, 6px))) translateX(var(--fa-float-drift, 1px)) rotate(var(--fa-float-tilt, 1deg)) scale(1, 1);
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  35% {
    transform: translateY(calc(-1 * var(--fa-float-height, 6px))) translateX(0) rotate(0deg) scale(var(--fa-float-stretch-x, 0.98), var(--fa-float-stretch-y, 1.03));
    animation-timing-function: cubic-bezier(0.5, 0, 0.5, 0);
  }
  50% {
    transform: translateY(calc(-0.92 * var(--fa-float-height, 6px))) translateX(calc(-0.5 * var(--fa-float-drift, 1px))) rotate(calc(-0.5 * var(--fa-float-tilt, 1deg))) scale(0.995, 1.01);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  70% {
    transform: translateY(calc(-0.3 * var(--fa-float-height, 6px))) translateX(calc(-1 * var(--fa-float-drift, 1px))) rotate(calc(-1 * var(--fa-float-tilt, 1deg))) scale(1, 1);
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  90% {
    transform: translateY(calc(0.05 * var(--fa-float-height, 6px))) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: translateY(0) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
  }
}
@keyframes fa-swing {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  8% {
    transform: rotate(var(--fa-swing-angle, 22deg));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  18% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.85));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  28% {
    transform: rotate(calc(var(--fa-swing-angle, 22deg) * 0.65));
    animation-timing-function: cubic-bezier(0.35, 0, 0.65, 1);
  }
  38% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.45));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  48% {
    transform: rotate(calc(var(--fa-swing-angle, 22deg) * 0.25));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  56% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.1));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  64% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-jello {
  0% {
    transform: scale(1, 1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  12% {
    transform: scale(var(--fa-jello-scale-x, 1.15), calc(2 - var(--fa-jello-scale-x, 1.15)));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  24% {
    transform: scale(calc(2 - var(--fa-jello-scale-y, 1.12)), var(--fa-jello-scale-y, 1.12));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  36% {
    transform: scale(calc(1 + (var(--fa-jello-scale-x, 1.15) - 1) * 0.5), calc(2 - (1 + (var(--fa-jello-scale-x, 1.15) - 1) * 0.5)));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  48% {
    transform: scale(calc(2 - (1 + (var(--fa-jello-scale-y, 1.12) - 1) * 0.3)), calc(1 + (var(--fa-jello-scale-y, 1.12) - 1) * 0.3));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  58% {
    transform: scale(1.02, 0.98);
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  68% {
    transform: scale(1, 1);
  }
  100% {
    transform: scale(1, 1);
  }
}
.fa-rotate-90 {
  transform: rotate(90deg);
}

.fa-rotate-180 {
  transform: rotate(180deg);
}

.fa-rotate-270 {
  transform: rotate(270deg);
}

.fa-flip-horizontal {
  transform: scale(-1, 1);
}

.fa-flip-vertical {
  transform: scale(1, -1);
}

.fa-flip-both,
.fa-flip-horizontal.fa-flip-vertical {
  transform: scale(-1, -1);
}

.fa-rotate-by {
  transform: rotate(var(--fa-rotate-angle, 0));
}

.svg-inline--fa .fa-primary {
  fill: var(--fa-primary-color, currentColor);
  opacity: var(--fa-primary-opacity, 1);
}

.svg-inline--fa .fa-secondary {
  fill: var(--fa-secondary-color, currentColor);
  opacity: var(--fa-secondary-opacity, 0.4);
}

.svg-inline--fa.fa-swap-opacity .fa-primary {
  opacity: var(--fa-secondary-opacity, 0.4);
}

.svg-inline--fa.fa-swap-opacity .fa-secondary {
  opacity: var(--fa-primary-opacity, 1);
}

.svg-inline--fa mask .fa-primary,
.svg-inline--fa mask .fa-secondary {
  fill: black;
}

.svg-inline--fa.fa-inverse {
  fill: var(--fa-inverse, #fff);
}

.fa-stack {
  display: inline-block;
  height: 2em;
  line-height: 2em;
  position: relative;
  vertical-align: middle;
  width: 2.5em;
}

.fa-inverse {
  color: var(--fa-inverse, #fff);
}

.svg-inline--fa.fa-stack-1x {
  --fa-width: 1.25em;
  height: 1em;
  width: var(--fa-width);
}
.svg-inline--fa.fa-stack-2x {
  --fa-width: 2.5em;
  height: 2em;
  width: var(--fa-width);
}

.fa-stack-1x,
.fa-stack-2x {
  inset: 0;
  margin: auto;
  position: absolute;
  z-index: var(--fa-stack-z-index, auto);
}`;function yp(){var e=Ef,t=Df,n=J.cssPrefix,r=J.replacementClass,i=vp;if(n!==e||r!==t){var a=RegExp(`\\.${e}\\-`,`g`),o=RegExp(`\\--${e}\\-`,`g`),s=RegExp(`\\.${t}`,`g`);i=i.replace(a,`.${n}-`).replace(o,`--${n}-`).replace(s,`.${r}`)}return i}var bp=!1;function xp(){J.autoAddCss&&!bp&&(sp(yp()),bp=!0)}var Sp={mixout:function(){return{dom:{css:yp,insertCss:xp}}},hooks:function(){return{beforeDOMElementCreation:function(){xp()},beforeI2svg:function(){xp()}}}},Cp=qu||{};Cp[wf]||(Cp[wf]={}),Cp[wf].styles||(Cp[wf].styles={}),Cp[wf].hooks||(Cp[wf].hooks={}),Cp[wf].shims||(Cp[wf].shims=[]);var wp=Cp[wf],Tp=[],Ep=function(){Ju.removeEventListener(`DOMContentLoaded`,Ep),Dp=1,Tp.map(function(e){return e()})},Dp=!1;Zu&&(Dp=(Ju.documentElement.doScroll?/^loaded|^c/:/^loaded|^i|^c/).test(Ju.readyState),Dp||Ju.addEventListener(`DOMContentLoaded`,Ep));function Op(e){Zu&&(Dp?setTimeout(e,0):Tp.push(e))}function kp(e){var t=e.tag,n=e.attributes,r=n===void 0?{}:n,i=e.children,a=i===void 0?[]:i;return typeof e==`string`?fp(e):`<${t} ${pp(r)}>${a.map(kp).join(``)}</${t}>`}function Ap(e,t,n){if(e&&e[t]&&e[t][n])return{prefix:t,iconName:n,icon:e[t][n]}}var jp=function(e,t){return function(n,r,i,a){return e.call(t,n,r,i,a)}},Mp=function(e,t,n,r){var i=Object.keys(e),a=i.length,o=r===void 0?t:jp(t,r),s,c,l;for(n===void 0?(s=1,l=e[i[0]]):(s=0,l=n);s<a;s++)c=i[s],l=o(l,e[c],c,e);return l};function Np(e){return Fu(e).length===1?e.codePointAt(0).toString(16):null}function Pp(e){return Object.keys(e).reduce(function(t,n){var r=e[n];return r.icon?t[r.iconName]=r.icon:t[n]=r,t},{})}function Fp(e,t){var n=(arguments.length>2&&arguments[2]!==void 0?arguments[2]:{}).skipHooks,r=n!==void 0&&n,i=Pp(t);typeof wp.hooks.addPack==`function`&&!r?wp.hooks.addPack(e,Pp(t)):wp.styles[e]=q(q({},wp.styles[e]||{}),i),e===`fas`&&Fp(`fa`,t)}var Ip=wp.styles,Lp=wp.shims,Rp=Object.keys(Wf),zp=Rp.reduce(function(e,t){return e[t]=Object.keys(Wf[t]),e},{}),Bp=null,Vp={},Hp={},Up={},Wp={},Gp={};function Kp(e){return~Zf.indexOf(e)}function qp(e,t){var n=t.split(`-`),r=n[0],i=n.slice(1).join(`-`);return r===e&&i!==``&&!Kp(i)?i:null}var Jp=function(){var e=function(e){return Mp(Ip,function(t,n,r){return t[r]=Mp(n,e,{}),t},{})};Vp=e(function(e,t,n){return t[3]&&(e[t[3]]=n),t[2]&&t[2].filter(function(e){return typeof e==`number`}).forEach(function(t){e[t.toString(16)]=n}),e}),Hp=e(function(e,t,n){return e[n]=n,t[2]&&t[2].filter(function(e){return typeof e==`string`}).forEach(function(t){e[t]=n}),e}),Gp=e(function(e,t,n){var r=t[2];return e[n]=n,r.forEach(function(t){e[t]=n}),e});var t=`far`in Ip||J.autoFetchSvg,n=Mp(Lp,function(e,n){var r=n[0],i=n[1],a=n[2];return i===`far`&&!t&&(i=`fas`),typeof r==`string`&&(e.names[r]={prefix:i,iconName:a}),typeof r==`number`&&(e.unicodes[r.toString(16)]={prefix:i,iconName:a}),e},{names:{},unicodes:{}});Up=n.names,Wp=n.unicodes,Bp=rm(J.styleDefault,{family:J.familyDefault})};ip(function(e){Bp=rm(e.styleDefault,{family:J.familyDefault})}),Jp();function Yp(e,t){return(Vp[e]||{})[t]}function Xp(e,t){return(Hp[e]||{})[t]}function Zp(e,t){return(Gp[e]||{})[t]}function Qp(e){return Up[e]||{prefix:null,iconName:null}}function $p(e){var t=Wp[e],n=Yp(`fas`,e);return t||(n?{prefix:`fas`,iconName:n}:null)||{prefix:null,iconName:null}}function em(){return Bp}var tm=function(){return{prefix:null,iconName:null,rest:[]}};function nm(e){var t=ad,n=Rp.reduce(function(e,t){return e[t]=`${J.cssPrefix}-${t}`,e},{});return $d.forEach(function(r){(e.includes(n[r])||e.some(function(e){return zp[r].includes(e)}))&&(t=r)}),t}function rm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).family,n=t===void 0?ad:t,r=Bf[n][e];if(n===od&&!e)return`fad`;var i=Hf[n][e]||Hf[n][r],a=e in wp.styles?e:null;return i||a||null}function im(e){var t=[],n=null;return e.forEach(function(e){var r=qp(J.cssPrefix,e);r?n=r:e&&t.push(e)}),{iconName:n,rest:t}}function am(e){return e.sort().filter(function(e,t,n){return n.indexOf(e)===t})}var om=vf.concat(af);function sm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).skipLookups,n=t!==void 0&&t,r=null,i=am(e.filter(function(e){return om.includes(e)})),a=am(e.filter(function(e){return!om.includes(e)})),o=Pu(i.filter(function(e){return r=e,!id.includes(e)}),1)[0],s=o===void 0?null:o,c=nm(i),l=q(q({},im(a)),{},{prefix:rm(s,{family:c})});return q(q(q({},l),dm({values:e,family:c,styles:Ip,config:J,canonical:l,givenPrefix:r})),cm(n,r,l))}function cm(e,t,n){var r=n.prefix,i=n.iconName;if(e||!r||!i)return{prefix:r,iconName:i};var a=t===`fa`?Qp(i):{},o=Zp(r,i);return i=a.iconName||o||i,r=a.prefix||r,r===`far`&&!Ip.far&&Ip.fas&&!J.autoFetchSvg&&(r=`fas`),{prefix:r,iconName:i}}var lm=$d.filter(function(e){return e!==ad||e!==od}),um=Object.keys(_f).filter(function(e){return e!==ad}).map(function(e){return Object.keys(_f[e])}).flat();function dm(e){var t=e.values,n=e.family,r=e.canonical,i=e.givenPrefix,a=i===void 0?``:i,o=e.styles,s=o===void 0?{}:o,c=e.config,l=c===void 0?{}:c,u=n===od,d=t.includes(`fa-duotone`)||t.includes(`fad`),f=l.familyDefault===`duotone`,p=r.prefix===`fad`||r.prefix===`fa-duotone`;return!u&&(d||f||p)&&(r.prefix=`fad`),(t.includes(`fa-brands`)||t.includes(`fab`))&&(r.prefix=`fab`),!r.prefix&&lm.includes(n)&&(Object.keys(s).find(function(e){return um.includes(e)})||l.autoFetchSvg)&&(r.prefix=nf.get(n).defaultShortPrefixId,r.iconName=Zp(r.prefix,r.iconName)||r.iconName),(r.prefix===`fa`||a===`fa`)&&(r.prefix=em()||`fas`),r}var fm=function(){function e(){Tu(this,e),this.definitions={}}return Du(e,[{key:`add`,value:function(){var e=this,t=[...arguments].reduce(this._pullDefinitions,{});Object.keys(t).forEach(function(n){e.definitions[n]=q(q({},e.definitions[n]||{}),t[n]),Fp(n,t[n]);var r=Wf[ad][n];r&&Fp(r,t[n]),Jp()})}},{key:`reset`,value:function(){this.definitions={}}},{key:`_pullDefinitions`,value:function(e,t){var n=t.prefix&&t.iconName&&t.icon?{0:t}:t;return Object.keys(n).map(function(t){var r=n[t],i=r.prefix,a=r.iconName,o=r.icon,s=o[2];e[i]||(e[i]={}),s.length>0&&s.forEach(function(t){typeof t==`string`&&(e[i][t]=o)}),e[i][a]=o}),e}}])}(),pm=[],mm={},hm={},gm=Object.keys(hm);function _m(e,t){var n=t.mixoutsTo;return pm=e,mm={},Object.keys(hm).forEach(function(e){gm.indexOf(e)===-1&&delete hm[e]}),pm.forEach(function(e){var t=e.mixout?e.mixout():{};if(Object.keys(t).forEach(function(e){typeof t[e]==`function`&&(n[e]=t[e]),Ru(t[e])===`object`&&Object.keys(t[e]).forEach(function(r){n[e]||(n[e]={}),n[e][r]=t[e][r]})}),e.hooks){var r=e.hooks();Object.keys(r).forEach(function(e){mm[e]||(mm[e]=[]),mm[e].push(r[e])})}e.provides&&e.provides(hm)}),n}function vm(e,t){var n=[...arguments].slice(2);return(mm[e]||[]).forEach(function(e){t=e.apply(null,[t].concat(n))}),t}function ym(e){var t=[...arguments].slice(1);(mm[e]||[]).forEach(function(e){e.apply(null,t)})}function bm(){var e=arguments[0],t=Array.prototype.slice.call(arguments,1);return hm[e]?hm[e].apply(null,t):void 0}function xm(e){e.prefix===`fa`&&(e.prefix=`fas`);var t=e.iconName,n=e.prefix||em();if(t)return t=Zp(n,t)||t,Ap(Sm.definitions,n,t)||Ap(wp.styles,n,t)}var Sm=new fm,Cm={noAuto:function(){J.autoReplaceSvg=!1,J.observeMutations=!1,ym(`noAuto`)},config:J,dom:{i2svg:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return Zu?(ym(`beforeI2svg`,e),bm(`pseudoElements2svg`,e),bm(`i2svg`,e)):Promise.reject(Error(`Operation requires a DOM of some kind.`))},watch:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},t=e.autoReplaceSvgRoot;J.autoReplaceSvg===!1&&(J.autoReplaceSvg=!0),J.observeMutations=!0,Op(function(){wm({autoReplaceSvgRoot:t}),ym(`watch`,e)})}},parse:{icon:function(e){if(e===null)return null;if(Ru(e)===`object`&&e.prefix&&e.iconName)return{prefix:e.prefix,iconName:Zp(e.prefix,e.iconName)||e.iconName};if(Array.isArray(e)&&e.length===2){var t=e[1].indexOf(`fa-`)===0?e[1].slice(3):e[1],n=rm(e[0]);return{prefix:n,iconName:Zp(n,t)||t}}if(typeof e==`string`&&(e.indexOf(`${J.cssPrefix}-`)>-1||e.match(Kf))){var r=sm(e.split(` `),{skipLookups:!0});return{prefix:r.prefix||em(),iconName:Zp(r.prefix,r.iconName)||r.iconName}}if(typeof e==`string`){var i=em();return{prefix:i,iconName:Zp(i,e)||e}}}},library:Sm,findIconDefinition:xm,toHtml:kp},wm=function(){var e=(arguments.length>0&&arguments[0]!==void 0?arguments[0]:{}).autoReplaceSvgRoot,t=e===void 0?Ju:e;(Object.keys(wp.styles).length>0||J.autoFetchSvg)&&Zu&&J.autoReplaceSvg&&Cm.dom.i2svg({node:t})};function Tm(e,t){return Object.defineProperty(e,"abstract",{get:t}),Object.defineProperty(e,"html",{get:function(){return e.abstract.map(function(e){return kp(e)})}}),Object.defineProperty(e,"node",{get:function(){if(Zu){var t=Ju.createElement(`div`);return t.innerHTML=e.html,t.children}}}),e}function Em(e){var t=e.children,n=e.main,r=e.mask,i=e.attributes,a=e.styles,o=e.transform;if(hp(o)&&n.found&&!r.found){var s={x:n.width/n.height/2,y:.5};i.style=mp(q(q({},a),{},{"transform-origin":`${s.x+o.x/16}em ${s.y+o.y/16}em`}))}return[{tag:`svg`,attributes:i,children:t}]}function Dm(e){var t=e.prefix,n=e.iconName,r=e.children,i=e.attributes,a=e.symbol,o=a===!0?`${t}-${J.cssPrefix}-${n}`:a;return[{tag:`svg`,attributes:{style:`display: none;`},children:[{tag:`symbol`,attributes:q(q({},i),{},{id:o}),children:r}]}]}function Om(e){return[`aria-label`,`aria-labelledby`,`title`,`role`].some(function(t){return t in e})}function km(e){var t=e.icons,n=t.main,r=t.mask,i=e.prefix,a=e.iconName,o=e.transform,s=e.symbol,c=e.maskId,l=e.extra,u=e.watchable,d=u!==void 0&&u,f=r.found?r:n,p=f.width,m=f.height,h=[J.replacementClass,a?`${J.cssPrefix}-${a}`:``].filter(function(e){return l.classes.indexOf(e)===-1}).filter(function(e){return e!==``||!!e}).concat(l.classes).join(` `),g={children:[],attributes:q(q({},l.attributes),{},{"data-prefix":i,"data-icon":a,class:h,role:l.attributes.role||`img`,viewBox:`0 0 ${p} ${m}`})};!Om(l.attributes)&&!l.attributes[`aria-hidden`]&&(g.attributes[`aria-hidden`]=`true`),d&&(g.attributes[Of]=``);var _=q(q({},g),{},{prefix:i,iconName:a,main:n,mask:r,maskId:c,transform:o,symbol:s,styles:q({},l.styles)}),v=r.found&&n.found?bm(`generateAbstractMask`,_)||{children:[],attributes:{}}:bm(`generateAbstractIcon`,_)||{children:[],attributes:{}},y=v.children,b=v.attributes;return _.children=y,_.attributes=b,s?Dm(_):Em(_)}function Am(e){var t=e.content,n=e.width,r=e.height,i=e.transform,a=e.extra,o=e.watchable,s=o!==void 0&&o,c=q(q({},a.attributes),{},{class:a.classes.join(` `)});s&&(c[Of]=``);var l=q({},a.styles);hp(i)&&(l.transform=_p({transform:i,startCentered:!0,width:n,height:r}),l[`-webkit-transform`]=l.transform);var u=mp(l);u.length>0&&(c.style=u);var d=[];return d.push({tag:`span`,attributes:c,children:[t]}),d}function jm(e){var t=e.content,n=e.extra,r=q(q({},n.attributes),{},{class:n.classes.join(` `)}),i=mp(n.styles);i.length>0&&(r.style=i);var a=[];return a.push({tag:`span`,attributes:r,children:[t]}),a}var Mm=wp.styles;function Nm(e){var t=e[0],n=e[1],r=Pu(e.slice(4),1)[0],i=null;return i=Array.isArray(r)?{tag:`g`,attributes:{class:`${J.cssPrefix}-${Xf.GROUP}`},children:[{tag:`path`,attributes:{class:`${J.cssPrefix}-${Xf.SECONDARY}`,fill:`currentColor`,d:r[0]}},{tag:`path`,attributes:{class:`${J.cssPrefix}-${Xf.PRIMARY}`,fill:`currentColor`,d:r[1]}}]}:{tag:`path`,attributes:{fill:`currentColor`,d:r}},{found:!0,width:t,height:n,icon:i}}var Pm={found:!1,width:512,height:512};function Fm(e,t){!Lf&&!J.showMissingIcons&&e&&console.error(`Icon with name "${e}" and prefix "${t}" is missing.`)}function Im(e,t){var n=t;return t===`fa`&&J.styleDefault!==null&&(t=em()),new Promise(function(r,i){if(n===`fa`){var a=Qp(e)||{};e=a.iconName||e,t=a.prefix||t}if(e&&t&&Mm[t]&&Mm[t][e]){var o=Mm[t][e];return r(Nm(o))}Fm(e,t),r(q(q({},Pm),{},{icon:J.showMissingIcons&&e&&bm(`missingIconAbstract`)||{}}))})}var Lm=function(){},Rm=J.measurePerformance&&Xu&&Xu.mark&&Xu.measure?Xu:{mark:Lm,measure:Lm},zm=`FA "7.3.1"`,Bm=function(e){return Rm.mark(`${zm} ${e} begins`),function(){return Vm(e)}},Vm=function(e){Rm.mark(`${zm} ${e} ends`),Rm.measure(`${zm} ${e}`,`${zm} ${e} begins`,`${zm} ${e} ends`)},Hm={begin:Bm,end:Vm},Um=function(){};function Wm(e){return typeof(e.getAttribute?e.getAttribute(Of):null)==`string`}function Gm(e){var t=e.getAttribute?e.getAttribute(jf):null,n=e.getAttribute?e.getAttribute(Mf):null;return t&&n}function Km(e){return e&&e.classList&&e.classList.contains&&e.classList.contains(J.replacementClass)}function qm(){return J.autoReplaceSvg===!0?Qm.replace:Qm[J.autoReplaceSvg]||Qm.replace}function Jm(e){return Ju.createElementNS(`http://www.w3.org/2000/svg`,e)}function Ym(e){return Ju.createElement(e)}function Xm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).ceFn,n=t===void 0?e.tag===`svg`?Jm:Ym:t;if(typeof e==`string`)return Ju.createTextNode(e);var r=n(e.tag);return Object.keys(e.attributes||[]).forEach(function(t){r.setAttribute(t,e.attributes[t])}),(e.children||[]).forEach(function(e){r.appendChild(Xm(e,{ceFn:n}))}),r}function Zm(e){var t=` ${e.outerHTML} `;return t=`${t}Font Awesome fontawesome.com `,t}var Qm={replace:function(e){var t=e[0];if(t.parentNode){if(e[1].forEach(function(e){t.parentNode.insertBefore(Xm(e),t)}),t.getAttribute(Of)===null&&J.keepOriginalSource){var n=Ju.createComment(Zm(t));t.parentNode.replaceChild(n,t)}else t.remove()}},nest:function(e){var t=e[0],n=e[1];if(~dp(t).indexOf(J.replacementClass))return Qm.replace(e);var r=RegExp(`${J.cssPrefix}-.*`);if(delete n[0].attributes.id,n[0].attributes.class){var i=n[0].attributes.class.split(` `).reduce(function(e,t){return t===J.replacementClass||t.match(r)?e.toSvg.push(t):e.toNode.push(t),e},{toNode:[],toSvg:[]});n[0].attributes.class=i.toSvg.join(` `),i.toNode.length===0?t.removeAttribute(`class`):t.setAttribute(`class`,i.toNode.join(` `))}var a=n.map(function(e){return kp(e)}).join(`
`);t.setAttribute(Of,``),t.innerHTML=a}};function $m(e){e()}function eh(e,t){var n=typeof t==`function`?t:Um;if(e.length===0)n();else{var r=$m;J.mutateApproach===Pf&&(r=qu.requestAnimationFrame||$m),r(function(){var t=qm(),r=Hm.begin(`mutate`);e.map(t),r(),n()})}}var th=!1;function nh(){th=!0}function rh(){th=!1}var ih=null;function ah(e){if(Yu&&J.observeMutations){var t=e.treeCallback,n=t===void 0?Um:t,r=e.nodeCallback,i=r===void 0?Um:r,a=e.pseudoElementsCallback,o=a===void 0?Um:a,s=e.observeMutationsRoot,c=s===void 0?Ju:s;ih=new Yu(function(e){if(!th){var t=em();up(e).forEach(function(e){if(e.type===`childList`&&e.addedNodes.length>0&&!Wm(e.addedNodes[0])&&(J.searchPseudoElements&&o(e.target),n(e.target)),e.type===`attributes`&&e.target.parentNode&&J.searchPseudoElements&&o([e.target],!0),e.type===`attributes`&&Wm(e.target)&&~Yf.indexOf(e.attributeName)){if(e.attributeName===`class`&&Gm(e.target)){var r=sm(dp(e.target)),a=r.prefix,s=r.iconName;e.target.setAttribute(jf,a||t),s&&e.target.setAttribute(Mf,s)}else Km(e.target)&&i(e.target)}})}}),Zu&&ih.observe(c,{childList:!0,attributes:!0,characterData:!0,subtree:!0})}}function oh(){ih&&ih.disconnect()}function sh(e){var t=e.getAttribute(`style`),n=[];return t&&(n=t.split(`;`).reduce(function(e,t){var n=t.split(`:`),r=n[0],i=n.slice(1);return r&&i.length>0&&(e[r]=i.join(`:`).trim()),e},{})),n}function ch(e){var t=e.getAttribute(`data-prefix`),n=e.getAttribute(`data-icon`),r=e.innerText===void 0?``:e.innerText.trim(),i=sm(dp(e));return i.prefix||=em(),t&&n&&(i.prefix=t,i.iconName=n),i.iconName&&i.prefix?i:(i.prefix&&r.length>0&&(i.iconName=Xp(i.prefix,e.innerText)||Yp(i.prefix,Np(e.innerText))),!i.iconName&&J.autoFetchSvg&&e.firstChild&&e.firstChild.nodeType===Node.TEXT_NODE&&(i.iconName=e.firstChild.data),i)}function lh(e){return up(e.attributes).reduce(function(e,t){return e.name!==`class`&&e.name!==`style`&&(e[t.name]=t.value),e},{})}function uh(){return{iconName:null,prefix:null,transform:op,symbol:!1,mask:{iconName:null,prefix:null,rest:[]},maskId:null,extra:{classes:[],styles:{},attributes:{}}}}function dh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{styleParser:!0},n=ch(e),r=n.iconName,i=n.prefix,a=n.rest,o=lh(e),s=vm(`parseNodeAttributes`,{},e);return q({iconName:r,prefix:i,transform:op,mask:{iconName:null,prefix:null,rest:[]},maskId:null,symbol:!1,extra:{classes:a,styles:t.styleParser?sh(e):[],attributes:o}},s)}var fh=wp.styles;function ph(e){var t=J.autoReplaceSvg===`nest`?dh(e,{styleParser:!1}):dh(e);return~t.extra.classes.indexOf(qf)?bm(`generateLayersText`,e,t):bm(`generateSvgReplacementMutation`,e,t)}function mh(){return[].concat(Fu(af),Fu(vf))}function hh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(!Zu)return Promise.resolve();var n=Ju.documentElement.classList,r=function(e){return n.add(`${Nf}-${e}`)},i=function(e){return n.remove(`${Nf}-${e}`)},a=J.autoFetchSvg?mh():id.concat(Object.keys(fh));a.includes(`fa`)||a.push(`fa`);var o=[`.${qf}:not([${Of}])`].concat(a.map(function(e){return`.${e}:not([${Of}])`})).join(`, `);if(o.length===0)return Promise.resolve();var s=[];try{s=up(e.querySelectorAll(o))}catch{}if(s.length>0)r(`pending`),i(`complete`);else return Promise.resolve();var c=Hm.begin(`onTree`),l=s.reduce(function(e,t){try{var n=ph(t);n&&e.push(n)}catch(e){Lf||e.name===`MissingIcon`&&console.error(e)}return e},[]);return new Promise(function(e,n){Promise.all(l).then(function(n){eh(n,function(){r(`active`),r(`complete`),i(`pending`),typeof t==`function`&&t(),c(),e()})}).catch(function(e){c(),n(e)})})}function gh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;ph(e).then(function(e){e&&eh([e],t)})}function _h(e){return function(t){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},r=(t||{}).icon?t:xm(t||{}),i=n.mask;return i&&=(i||{}).icon?i:xm(i||{}),e(r,q(q({},n),{},{mask:i}))}}var vh=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?op:n,i=t.symbol,a=i!==void 0&&i,o=t.mask,s=o===void 0?null:o,c=t.maskId,l=c===void 0?null:c,u=t.classes,d=u===void 0?[]:u,f=t.attributes,p=f===void 0?{}:f,m=t.styles,h=m===void 0?{}:m;if(e){var g=e.prefix,_=e.iconName,v=e.icon;return Tm(q({type:`icon`},e),function(){return ym(`beforeDOMElementCreation`,{iconDefinition:e,params:t}),km({icons:{main:Nm(v),mask:s?Nm(s.icon):{found:!1,width:null,height:null,icon:{}}},prefix:g,iconName:_,transform:q(q({},op),r),symbol:a,maskId:l,extra:{attributes:p,styles:h,classes:d}})})}},yh={mixout:function(){return{icon:_h(vh)}},hooks:function(){return{mutationObserverCallbacks:function(e){return e.treeCallback=hh,e.nodeCallback=gh,e}}},provides:function(e){e.i2svg=function(e){var t=e.node,n=t===void 0?Ju:t,r=e.callback;return hh(n,r===void 0?function(){}:r)},e.generateSvgReplacementMutation=function(e,t){var n=t.iconName,r=t.prefix,i=t.transform,a=t.symbol,o=t.mask,s=t.maskId,c=t.extra;return new Promise(function(t,l){Promise.all([Im(n,r),o.iconName?Im(o.iconName,o.prefix):Promise.resolve({found:!1,width:512,height:512,icon:{}})]).then(function(o){var l=Pu(o,2),u=l[0],d=l[1];t([e,km({icons:{main:u,mask:d},prefix:r,iconName:n,transform:i,symbol:a,maskId:s,extra:c,watchable:!0})])}).catch(l)})},e.generateAbstractIcon=function(e){var t=e.children,n=e.attributes,r=e.main,i=e.transform,a=e.styles,o=mp(a);o.length>0&&(n.style=o);var s;return hp(i)&&(s=bm(`generateAbstractTransformGrouping`,{main:r,transform:i,containerWidth:r.width,iconWidth:r.width})),t.push(s||r.icon),{children:t,attributes:n}}}},bh={mixout:function(){return{layer:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.classes,r=n===void 0?[]:n;return Tm({type:`layer`},function(){ym(`beforeDOMElementCreation`,{assembler:e,params:t});var n=[];return e(function(e){Array.isArray(e)?e.map(function(e){n=n.concat(e.abstract)}):n=n.concat(e.abstract)}),[{tag:`span`,attributes:{class:[`${J.cssPrefix}-layers`].concat(Fu(r)).join(` `)},children:n}]})}}}},xh={mixout:function(){return{counter:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.title,r=n===void 0?null:n,i=t.classes,a=i===void 0?[]:i,o=t.attributes,s=o===void 0?{}:o,c=t.styles,l=c===void 0?{}:c;return Tm({type:`counter`,content:e},function(){return ym(`beforeDOMElementCreation`,{content:e,params:t}),jm({content:e.toString(),title:r,extra:{attributes:s,styles:l,classes:[`${J.cssPrefix}-layers-counter`].concat(Fu(a))}})})}}}},Sh={mixout:function(){return{text:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?op:n,i=t.classes,a=i===void 0?[]:i,o=t.attributes,s=o===void 0?{}:o,c=t.styles,l=c===void 0?{}:c;return Tm({type:`text`,content:e},function(){return ym(`beforeDOMElementCreation`,{content:e,params:t}),Am({content:e,transform:q(q({},op),r),extra:{attributes:s,styles:l,classes:[`${J.cssPrefix}-layers-text`].concat(Fu(a))}})})}}},provides:function(e){e.generateLayersText=function(e,t){var n=t.transform,r=t.extra,i=null,a=null;if(Qu){var o=parseInt(getComputedStyle(e).fontSize,10),s=e.getBoundingClientRect();i=s.width/o,a=s.height/o}return Promise.resolve([e,Am({content:e.innerHTML,width:i,height:a,transform:n,extra:r,watchable:!0})])}}},Ch=RegExp(`"`,`ug`),wh=[1105920,1112319],Th=q(q(q(q({},{FontAwesome:{normal:`fas`,400:`fas`}}),tf),Cf),lf),Eh=Object.keys(Th).reduce(function(e,t){return e[t.toLowerCase()]=Th[t],e},{}),Dh=Object.keys(Eh).reduce(function(e,t){var n=Eh[t];return e[t]=n[900]||Fu(Object.entries(n))[0][1],e},{});function Oh(e){return Np(Fu(e.replace(Ch,``))[0]||``)}function kh(e){var t=e.getPropertyValue(`font-feature-settings`).includes(`ss01`),n=e.getPropertyValue(`content`).replace(Ch,``),r=n.codePointAt(0),i=r>=wh[0]&&r<=wh[1],a=n.length===2&&n[0]===n[1];return i||a||t}function Ah(e,t){var n=e.replace(/^['"]|['"]$/g,``).toLowerCase(),r=parseInt(t),i=isNaN(r)?`normal`:r;return(Eh[n]||{})[i]||Dh[n]}function jh(e,t){var n=`${Af}${t.replace(`:`,`-`)}`;return new Promise(function(r,i){if(e.getAttribute(n)!==null)return r();var a=up(e.children).filter(function(e){return e.getAttribute(kf)===t})[0],o=qu.getComputedStyle(e,t),s=o.getPropertyValue(`font-family`),c=s.match(Jf),l=o.getPropertyValue(`font-weight`),u=o.getPropertyValue(`content`);if(a&&!c)return e.removeChild(a),r();if(c&&u!==`none`&&u!==``){var d=o.getPropertyValue(`content`),f=Ah(s,l),p=Oh(d),m=c[0].startsWith(`FontAwesome`),h=kh(o),g=Yp(f,p),_=g;if(m){var v=$p(p);v.iconName&&v.prefix&&(g=v.iconName,f=v.prefix)}if(g&&!h&&(!a||a.getAttribute(jf)!==f||a.getAttribute(Mf)!==_)){e.setAttribute(n,_),a&&e.removeChild(a);var y=uh(),b=y.extra;b.attributes[kf]=t,Im(g,f).then(function(i){var a=km(q(q({},y),{},{icons:{main:i,mask:tm()},prefix:f,iconName:_,extra:b,watchable:!0})),o=Ju.createElementNS(`http://www.w3.org/2000/svg`,`svg`);t===`::before`?e.insertBefore(o,e.firstChild):e.appendChild(o),o.outerHTML=a.map(function(e){return kp(e)}).join(`
`),e.removeAttribute(n),r()}).catch(i)}else r()}else r()})}function Mh(e){return Promise.all([jh(e,`::before`),jh(e,`::after`)])}function Nh(e){return e.parentNode!==document.head&&!~Ff.indexOf(e.tagName.toUpperCase())&&!e.getAttribute(kf)&&(!e.parentNode||e.parentNode.tagName!==`svg`)}var Ph=function(e){return!!e&&If.some(function(t){return e.includes(t)})},Fh=function(e){if(!e)return[];var t=new Set,n=e.split(/,(?![^()]*\))/).map(function(e){return e.trim()});n=n.flatMap(function(e){return e.includes(`(`)?e:e.split(`,`).map(function(e){return e.trim()})});var r=Ou(n),i;try{for(r.s();!(i=r.n()).done;){var a=i.value;if(Ph(a)){var o=If.reduce(function(e,t){return e.replace(t,``)},a);o!==``&&o!==`*`&&t.add(o)}}}catch(e){r.e(e)}finally{r.f()}return t};function Ih(e){var t=arguments.length>1&&arguments[1]!==void 0&&arguments[1];if(Zu){var n;if(t)n=e;else if(J.searchPseudoElementsFullScan)n=e.querySelectorAll(`*`);else{var r=new Set,i=Ou(document.styleSheets),a;try{for(i.s();!(a=i.n()).done;){var o=a.value;try{var s=Ou(o.cssRules),c;try{for(s.s();!(c=s.n()).done;){var l=c.value,u=Ou(Fh(l.selectorText)),d;try{for(u.s();!(d=u.n()).done;){var f=d.value;r.add(f)}}catch(e){u.e(e)}finally{u.f()}}}catch(e){s.e(e)}finally{s.f()}}catch(e){J.searchPseudoElementsWarnings&&console.warn(`Font Awesome: cannot parse stylesheet: ${o.href} (${e.message})
If it declares any Font Awesome CSS pseudo-elements, they will not be rendered as SVG icons. Add crossorigin="anonymous" to the <link>, enable searchPseudoElementsFullScan for slower but more thorough DOM parsing, or suppress this warning by setting searchPseudoElementsWarnings to false.`)}}}catch(e){i.e(e)}finally{i.f()}if(!r.size)return;var p=Array.from(r).join(`, `);try{n=e.querySelectorAll(p)}catch{}}return new Promise(function(e,t){var r=up(n).filter(Nh).map(Mh),i=Hm.begin(`searchPseudoElements`);nh(),Promise.all(r).then(function(){i(),rh(),e()}).catch(function(){i(),rh(),t()})})}}var Lh={hooks:function(){return{mutationObserverCallbacks:function(e){return e.pseudoElementsCallback=Ih,e}}},provides:function(e){e.pseudoElements2svg=function(e){var t=e.node,n=t===void 0?Ju:t;J.searchPseudoElements&&Ih(n)}}},Rh=!1,zh={mixout:function(){return{dom:{unwatch:function(){nh(),Rh=!0}}}},hooks:function(){return{bootstrap:function(){ah(vm(`mutationObserverCallbacks`,{}))},noAuto:function(){oh()},watch:function(e){var t=e.observeMutationsRoot;Rh?rh():ah(vm(`mutationObserverCallbacks`,{observeMutationsRoot:t}))}}}},Bh=function(e){return e.toLowerCase().split(` `).reduce(function(e,t){var n=t.toLowerCase().split(`-`),r=n[0],i=n.slice(1).join(`-`);if(r&&i===`h`)return e.flipX=!0,e;if(r&&i===`v`)return e.flipY=!0,e;if(i=parseFloat(i),isNaN(i))return e;switch(r){case`grow`:e.size+=i;break;case`shrink`:e.size-=i;break;case`left`:e.x-=i;break;case`right`:e.x+=i;break;case`up`:e.y-=i;break;case`down`:e.y+=i;break;case`rotate`:e.rotate+=i}return e},{size:16,x:0,y:0,flipX:!1,flipY:!1,rotate:0})},Vh={mixout:function(){return{parse:{transform:function(e){return Bh(e)}}}},hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-transform`);return n&&(e.transform=Bh(n)),e}}},provides:function(e){e.generateAbstractTransformGrouping=function(e){var t=e.main,n=e.transform,r=e.containerWidth,i=e.iconWidth,a={outer:{transform:`translate(${r/2} 256)`},inner:{transform:`${`translate(${n.x*32}, ${n.y*32}) `} ${`scale(${n.size/16*(n.flipX?-1:1)}, ${n.size/16*(n.flipY?-1:1)}) `} ${`rotate(${n.rotate} 0 0)`}`},path:{transform:`translate(${i/2*-1} -256)`}};return{tag:`g`,attributes:q({},a.outer),children:[{tag:`g`,attributes:q({},a.inner),children:[{tag:t.icon.tag,children:t.icon.children,attributes:q(q({},t.icon.attributes),a.path)}]}]}}}},Hh={x:0,y:0,width:`100%`,height:`100%`};function Uh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return e.attributes&&(e.attributes.fill||t)&&(e.attributes.fill=`black`),e}function Wh(e){return e.tag===`g`?e.children:[e]}_m([Sp,yh,bh,xh,Sh,Lh,zh,Vh,{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-mask`),r=n?sm(n.split(` `).map(function(e){return e.trim()})):tm();return r.prefix||=em(),e.mask=r,e.maskId=t.getAttribute(`data-fa-mask-id`),e}}},provides:function(e){e.generateAbstractMask=function(e){var t=e.children,n=e.attributes,r=e.main,i=e.mask,a=e.maskId,o=e.transform,s=r.width,c=r.icon,l=i.width,u=i.icon,d=gp({transform:o,containerWidth:l,iconWidth:s}),f={tag:`rect`,attributes:q(q({},Hh),{},{fill:`white`})},p=c.children?{children:c.children.map(Uh)}:{},m={tag:`g`,attributes:q({},d.inner),children:[Uh(q({tag:c.tag,attributes:q(q({},c.attributes),d.path)},p))]},h={tag:`g`,attributes:q({},d.outer),children:[m]},g=`mask-${a||lp()}`,_=`clip-${a||lp()}`,v={tag:`mask`,attributes:q(q({},Hh),{},{id:g,maskUnits:`userSpaceOnUse`,maskContentUnits:`userSpaceOnUse`}),children:[f,h]},y={tag:`defs`,children:[{tag:`clipPath`,attributes:{id:_},children:Wh(u)},v]};return t.push(y,{tag:`rect`,attributes:q({fill:`currentColor`,"clip-path":`url(#${_})`,mask:`url(#${g})`},Hh)}),{children:t,attributes:n}}}},{provides:function(e){var t=!1;qu.matchMedia&&(t=qu.matchMedia(`(prefers-reduced-motion: reduce)`).matches),e.missingIconAbstract=function(){var e=[],n={fill:`currentColor`},r={attributeType:`XML`,repeatCount:`indefinite`,dur:`2s`};e.push({tag:`path`,attributes:q(q({},n),{},{d:`M156.5,447.7l-12.6,29.5c-18.7-9.5-35.9-21.2-51.5-34.9l22.7-22.7C127.6,430.5,141.5,440,156.5,447.7z M40.6,272H8.5 c1.4,21.2,5.4,41.7,11.7,61.1L50,321.2C45.1,305.5,41.8,289,40.6,272z M40.6,240c1.4-18.8,5.2-37,11.1-54.1l-29.5-12.6 C14.7,194.3,10,216.7,8.5,240H40.6z M64.3,156.5c7.8-14.9,17.2-28.8,28.1-41.5L69.7,92.3c-13.7,15.6-25.5,32.8-34.9,51.5 L64.3,156.5z M397,419.6c-13.9,12-29.4,22.3-46.1,30.4l11.9,29.8c20.7-9.9,39.8-22.6,56.9-37.6L397,419.6z M115,92.4 c13.9-12,29.4-22.3,46.1-30.4l-11.9-29.8c-20.7,9.9-39.8,22.6-56.8,37.6L115,92.4z M447.7,355.5c-7.8,14.9-17.2,28.8-28.1,41.5 l22.7,22.7c13.7-15.6,25.5-32.9,34.9-51.5L447.7,355.5z M471.4,272c-1.4,18.8-5.2,37-11.1,54.1l29.5,12.6 c7.5-21.1,12.2-43.5,13.6-66.8H471.4z M321.2,462c-15.7,5-32.2,8.2-49.2,9.4v32.1c21.2-1.4,41.7-5.4,61.1-11.7L321.2,462z M240,471.4c-18.8-1.4-37-5.2-54.1-11.1l-12.6,29.5c21.1,7.5,43.5,12.2,66.8,13.6V471.4z M462,190.8c5,15.7,8.2,32.2,9.4,49.2h32.1 c-1.4-21.2-5.4-41.7-11.7-61.1L462,190.8z M92.4,397c-12-13.9-22.3-29.4-30.4-46.1l-29.8,11.9c9.9,20.7,22.6,39.8,37.6,56.9 L92.4,397z M272,40.6c18.8,1.4,36.9,5.2,54.1,11.1l12.6-29.5C317.7,14.7,295.3,10,272,8.5V40.6z M190.8,50 c15.7-5,32.2-8.2,49.2-9.4V8.5c-21.2,1.4-41.7,5.4-61.1,11.7L190.8,50z M442.3,92.3L419.6,115c12,13.9,22.3,29.4,30.5,46.1 l29.8-11.9C470,128.5,457.3,109.4,442.3,92.3z M397,92.4l22.7-22.7c-15.6-13.7-32.8-25.5-51.5-34.9l-12.6,29.5 C370.4,72.1,384.4,81.5,397,92.4z`})});var i=q(q({},r),{},{attributeName:`opacity`}),a={tag:`circle`,attributes:q(q({},n),{},{cx:`256`,cy:`364`,r:`28`}),children:[]};return t||a.children.push({tag:`animate`,attributes:q(q({},r),{},{attributeName:`r`,values:`28;14;28;28;14;28;`})},{tag:`animate`,attributes:q(q({},i),{},{values:`1;0;1;1;0;1;`})}),e.push(a),e.push({tag:`path`,attributes:q(q({},n),{},{opacity:`1`,d:`M263.7,312h-16c-6.6,0-12-5.4-12-12c0-71,77.4-63.9,77.4-107.8c0-20-17.8-40.2-57.4-40.2c-29.1,0-44.3,9.6-59.2,28.7 c-3.9,5-11.1,6-16.2,2.4l-13.1-9.2c-5.6-3.9-6.9-11.8-2.6-17.2c21.2-27.2,46.4-44.7,91.2-44.7c52.3,0,97.4,29.8,97.4,80.2 c0,67.6-77.4,63.5-77.4,107.8C275.7,306.6,270.3,312,263.7,312z`}),children:t?[]:[{tag:`animate`,attributes:q(q({},i),{},{values:`1;0;0;0;0;1;`})}]}),t||e.push({tag:`path`,attributes:q(q({},n),{},{opacity:`0`,d:`M232.5,134.5l7,168c0.3,6.4,5.6,11.5,12,11.5h9c6.4,0,11.7-5.1,12-11.5l7-168c0.3-6.8-5.2-12.5-12-12.5h-23 C237.7,122,232.2,127.7,232.5,134.5z`}),children:[{tag:`animate`,attributes:q(q({},i),{},{values:`0;0;1;1;0;0;`})}]}),{tag:`g`,attributes:{class:`missing`},children:e}}}},{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-symbol`);return e.symbol=n===null?!1:n===``||n,e}}}}],{mixoutsTo:Cm}),Cm.noAuto,Cm.config,Cm.library,Cm.dom;var Gh=Cm.parse;Cm.findIconDefinition,Cm.toHtml;var Kh=Cm.icon;Cm.layer,Cm.text,Cm.counter;function qh(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function Jh(e){if(Array.isArray(e))return qh(e)}function Yh(e,t,n){return(t=ig(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function Xh(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function Zh(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Qh(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function $h(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Qh(Object(n),!0).forEach(function(t){Yh(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Qh(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function eg(e,t){if(e==null)return{};var n,r,i=tg(e,t);if(Object.getOwnPropertySymbols){var a=Object.getOwnPropertySymbols(e);for(r=0;r<a.length;r++)n=a[r],t.indexOf(n)===-1&&{}.propertyIsEnumerable.call(e,n)&&(i[n]=e[n])}return i}function tg(e,t){if(e==null)return{};var n={};for(var r in e)if({}.hasOwnProperty.call(e,r)){if(t.indexOf(r)!==-1)continue;n[r]=e[r]}return n}function ng(e){return Jh(e)||Xh(e)||og(e)||Zh()}function rg(e,t){if(typeof e!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(typeof r!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function ig(e){var t=rg(e,`string`);return typeof t==`symbol`?t:t+``}function ag(e){"@babel/helpers - typeof";return ag=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},ag(e)}function og(e,t){if(e){if(typeof e==`string`)return qh(e,t);var n={}.toString.call(e).slice(8,-1);return n===`Object`&&e.constructor&&(n=e.constructor.name),n===`Map`||n===`Set`?Array.from(e):n===`Arguments`||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?qh(e,t):void 0}}function sg(e,t){return Array.isArray(t)&&t.length>0||!Array.isArray(t)&&t?Yh({},e,t):{}}function cg(e){var t,n=(t={"fa-spin":e.spin,"fa-pulse":e.pulse,"fa-fw":e.fixedWidth,"fa-border":e.border,"fa-li":e.listItem,"fa-inverse":e.inverse,"fa-flip":e.flip===!0,"fa-flip-horizontal":e.flip===`horizontal`||e.flip===`both`,"fa-flip-vertical":e.flip===`vertical`||e.flip===`both`},Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(t,`fa-${e.size}`,e.size!==null),`fa-rotate-${e.rotation}`,e.rotation!==null),`fa-rotate-by`,e.rotateBy),`fa-pull-${e.pull}`,e.pull!==null),`fa-swap-opacity`,e.swapOpacity),`fa-bounce`,e.bounce),`fa-shake`,e.shake),`fa-beat`,e.beat),`fa-fade`,e.fade),`fa-beat-fade`,e.beatFade),Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(t,`fa-flash`,e.flash),`fa-spin-pulse`,e.spinPulse),`fa-spin-reverse`,e.spinReverse),`fa-width-auto`,e.widthAuto),`fa-canvas-square`,e.canvasSquare),`fa-canvas-roomy`,e.canvasRoomy),`fa-flip-360`,e.flip360),`fa-buzz`,e.buzz),`fa-float`,e.float),`fa-jello`,e.jello),Yh(Yh(Yh(Yh(Yh(t,`fa-spin-snap`,e.spinSnap),`fa-spin-snap-4`,e.spinSnap4),`fa-spin-snap-8`,e.spinSnap8),`fa-swing`,e.swing),`fa-wag`,e.wag));return Object.keys(n).map(function(e){return n[e]?e:null}).filter(function(e){return e})}var lg=typeof globalThis<`u`?globalThis:typeof window<`u`?window:typeof global<`u`?global:typeof self<`u`?self:{},ug={exports:{}};(function(e){(function(t){var n=function(e,t,r){if(!l(t)||d(t)||f(t)||p(t)||c(t))return t;var i,a=0,o=0;if(u(t))for(i=[],o=t.length;a<o;a++)i.push(n(e,t[a],r));else for(var s in i={},t)Object.prototype.hasOwnProperty.call(t,s)&&(i[e(s,r)]=n(e,t[s],r));return i},r=function(e,t){t||={};var n=t.separator||`_`,r=t.split||/(?=[A-Z])/;return e.split(r).join(n)},i=function(e){return m(e)?e:(e=e.replace(/[\-_\s]+(.)?/g,function(e,t){return t?t.toUpperCase():``}),e.substr(0,1).toLowerCase()+e.substr(1))},a=function(e){var t=i(e);return t.substr(0,1).toUpperCase()+t.substr(1)},o=function(e,t){return r(e,t).toLowerCase()},s=Object.prototype.toString,c=function(e){return typeof e==`function`},l=function(e){return e===Object(e)},u=function(e){return s.call(e)==`[object Array]`},d=function(e){return s.call(e)==`[object Date]`},f=function(e){return s.call(e)==`[object RegExp]`},p=function(e){return s.call(e)==`[object Boolean]`},m=function(e){return e-=0,e===e},h=function(e,t){var n=t&&`process`in t?t.process:t;return typeof n==`function`?function(t,r){return n(t,e,r)}:e},g={camelize:i,decamelize:o,pascalize:a,depascalize:o,camelizeKeys:function(e,t){return n(h(i,t),e)},decamelizeKeys:function(e,t){return n(h(o,t),e,t)},pascalizeKeys:function(e,t){return n(h(a,t),e)},depascalizeKeys:function(){return this.decamelizeKeys.apply(this,arguments)}};e.exports?e.exports=g:t.humps=g})(lg)})(ug);var dg=ug.exports,fg=[`gradientFill`],pg=[`class`,`style`],mg=[`type`,`stops`,`id`];function hg(e){return e.split(`;`).map(function(e){return e.trim()}).filter(function(e){return e}).reduce(function(e,t){var n=t.indexOf(`:`),r=dg.camelize(t.slice(0,n));return e[r]=t.slice(n+1).trim(),e},{})}function gg(e){return e.split(/\s+/).reduce(function(e,t){return e[t]=!0,e},{})}function _g(e,t){return G(`stop`,$h({key:`${t}-${e.offset}`,offset:e.offset,"stop-color":e.color},e.opacity!==void 0&&{"stop-opacity":e.opacity}))}function vg(e){if(typeof e==`string`)return e;var t=(e.children||[]).map(vg);return e.tag===`path`&&e.attributes&&`fill`in e.attributes?$h($h({},e),{},{attributes:$h($h({},e.attributes),{},{fill:void 0}),children:t}):$h($h({},e),{},{children:t})}function yg(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{};if(typeof e==`string`)return e;var r=t.gradientFill,i=r===void 0?null:r,a=eg(t,fg),o=i||`fill`in n?vg(e):e,s=(o.children||[]).map(function(e){return yg(e,{},{})}),c=Object.keys(o.attributes||{}).reduce(function(e,t){var n=o.attributes[t];switch(t){case`class`:e.class=gg(n);break;case`style`:e.style=hg(n);break;default:e.attrs[t]=n}return e},{attrs:{},class:{},style:{}});n.class;var l=n.style,u=l===void 0?{}:l,d=eg(n,pg);if(i&&i.id&&(i.type===`linear`||i.type===`radial`)){var f=i.type,p=i.stops,m=p===void 0?[]:p,h=i.id,g=eg(i,mg),_=G(f===`linear`?`linearGradient`:`radialGradient`,$h($h({},g),{},{id:h}),m.map(_g));return G(o.tag,$h($h($h($h({},a),{},{class:c.class,style:$h($h({},c.style),u)},c.attrs),d),{},{fill:`url(#${h})`}),[_].concat(ng(s)))}return G(e.tag,$h($h($h({},a),{},{class:c.class,style:$h($h({},c.style),u)},c.attrs),d),s)}var bg=!1;try{bg=!0}catch{}function xg(){if(!bg&&console&&typeof console.error==`function`){var e;(e=console).error.apply(e,arguments)}}function Sg(e){if(e&&ag(e)===`object`&&e.prefix&&e.iconName&&e.icon)return e;if(Gh.icon)return Gh.icon(e);if(e===null)return null;if(ag(e)===`object`&&e.prefix&&e.iconName)return e;if(Array.isArray(e)&&e.length===2)return{prefix:e[0],iconName:e[1]};if(typeof e==`string`)return{prefix:`fas`,iconName:e}}var Cg=F({name:`FontAwesomeIcon`,props:{border:{type:Boolean,default:!1},fixedWidth:{type:Boolean,default:!1},flip:{type:[Boolean,String],default:!1,validator:function(e){return[!0,!1,`horizontal`,`vertical`,`both`].indexOf(e)>-1}},icon:{type:[Object,Array,String],required:!0},mask:{type:[Object,Array,String],default:null},maskId:{type:String,default:null},listItem:{type:Boolean,default:!1},pull:{type:String,default:null,validator:function(e){return[`right`,`left`].indexOf(e)>-1}},pulse:{type:Boolean,default:!1},rotation:{type:[String,Number],default:null,validator:function(e){return[90,180,270].indexOf(Number.parseInt(e,10))>-1}},rotateBy:{type:Boolean,default:!1},swapOpacity:{type:Boolean,default:!1},size:{type:String,default:null,validator:function(e){return[`2xs`,`xs`,`sm`,`lg`,`xl`,`2xl`,`1x`,`2x`,`3x`,`4x`,`5x`,`6x`,`7x`,`8x`,`9x`,`10x`].indexOf(e)>-1}},spin:{type:Boolean,default:!1},transform:{type:[String,Object],default:null},symbol:{type:[Boolean,String],default:!1},title:{type:String,default:null},titleId:{type:String,default:null},inverse:{type:Boolean,default:!1},bounce:{type:Boolean,default:!1},shake:{type:Boolean,default:!1},beat:{type:Boolean,default:!1},fade:{type:Boolean,default:!1},beatFade:{type:Boolean,default:!1},flash:{type:Boolean,default:!1},spinPulse:{type:Boolean,default:!1},spinReverse:{type:Boolean,default:!1},widthAuto:{type:Boolean,default:!1},canvasSquare:{type:Boolean,default:!1},canvasRoomy:{type:Boolean,default:!1},gradientFill:{type:Object,default:null,validator:function(e){return typeof e.id!=`string`||!e.id?(console.warn(`FontAwesomeIcon: gradientFill.id must be a non-empty string`),!1):e.type!==`linear`&&e.type!==`radial`?(console.warn(`FontAwesomeIcon: gradientFill.type must be "linear" or "radial"`),!1):!0}},flip360:{type:Boolean,default:!1},buzz:{type:Boolean,default:!1},float:{type:Boolean,default:!1},jello:{type:Boolean,default:!1},spinSnap:{type:Boolean,default:!1},spinSnap4:{type:Boolean,default:!1},spinSnap8:{type:Boolean,default:!1},swing:{type:Boolean,default:!1},wag:{type:Boolean,default:!1}},setup:function(e,t){var n=t.attrs,r=W(function(){return Sg(e.icon)}),i=W(function(){return sg(`classes`,cg(e))}),a=W(function(){return sg(`transform`,typeof e.transform==`string`?Gh.transform(e.transform):e.transform)}),o=W(function(){return sg(`mask`,Sg(e.mask))}),s=W(function(){var t=$h($h($h($h({},i.value),a.value),o.value),{},{symbol:e.symbol,maskId:e.maskId});return t.title=e.title,t.titleId=e.titleId,Kh(r.value,t)});Er(s,function(e){if(!e)return xg(`Could not find one or more icon(s)`,r.value,o.value)},{immediate:!0}),e.gradientFill&&e.symbol&&xg(`gradientFill is not supported when symbol is true and will be ignored`);var c=W(function(){return s.value?yg(s.value.abstract[0],{gradientFill:e.symbol?null:e.gradientFill},n):null});return function(){return c.value}}}),wg=typeof window<`u`,Tg,Eg=e=>Tg=e,Dg=Symbol();function Og(e){return e&&typeof e==`object`&&Object.prototype.toString.call(e)===`[object Object]`&&typeof e.toJSON!=`function`}var kg=typeof window==`object`&&window.window===window?window:typeof self==`object`&&self.self===self?self:typeof global==`object`&&global.global===global?global:typeof globalThis==`object`?globalThis:{HTMLElement:null};function Ag(e,{autoBom:t=!1}={}){return t&&/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(e.type)?new Blob([`﻿`,e],{type:e.type}):e}function jg(e,t,n){let r=new XMLHttpRequest;r.open(`GET`,e),r.responseType=`blob`,r.onload=function(){Ig(r.response,t,n)},r.onerror=function(){console.error(`could not download file`)},r.send()}function Mg(e){let t=new XMLHttpRequest;t.open(`HEAD`,e,!1);try{t.send()}catch{}return t.status>=200&&t.status<=299}function Ng(e){try{e.dispatchEvent(new MouseEvent(`click`))}catch{let t=new MouseEvent(`click`,{bubbles:!0,cancelable:!0,view:window,detail:0,screenX:80,screenY:20,clientX:80,clientY:20,ctrlKey:!1,altKey:!1,shiftKey:!1,metaKey:!1,button:0,relatedTarget:null});e.dispatchEvent(t)}}var Pg=typeof navigator==`object`?navigator:{userAgent:``},Fg=/Macintosh/.test(Pg.userAgent)&&/AppleWebKit/.test(Pg.userAgent)&&!/Safari/.test(Pg.userAgent),Ig=wg?typeof HTMLAnchorElement<`u`&&`download`in HTMLAnchorElement.prototype&&!Fg?Lg:`msSaveOrOpenBlob`in Pg?Rg:zg:()=>{};function Lg(e,t=`download`,n){let r=document.createElement(`a`);r.download=t,r.rel=`noopener`,typeof e==`string`?(r.href=e,r.origin===location.origin?Ng(r):Mg(r.href)?jg(e,t,n):(r.target=`_blank`,Ng(r))):(r.href=URL.createObjectURL(e),setTimeout(function(){URL.revokeObjectURL(r.href)},4e4),setTimeout(function(){Ng(r)},0))}function Rg(e,t=`download`,n){if(typeof e==`string`){if(Mg(e))jg(e,t,n);else{let t=document.createElement(`a`);t.href=e,t.target=`_blank`,setTimeout(function(){Ng(t)})}}else navigator.msSaveOrOpenBlob(Ag(e,n),t)}function zg(e,t,n,r){if(r||=open(``,`_blank`),r&&(r.document.title=r.document.body.innerText=`downloading...`),typeof e==`string`)return jg(e,t,n);let i=e.type===`application/octet-stream`,a=/constructor/i.test(String(kg.HTMLElement))||`safari`in kg,o=/CriOS\/[\d]+/.test(navigator.userAgent);if((o||i&&a||Fg)&&typeof FileReader<`u`){let t=new FileReader;t.onloadend=function(){let e=t.result;if(typeof e!=`string`)throw r=null,Error(`Wrong reader.result type`);e=o?e:e.replace(/^data:[^;]*;/,`data:attachment/file;`),r?r.location.href=e:location.assign(e),r=null},t.readAsDataURL(e)}else{let t=URL.createObjectURL(e);r?r.location.assign(t):location.href=t,r=null,setTimeout(function(){URL.revokeObjectURL(t)},4e4)}}var{assign:Bg}=Object;function Vg(){let e=Pe(!0),t=e.run(()=>M({})),n=[],r=[],i=sn({install(e){Eg(i),i._a=e,e.provide(Dg,i),e.config.globalProperties.$pinia=i,r.forEach(e=>n.push(e)),r=[]},use(e){return this._a?n.push(e):r.push(e),this},_p:n,_a:null,_e:e,_s:new Map,state:t});return i}var Hg=()=>{};function Ug(e,t,n,r=Hg){e.add(t);let i=()=>{e.delete(t)&&r()};return!n&&Fe()&&Ie(i),i}function Wg(e,...t){e.forEach(e=>{e(...t)})}var Gg=e=>e(),Kg=Symbol(),qg=Symbol();function Jg(e,t){e instanceof Map&&t instanceof Map?t.forEach((t,n)=>e.set(n,t)):e instanceof Set&&t instanceof Set&&t.forEach(e.add,e);for(let n in t){if(!Object.hasOwn(t,n))continue;let r=t[n],i=e[n];e[n]=Og(i)&&Og(r)&&Object.hasOwn(e,n)&&!j(r)&&!nn(r)?Jg(i,r):r}return e}var Yg=Symbol();function Xg(e){return!e||typeof e!=`object`||!Object.hasOwn(e,Yg)}var{assign:Zg}=Object;function Qg(e){return!!(j(e)&&e.effect)}function $g(e,t,n,r){let{state:i,actions:a,getters:o}=t,s=n.state.value[e],c;function l(){return s||(n.state.value[e]=i?i():{}),Zg(yn(n.state.value[e]),a,Object.keys(o||{}).reduce((t,r)=>(t[r]=sn(W(()=>{Eg(n);let t=n._s.get(e);return o[r].call(t,t)})),t),{}))}return c=e_(e,l,t,n,r,!0),c}function e_(e,t,n={},r,i,a){let o,s=Zg({actions:{}},n),c={deep:!0},l,u,d=new Set,f=new Set,p,m=r.state.value[e];!a&&!m&&(r.state.value[e]={});let h;function g(t){let n;l=u=!1,typeof t==`function`?(t(r.state.value[e]),n={type:`patch function`,storeId:e,events:p}):(Jg(r.state.value[e],t),n={type:`patch object`,payload:t,storeId:e,events:p});let i=h=Symbol();Qn().then(()=>{h===i&&(l=!0)}),u=!0,Wg(d,n,r.state.value[e])}let _=a?function(){let{state:e}=n,t=e?e():{};this.$patch(e=>{Zg(e,t)})}:Hg;function v(){o.stop(),d.clear(),f.clear(),r._s.delete(e)}let y=(t,n=``)=>{if(Kg in t)return t[qg]=n,t;let i=function(){Eg(r);let n=Array.from(arguments),a=new Set,o=new Set;function s(e){a.add(e)}function c(e){o.add(e)}Wg(f,{args:n,name:i[qg],store:b,after:s,onError:c});let l;try{l=t.apply(this&&this.$id===e?this:b,n)}catch(e){throw Wg(o,e),e}return l instanceof Promise?l.then(e=>(Wg(a,e),e)).catch(e=>(Wg(o,e),Promise.reject(e))):(Wg(a,l),l)};return i[Kg]=!0,i[qg]=n,i},b=Zt({_p:r,$id:e,$onAction:Ug.bind(null,f),$patch:g,$reset:_,$subscribe(t,n={}){if(d.has(t))return Hg;let i=Ug(d,t,n.detached,()=>a()),a=o.run(()=>Er(()=>r.state.value[e],r=>{(n.flush===`sync`?u:l)&&t({storeId:e,type:`direct`,events:p},r)},Zg({},c,n)));return i},$dispose:v});r._s.set(e,b);let x=(r._a&&r._a.runWithContext||Gg)(()=>r._e.run(()=>(o=Pe()).run(()=>t({action:y}))));for(let t in x){let n=x[t];j(n)&&!Qg(n)||nn(n)?a||(m&&Xg(n)&&(j(n)?n.value=m[t]:((n instanceof Set||n instanceof Map)&&n.clear(),Jg(n,m[t]))),r.state.value[e][t]=n):typeof n==`function`&&(x[t]=y(n,t),s.actions[t]=n)}return Zg(b,x),Zg(A(b),x),Object.defineProperty(b,"$state",{get:()=>r.state.value[e],set:e=>{g(t=>{Zg(t,e)})}}),r._p.forEach(e=>{let t=o.run(()=>e({store:b,app:r._a,pinia:r,options:s}));Zg(b,t)}),m&&a&&n.hydrate&&n.hydrate(b.$state,m),l=!0,u=!0,b}function t_(e,t,n){let r,i=typeof t==`function`;r=i?n:t;function a(n,a){let o=br();return n||=o?yr(Dg,null):null,n&&Eg(n),n=Tg,n._s.has(e)||(i?e_(e,t,r,n):$g(e,r,n)),n._s.get(e)}return a.$id=e,a}var n_={prefix:`fab`,iconName:`github`,icon:[512,512,[],`f09b`,`M216.5 362.5c-66-8-112.5-55.5-112.5-117 0-25 9-52 24-70-6.5-16.5-5.5-51.5 2-66 20-2.5 47 8 63 22.5 19-6 39-9 63.5-9s44.5 3 62.5 8.5c15.5-14 43-24.5 63-22 7 13.5 8 48.5 1.5 65.5 16 19 24.5 44.5 24.5 70.5 0 61.5-46.5 108-113.5 116.5 17 11 28.5 35 28.5 62.5l0 52C323 491.5 335.5 500 350.5 494 441 459.5 512 369 512 257 512 115.5 397 0 255.5 0S0 115.5 0 257c0 111 70.5 203 165.5 237.5 13.5 5 26.5-4 26.5-17.5l0-40c-7 3-16 5-24 5-33 0-52.5-18-66.5-51.5-5.5-13.5-11.5-21.5-23-23-6-.5-8-3-8-6 0-6 10-10.5 20-10.5 14.5 0 27 9 40 27.5 10 14.5 20.5 21 33 21s20.5-4.5 32-16c8.5-8.5 15-16 21-21z`]},r_={prefix:`fas`,iconName:`magnifying-glass`,icon:[512,512,[128269,`search`],`f002`,`M416 208c0 45.9-14.9 88.3-40 122.7L502.6 457.4c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L330.7 376C296.3 401.1 253.9 416 208 416 93.1 416 0 322.9 0 208S93.1 0 208 0 416 93.1 416 208zM208 352a144 144 0 1 0 0-288 144 144 0 1 0 0 288z`]},i_={prefix:`fas`,iconName:`key`,icon:[512,512,[128273],`f084`,`M336 352c97.2 0 176-78.8 176-176S433.2 0 336 0 160 78.8 160 176c0 18.7 2.9 36.8 8.3 53.7L7 391c-4.5 4.5-7 10.6-7 17l0 80c0 13.3 10.7 24 24 24l80 0c13.3 0 24-10.7 24-24l0-40 40 0c13.3 0 24-10.7 24-24l0-40 40 0c6.4 0 12.5-2.5 17-7l33.3-33.3c16.9 5.4 35 8.3 53.7 8.3zM376 96a40 40 0 1 1 0 80 40 40 0 1 1 0-80z`]},a_={prefix:`fas`,iconName:`sort-up`,icon:[384,512,[`sort-asc`],`f0de`,`M32 224c-12.9 0-24.6-7.8-29.6-19.8S.2 178.5 9.4 169.4l160-160c12.5-12.5 32.8-12.5 45.3 0l160 160c9.2 9.2 11.9 22.9 6.9 34.9S364.9 224 352 224L32 224z`]},o_={prefix:`fas`,iconName:`eye`,icon:[576,512,[128065],`f06e`,`M288 32c-80.8 0-145.5 36.8-192.6 80.6-46.8 43.5-78.1 95.4-93 131.1-3.3 7.9-3.3 16.7 0 24.6 14.9 35.7 46.2 87.7 93 131.1 47.1 43.7 111.8 80.6 192.6 80.6s145.5-36.8 192.6-80.6c46.8-43.5 78.1-95.4 93-131.1 3.3-7.9 3.3-16.7 0-24.6-14.9-35.7-46.2-87.7-93-131.1-47.1-43.7-111.8-80.6-192.6-80.6zM144 256a144 144 0 1 1 288 0 144 144 0 1 1 -288 0zm144-64c0 35.3-28.7 64-64 64-11.5 0-22.3-3-31.7-8.4-1 10.9-.1 22.1 2.9 33.2 13.7 51.2 66.4 81.6 117.6 67.9s81.6-66.4 67.9-117.6c-12.2-45.7-55.5-74.8-101.1-70.8 5.3 9.3 8.4 20.1 8.4 31.7z`]},s_={prefix:`fas`,iconName:`chevron-up`,icon:[448,512,[],`f077`,`M201.4 105.4c12.5-12.5 32.8-12.5 45.3 0l192 192c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L224 173.3 54.6 342.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l192-192z`]},c_={prefix:`fas`,iconName:`circle-xmark`,icon:[512,512,[61532,`times-circle`,`xmark-circle`],`f057`,`M256 512a256 256 0 1 0 0-512 256 256 0 1 0 0 512zM167 167c9.4-9.4 24.6-9.4 33.9 0l55 55 55-55c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9l-55 55 55 55c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0l-55-55-55 55c-9.4 9.4-24.6 9.4-33.9 0s-9.4-24.6 0-33.9l55-55-55-55c-9.4-9.4-9.4-24.6 0-33.9z`]},l_={prefix:`fas`,iconName:`circle-exclamation`,icon:[512,512,[`exclamation-circle`],`f06a`,`M256 512a256 256 0 1 1 0-512 256 256 0 1 1 0 512zm0-192a32 32 0 1 0 0 64 32 32 0 1 0 0-64zm0-192c-18.2 0-32.7 15.5-31.4 33.7l7.4 104c.9 12.6 11.4 22.3 23.9 22.3 12.6 0 23-9.7 23.9-22.3l7.4-104c1.3-18.2-13.1-33.7-31.4-33.7z`]},u_={prefix:`fas`,iconName:`check`,icon:[448,512,[10003,10004],`f00c`,`M434.8 70.1c14.3 10.4 17.5 30.4 7.1 44.7l-256 352c-5.5 7.6-14 12.3-23.4 13.1s-18.5-2.7-25.1-9.3l-128-128c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0l101.5 101.5 234-321.7c10.4-14.3 30.4-17.5 44.7-7.1z`]},d_={prefix:`fas`,iconName:`sort`,icon:[384,512,[`unsorted`],`f0dc`,`M2.4 204.2c5 12 16.6 19.8 29.6 19.8l320 0c12.9 0 24.6-7.8 29.6-19.8s2.2-25.7-6.9-34.9l-160-160c-12.5-12.5-32.8-12.5-45.3 0l-160 160c-9.2 9.2-11.9 22.9-6.9 34.9zm0 103.5c-5 12-2.2 25.7 6.9 34.9l160 160c12.5 12.5 32.8 12.5 45.3 0l160-160c9.2-9.2 11.9-22.9 6.9-34.9S364.9 288 352 288L32 288c-12.9 0-24.6 7.8-29.6 19.8z`]},f_={prefix:`fas`,iconName:`xmark`,icon:[384,512,[128473,10005,10006,10060,215,`close`,`multiply`,`remove`,`times`],`f00d`,`M55.1 73.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3L147.2 256 9.9 393.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0L192.5 301.3 329.9 438.6c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L237.8 256 375.1 118.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L192.5 210.7 55.1 73.4z`]},p_={prefix:`fas`,iconName:`circle-check`,icon:[512,512,[61533,`check-circle`],`f058`,`M256 512a256 256 0 1 1 0-512 256 256 0 1 1 0 512zM374 145.7c-10.7-7.8-25.7-5.4-33.5 5.3L221.1 315.2 169 263.1c-9.4-9.4-24.6-9.4-33.9 0s-9.4 24.6 0 33.9l72 72c5 5 11.8 7.5 18.8 7s13.4-4.1 17.5-9.8L379.3 179.2c7.8-10.7 5.4-25.7-5.3-33.5z`]},m_={prefix:`fas`,iconName:`chevron-down`,icon:[448,512,[],`f078`,`M201.4 406.6c12.5 12.5 32.8 12.5 45.3 0l192-192c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 338.7 54.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l192 192z`]},h_={prefix:`fas`,iconName:`triangle-exclamation`,icon:[512,512,[9888,`exclamation-triangle`,`warning`],`f071`,`M256 0c14.7 0 28.2 8.1 35.2 21l216 400c6.7 12.4 6.4 27.4-.8 39.5S486.1 480 472 480L40 480c-14.1 0-27.2-7.4-34.4-19.5s-7.5-27.1-.8-39.5l216-400c7-12.9 20.5-21 35.2-21zm0 352a32 32 0 1 0 0 64 32 32 0 1 0 0-64zm0-192c-18.2 0-32.7 15.5-31.4 33.7l7.4 104c.9 12.5 11.4 22.3 23.9 22.3 12.6 0 23-9.7 23.9-22.3l7.4-104c1.3-18.2-13.1-33.7-31.4-33.7z`]},g_={prefix:`fas`,iconName:`copy`,icon:[448,512,[],`f0c5`,`M192 0c-35.3 0-64 28.7-64 64l0 256c0 35.3 28.7 64 64 64l192 0c35.3 0 64-28.7 64-64l0-200.6c0-17.4-7.1-34.1-19.7-46.2L370.6 17.8C358.7 6.4 342.8 0 326.3 0L192 0zM64 128c-35.3 0-64 28.7-64 64L0 448c0 35.3 28.7 64 64 64l192 0c35.3 0 64-28.7 64-64l0-16-64 0 0 16-192 0 0-256 16 0 0-64-16 0z`]},__={prefix:`fas`,iconName:`eye-slash`,icon:[576,512,[],`f070`,`M41-24.9c-9.4-9.4-24.6-9.4-33.9 0S-2.3-.3 7 9.1l528 528c9.4 9.4 24.6 9.4 33.9 0s9.4-24.6 0-33.9l-96.4-96.4c2.7-2.4 5.4-4.8 8-7.2 46.8-43.5 78.1-95.4 93-131.1 3.3-7.9 3.3-16.7 0-24.6-14.9-35.7-46.2-87.7-93-131.1-47.1-43.7-111.8-80.6-192.6-80.6-56.8 0-105.6 18.2-146 44.2L41-24.9zM204.5 138.7c23.5-16.8 52.4-26.7 83.5-26.7 79.5 0 144 64.5 144 144 0 31.1-9.9 59.9-26.7 83.5l-34.7-34.7c12.7-21.4 17-47.7 10.1-73.7-13.7-51.2-66.4-81.6-117.6-67.9-8.6 2.3-16.7 5.7-24 10l-34.7-34.7zM325.3 395.1c-11.9 3.2-24.4 4.9-37.3 4.9-79.5 0-144-64.5-144-144 0-12.9 1.7-25.4 4.9-37.3L69.4 139.2c-32.6 36.8-55 75.8-66.9 104.5-3.3 7.9-3.3 16.7 0 24.6 14.9 35.7 46.2 87.7 93 131.1 47.1 43.7 111.8 80.6 192.6 80.6 37.3 0 71.2-7.9 101.5-20.6l-64.2-64.2z`]},v_={prefix:`fas`,iconName:`sort-down`,icon:[384,512,[`sort-desc`],`f0dd`,`M32 288c-12.9 0-24.6 7.8-29.6 19.8S.2 333.5 9.4 342.6l160 160c12.5 12.5 32.8 12.5 45.3 0l160-160c9.2-9.2 11.9-22.9 6.9-34.9S364.9 288 352 288L32 288z`]};function y_(e){var t,n,r=``;if(typeof e==`string`||typeof e==`number`)r+=e;else if(typeof e==`object`){if(Array.isArray(e)){var i=e.length;for(t=0;t<i;t++)e[t]&&(n=y_(e[t]))&&(r&&(r+=` `),r+=n)}else for(n in e)e[n]&&(r&&(r+=` `),r+=n)}return r}function b_(){for(var e,t,n=0,r=``,i=arguments.length;n<i;n++)(e=arguments[n])&&(t=y_(e))&&(r&&(r+=` `),r+=t);return r}var x_=e=>typeof e==`boolean`?`${e}`:e===0?`0`:e,S_=b_,C_=(e,t)=>n=>{if(t?.variants==null)return S_(e,n?.class,n?.className);let{variants:r,defaultVariants:i}=t,a=Object.keys(r).map(e=>{let t=n?.[e],a=i?.[e];if(t===null)return null;let o=x_(t)||x_(a);return r[e][o]}),o=n&&Object.entries(n).reduce((e,t)=>{let[n,r]=t;return r===void 0||(e[n]=r),e},{});return S_(e,a,t?.compoundVariants?.reduce((e,t)=>{let{class:n,className:r,...a}=t;return Object.entries(a).every(e=>{let[t,n]=e;return Array.isArray(n)?n.includes({...i,...o}[t]):{...i,...o}[t]===n})?[...e,n,r]:e},[]),n?.class,n?.className)},w_=(e,t)=>{let n=Array(e.length+t.length);for(let t=0;t<e.length;t++)n[t]=e[t];for(let r=0;r<t.length;r++)n[e.length+r]=t[r];return n},T_=(e,t)=>({classGroupId:e,validator:t}),E_=(e=new Map,t=null,n)=>({nextPart:e,validators:t,classGroupId:n}),D_=`-`,O_=[],k_=`arbitrary..`,A_=e=>{let t=N_(e),{conflictingClassGroups:n,conflictingClassGroupModifiers:r}=e;return{getClassGroupId:e=>{if(e.startsWith(`[`)&&e.endsWith(`]`))return M_(e);let n=e.split(D_);return j_(n,+(n[0]===``&&n.length>1),t)},getConflictingClassGroupIds:(e,t)=>{if(t){let t=r[e],i=n[e];return t?i?w_(i,t):t:i||O_}return n[e]||O_}}},j_=(e,t,n)=>{if(e.length-t===0)return n.classGroupId;let r=e[t],i=n.nextPart.get(r);if(i){let n=j_(e,t+1,i);if(n)return n}let a=n.validators;if(a===null)return;let o=t===0?e.join(D_):e.slice(t).join(D_),s=a.length;for(let e=0;e<s;e++){let t=a[e];if(t.validator(o))return t.classGroupId}},M_=e=>e.slice(1,-1).indexOf(`:`)===-1?void 0:(()=>{let t=e.slice(1,-1),n=t.indexOf(`:`),r=t.slice(0,n);return r?k_+r:void 0})(),N_=e=>{let{theme:t,classGroups:n}=e;return P_(n,t)},P_=(e,t)=>{let n=E_();for(let r in e){let i=e[r];F_(i,n,r,t)}return n},F_=(e,t,n,r)=>{let i=e.length;for(let a=0;a<i;a++){let i=e[a];I_(i,t,n,r)}},I_=(e,t,n,r)=>{if(typeof e==`string`){L_(e,t,n);return}if(typeof e==`function`){R_(e,t,n,r);return}z_(e,t,n,r)},L_=(e,t,n)=>{let r=e===``?t:B_(t,e);r.classGroupId=n},R_=(e,t,n,r)=>{if(V_(e)){F_(e(r),t,n,r);return}t.validators===null&&(t.validators=[]),t.validators.push(T_(n,e))},z_=(e,t,n,r)=>{let i=Object.entries(e),a=i.length;for(let e=0;e<a;e++){let[a,o]=i[e];F_(o,B_(t,a),n,r)}},B_=(e,t)=>{let n=e,r=t.split(D_),i=r.length;for(let e=0;e<i;e++){let t=r[e],i=n.nextPart.get(t);i||(i=E_(),n.nextPart.set(t,i)),n=i}return n},V_=e=>`isThemeGetter`in e&&e.isThemeGetter===!0,H_=e=>{if(e<1)return{get:()=>void 0,set:()=>{}};let t=0,n=Object.create(null),r=Object.create(null),i=(i,a)=>{n[i]=a,t++,t>e&&(t=0,r=n,n=Object.create(null))};return{get(e){let t=n[e];if(t!==void 0)return t;if((t=r[e])!==void 0)return i(e,t),t},set(e,t){e in n?n[e]=t:i(e,t)}}},U_=`!`,W_=`:`,G_=[],K_=(e,t,n,r,i)=>({modifiers:e,hasImportantModifier:t,baseClassName:n,maybePostfixModifierPosition:r,isExternal:i}),q_=e=>{let{prefix:t,experimentalParseClassName:n}=e,r=e=>{let t=[],n=0,r=0,i=0,a,o=e.length;for(let s=0;s<o;s++){let o=e[s];if(n===0&&r===0){if(o===W_){t.push(e.slice(i,s)),i=s+1;continue}if(o===`/`){a=s;continue}}o===`[`?n++:o===`]`?n--:o===`(`?r++:o===`)`&&r--}let s=t.length===0?e:e.slice(i),c=s,l=!1;s.endsWith(U_)?(c=s.slice(0,-1),l=!0):s.startsWith(U_)&&(c=s.slice(1),l=!0);let u=a&&a>i?a-i:void 0;return K_(t,l,c,u)};if(t){let e=t+W_,n=r;r=t=>t.startsWith(e)?n(t.slice(e.length)):K_(G_,!1,t,void 0,!0)}if(n){let e=r;r=t=>n({className:t,parseClassName:e})}return r},J_=e=>{let t=new Map;return e.orderSensitiveModifiers.forEach((e,n)=>{t.set(e,1e6+n)}),e=>{let n=[],r=[];for(let i=0;i<e.length;i++){let a=e[i],o=a[0]===`[`,s=t.has(a);o||s?(r.length>0&&(r.sort(),n.push(...r),r=[]),n.push(a)):r.push(a)}return r.length>0&&(r.sort(),n.push(...r)),n}},Y_=e=>({cache:H_(e.cacheSize),parseClassName:q_(e),sortModifiers:J_(e),postfixLookupClassGroupIds:X_(e),...A_(e)}),X_=e=>{let t=Object.create(null),n=e.postfixLookupClassGroups;if(n)for(let e=0;e<n.length;e++)t[n[e]]=!0;return t},Z_=/\s+/,Q_=(e,t)=>{let{parseClassName:n,getClassGroupId:r,getConflictingClassGroupIds:i,sortModifiers:a,postfixLookupClassGroupIds:o}=t,s=[],c=e.trim().split(Z_),l=``;for(let e=c.length-1;e>=0;--e){let t=c[e],{isExternal:u,modifiers:d,hasImportantModifier:f,baseClassName:p,maybePostfixModifierPosition:m}=n(t);if(u){l=t+(l.length>0?` `+l:l);continue}let h=!!m,g;if(h){g=r(p.substring(0,m));let e=g&&o[g]?r(p):void 0;e&&e!==g&&(g=e,h=!1)}else g=r(p);if(!g){if(!h){l=t+(l.length>0?` `+l:l);continue}if(g=r(p),!g){l=t+(l.length>0?` `+l:l);continue}h=!1}let _=d.length===0?``:d.length===1?d[0]:a(d).join(`:`),v=f?_+U_:_,y=v+g;if(s.indexOf(y)>-1)continue;s.push(y);let b=i(g,h);for(let e=0;e<b.length;++e){let t=b[e];s.push(v+t)}l=t+(l.length>0?` `+l:l)}return l},$_=(...e)=>{let t=0,n,r,i=``;for(;t<e.length;)(n=e[t++])&&(r=ev(n))&&(i&&(i+=` `),i+=r);return i},ev=e=>{if(typeof e==`string`)return e;let t,n=``;for(let r=0;r<e.length;r++)e[r]&&(t=ev(e[r]))&&(n&&(n+=` `),n+=t);return n},tv=(e,...t)=>{let n,r,i,a,o=o=>(n=Y_(t.reduce((e,t)=>t(e),e())),r=n.cache.get,i=n.cache.set,a=s,s(o)),s=e=>{let t=r(e);if(t)return t;let a=Q_(e,n);return i(e,a),a};return a=o,(...e)=>a($_(...e))},nv=[],rv=e=>{let t=t=>t[e]||nv;return t.isThemeGetter=!0,t},iv=/^\[(?:(\w[\w-]*):)?(.+)\]$/i,av=/^\((?:(\w[\w-]*):)?(.+)\)$/i,ov=/^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/,sv=/^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/,cv=/\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/,lv=/^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/,uv=/^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/,dv=/^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/,fv=e=>ov.test(e),Y=e=>!!e&&!Number.isNaN(Number(e)),pv=e=>!!e&&Number.isInteger(Number(e)),mv=e=>e.endsWith(`%`)&&Y(e.slice(0,-1)),hv=e=>sv.test(e),gv=()=>!0,_v=e=>cv.test(e)&&!lv.test(e),vv=()=>!1,yv=e=>uv.test(e),bv=e=>dv.test(e),xv=e=>!X(e)&&!Z(e),Sv=e=>e.startsWith(`@container`)&&(e[10]===`/`&&e[11]!==void 0||e[11]===`s`&&e[16]!==void 0&&e.startsWith(`-size/`,10)||e[11]===`n`&&e[18]!==void 0&&e.startsWith(`-normal/`,10)),Cv=e=>Rv(e,Hv,vv),X=e=>iv.test(e),wv=e=>Rv(e,Uv,_v),Tv=e=>Rv(e,Wv,Y),Ev=e=>Rv(e,Kv,gv),Dv=e=>Rv(e,Gv,vv),Ov=e=>Rv(e,Bv,vv),kv=e=>Rv(e,Vv,bv),Av=e=>Rv(e,qv,yv),Z=e=>av.test(e),jv=e=>zv(e,Uv),Mv=e=>zv(e,Gv),Nv=e=>zv(e,Bv),Pv=e=>zv(e,Hv),Fv=e=>zv(e,Vv),Iv=e=>zv(e,qv,!0),Lv=e=>zv(e,Kv,!0),Rv=(e,t,n)=>{let r=iv.exec(e);return r?r[1]?t(r[1]):n(r[2]):!1},zv=(e,t,n=!1)=>{let r=av.exec(e);return r?r[1]?t(r[1]):n:!1},Bv=e=>e===`position`||e===`percentage`,Vv=e=>e===`image`||e===`url`,Hv=e=>e===`length`||e===`size`||e===`bg-size`,Uv=e=>e===`length`,Wv=e=>e===`number`,Gv=e=>e===`family-name`,Kv=e=>e===`number`||e===`weight`,qv=e=>e===`shadow`,Jv=tv(()=>{let e=rv(`color`),t=rv(`font`),n=rv(`text`),r=rv(`font-weight`),i=rv(`tracking`),a=rv(`leading`),o=rv(`breakpoint`),s=rv(`container`),c=rv(`spacing`),l=rv(`radius`),u=rv(`shadow`),d=rv(`inset-shadow`),f=rv(`text-shadow`),p=rv(`drop-shadow`),m=rv(`blur`),h=rv(`perspective`),g=rv(`aspect`),_=rv(`ease`),v=rv(`animate`),y=()=>[`auto`,`avoid`,`all`,`avoid-page`,`page`,`left`,`right`,`column`],b=()=>[`center`,`top`,`bottom`,`left`,`right`,`top-left`,`left-top`,`top-right`,`right-top`,`bottom-right`,`right-bottom`,`bottom-left`,`left-bottom`],x=()=>[...b(),Z,X],S=()=>[`auto`,`hidden`,`clip`,`visible`,`scroll`],C=()=>[`auto`,`contain`,`none`],w=()=>[Z,X,c],ee=()=>[fv,`full`,`auto`,...w()],te=()=>[pv,`none`,`subgrid`,Z,X],T=()=>[`auto`,{span:[`full`,pv,Z,X]},pv,Z,X],ne=()=>[pv,`auto`,Z,X],re=()=>[`auto`,`min`,`max`,`fr`,Z,X],ie=()=>[`start`,`end`,`center`,`between`,`around`,`evenly`,`stretch`,`baseline`,`center-safe`,`end-safe`],E=()=>[`start`,`end`,`center`,`stretch`,`center-safe`,`end-safe`],ae=()=>[`auto`,...w()],oe=()=>[fv,`auto`,`full`,`dvw`,`dvh`,`lvw`,`lvh`,`svw`,`svh`,`min`,`max`,`fit`,...w()],se=()=>[fv,`screen`,`full`,`dvw`,`lvw`,`svw`,`min`,`max`,`fit`,...w()],ce=()=>[fv,`screen`,`full`,`lh`,`dvh`,`lvh`,`svh`,`min`,`max`,`fit`,...w()],D=()=>[e,Z,X],le=()=>[...b(),Nv,Ov,{position:[Z,X]}],ue=()=>[`no-repeat`,{repeat:[``,`x`,`y`,`space`,`round`]}],de=()=>[`auto`,`cover`,`contain`,Pv,Cv,{size:[Z,X]}],fe=()=>[mv,jv,wv],pe=()=>[``,`none`,`full`,l,Z,X],me=()=>[``,Y,jv,wv],he=()=>[`solid`,`dashed`,`dotted`,`double`],ge=()=>[`normal`,`multiply`,`screen`,`overlay`,`darken`,`lighten`,`color-dodge`,`color-burn`,`hard-light`,`soft-light`,`difference`,`exclusion`,`hue`,`saturation`,`color`,`luminosity`],_e=()=>[Y,mv,Nv,Ov],ve=()=>[``,`none`,m,Z,X],ye=()=>[`none`,Y,Z,X],be=()=>[`none`,Y,Z,X],O=()=>[Y,Z,X],xe=()=>[fv,`full`,...w()];return{cacheSize:500,theme:{animate:[`spin`,`ping`,`pulse`,`bounce`],aspect:[`video`],blur:[hv],breakpoint:[hv],color:[gv],container:[hv],"drop-shadow":[hv],ease:[`in`,`out`,`in-out`],font:[xv],"font-weight":[`thin`,`extralight`,`light`,`normal`,`medium`,`semibold`,`bold`,`extrabold`,`black`],"inset-shadow":[hv],leading:[`none`,`tight`,`snug`,`normal`,`relaxed`,`loose`],perspective:[`dramatic`,`near`,`normal`,`midrange`,`distant`,`none`],radius:[hv],shadow:[hv],spacing:[`px`,Y],text:[hv],"text-shadow":[hv],tracking:[`tighter`,`tight`,`normal`,`wide`,`wider`,`widest`]},classGroups:{aspect:[{aspect:[`auto`,`square`,fv,X,Z,g]}],container:[`container`],"container-type":[{"@container":[``,`normal`,`size`,Z,X]}],"container-named":[Sv],columns:[{columns:[Y,X,Z,s]}],"break-after":[{"break-after":y()}],"break-before":[{"break-before":y()}],"break-inside":[{"break-inside":[`auto`,`avoid`,`avoid-page`,`avoid-column`]}],"box-decoration":[{"box-decoration":[`slice`,`clone`]}],box:[{box:[`border`,`content`]}],display:[`block`,`inline-block`,`inline`,`flex`,`inline-flex`,`table`,`inline-table`,`table-caption`,`table-cell`,`table-column`,`table-column-group`,`table-footer-group`,`table-header-group`,`table-row-group`,`table-row`,`flow-root`,`grid`,`inline-grid`,`contents`,`list-item`,`hidden`],sr:[`sr-only`,`not-sr-only`],float:[{float:[`right`,`left`,`none`,`start`,`end`]}],clear:[{clear:[`left`,`right`,`both`,`none`,`start`,`end`]}],isolation:[`isolate`,`isolation-auto`],"object-fit":[{object:[`contain`,`cover`,`fill`,`none`,`scale-down`]}],"object-position":[{object:x()}],overflow:[{overflow:S()}],"overflow-x":[{"overflow-x":S()}],"overflow-y":[{"overflow-y":S()}],overscroll:[{overscroll:C()}],"overscroll-x":[{"overscroll-x":C()}],"overscroll-y":[{"overscroll-y":C()}],position:[`static`,`fixed`,`absolute`,`relative`,`sticky`],inset:[{inset:ee()}],"inset-x":[{"inset-x":ee()}],"inset-y":[{"inset-y":ee()}],start:[{"inset-s":ee(),start:ee()}],end:[{"inset-e":ee(),end:ee()}],"inset-bs":[{"inset-bs":ee()}],"inset-be":[{"inset-be":ee()}],top:[{top:ee()}],right:[{right:ee()}],bottom:[{bottom:ee()}],left:[{left:ee()}],visibility:[`visible`,`invisible`,`collapse`],z:[{z:[pv,`auto`,Z,X]}],basis:[{basis:[fv,`full`,`auto`,s,...w()]}],"flex-direction":[{flex:[`row`,`row-reverse`,`col`,`col-reverse`]}],"flex-wrap":[{flex:[`nowrap`,`wrap`,`wrap-reverse`]}],flex:[{flex:[Y,fv,`auto`,`initial`,`none`,X]}],grow:[{grow:[``,Y,Z,X]}],shrink:[{shrink:[``,Y,Z,X]}],order:[{order:[pv,`first`,`last`,`none`,Z,X]}],"grid-cols":[{"grid-cols":te()}],"col-start-end":[{col:T()}],"col-start":[{"col-start":ne()}],"col-end":[{"col-end":ne()}],"grid-rows":[{"grid-rows":te()}],"row-start-end":[{row:T()}],"row-start":[{"row-start":ne()}],"row-end":[{"row-end":ne()}],"grid-flow":[{"grid-flow":[`row`,`col`,`dense`,`row-dense`,`col-dense`]}],"auto-cols":[{"auto-cols":re()}],"auto-rows":[{"auto-rows":re()}],gap:[{gap:w()}],"gap-x":[{"gap-x":w()}],"gap-y":[{"gap-y":w()}],"justify-content":[{justify:[...ie(),`normal`]}],"justify-items":[{"justify-items":[...E(),`normal`]}],"justify-self":[{"justify-self":[`auto`,...E()]}],"align-content":[{content:[`normal`,...ie()]}],"align-items":[{items:[...E(),{baseline:[``,`last`]}]}],"align-self":[{self:[`auto`,...E(),{baseline:[``,`last`]}]}],"place-content":[{"place-content":ie()}],"place-items":[{"place-items":[...E(),`baseline`]}],"place-self":[{"place-self":[`auto`,...E()]}],p:[{p:w()}],px:[{px:w()}],py:[{py:w()}],ps:[{ps:w()}],pe:[{pe:w()}],pbs:[{pbs:w()}],pbe:[{pbe:w()}],pt:[{pt:w()}],pr:[{pr:w()}],pb:[{pb:w()}],pl:[{pl:w()}],m:[{m:ae()}],mx:[{mx:ae()}],my:[{my:ae()}],ms:[{ms:ae()}],me:[{me:ae()}],mbs:[{mbs:ae()}],mbe:[{mbe:ae()}],mt:[{mt:ae()}],mr:[{mr:ae()}],mb:[{mb:ae()}],ml:[{ml:ae()}],"space-x":[{"space-x":w()}],"space-x-reverse":[`space-x-reverse`],"space-y":[{"space-y":w()}],"space-y-reverse":[`space-y-reverse`],size:[{size:oe()}],"inline-size":[{inline:[`auto`,...se()]}],"min-inline-size":[{"min-inline":[`auto`,...se()]}],"max-inline-size":[{"max-inline":[`none`,...se()]}],"block-size":[{block:[`auto`,...ce()]}],"min-block-size":[{"min-block":[`auto`,...ce()]}],"max-block-size":[{"max-block":[`none`,...ce()]}],w:[{w:[s,`screen`,...oe()]}],"min-w":[{"min-w":[s,`screen`,`none`,...oe()]}],"max-w":[{"max-w":[s,`screen`,`none`,`prose`,{screen:[o]},...oe()]}],h:[{h:[`screen`,`lh`,...oe()]}],"min-h":[{"min-h":[`screen`,`lh`,`none`,...oe()]}],"max-h":[{"max-h":[`screen`,`lh`,...oe()]}],"font-size":[{text:[`base`,n,jv,wv]}],"font-smoothing":[`antialiased`,`subpixel-antialiased`],"font-style":[`italic`,`not-italic`],"font-weight":[{font:[r,Lv,Ev]}],"font-stretch":[{"font-stretch":[`ultra-condensed`,`extra-condensed`,`condensed`,`semi-condensed`,`normal`,`semi-expanded`,`expanded`,`extra-expanded`,`ultra-expanded`,mv,X]}],"font-family":[{font:[Mv,Dv,t]}],"font-features":[{"font-features":[X]}],"fvn-normal":[`normal-nums`],"fvn-ordinal":[`ordinal`],"fvn-slashed-zero":[`slashed-zero`],"fvn-figure":[`lining-nums`,`oldstyle-nums`],"fvn-spacing":[`proportional-nums`,`tabular-nums`],"fvn-fraction":[`diagonal-fractions`,`stacked-fractions`],tracking:[{tracking:[i,Z,X]}],"line-clamp":[{"line-clamp":[Y,`none`,Z,Tv]}],leading:[{leading:[a,...w()]}],"list-image":[{"list-image":[`none`,Z,X]}],"list-style-position":[{list:[`inside`,`outside`]}],"list-style-type":[{list:[`disc`,`decimal`,`none`,Z,X]}],"text-alignment":[{text:[`left`,`center`,`right`,`justify`,`start`,`end`]}],"placeholder-color":[{placeholder:D()}],"text-color":[{text:D()}],"text-decoration":[`underline`,`overline`,`line-through`,`no-underline`],"text-decoration-style":[{decoration:[...he(),`wavy`]}],"text-decoration-thickness":[{decoration:[Y,`from-font`,`auto`,Z,wv]}],"text-decoration-color":[{decoration:D()}],"underline-offset":[{"underline-offset":[Y,`auto`,Z,X]}],"text-transform":[`uppercase`,`lowercase`,`capitalize`,`normal-case`],"text-overflow":[`truncate`,`text-ellipsis`,`text-clip`],"text-wrap":[{text:[`wrap`,`nowrap`,`balance`,`pretty`]}],indent:[{indent:w()}],"tab-size":[{tab:[pv,Z,X]}],"vertical-align":[{align:[`baseline`,`top`,`middle`,`bottom`,`text-top`,`text-bottom`,`sub`,`super`,Z,X]}],whitespace:[{whitespace:[`normal`,`nowrap`,`pre`,`pre-line`,`pre-wrap`,`break-spaces`]}],break:[{break:[`normal`,`words`,`all`,`keep`]}],wrap:[{wrap:[`break-word`,`anywhere`,`normal`]}],hyphens:[{hyphens:[`none`,`manual`,`auto`]}],content:[{content:[`none`,Z,X]}],"bg-attachment":[{bg:[`fixed`,`local`,`scroll`]}],"bg-clip":[{"bg-clip":[`border`,`padding`,`content`,`text`]}],"bg-origin":[{"bg-origin":[`border`,`padding`,`content`]}],"bg-position":[{bg:le()}],"bg-repeat":[{bg:ue()}],"bg-size":[{bg:de()}],"bg-image":[{bg:[`none`,{linear:[{to:[`t`,`tr`,`r`,`br`,`b`,`bl`,`l`,`tl`]},pv,Z,X],radial:[``,Z,X],conic:[pv,Z,X]},Fv,kv]}],"bg-color":[{bg:D()}],"gradient-from-pos":[{from:fe()}],"gradient-via-pos":[{via:fe()}],"gradient-to-pos":[{to:fe()}],"gradient-from":[{from:D()}],"gradient-via":[{via:D()}],"gradient-to":[{to:D()}],rounded:[{rounded:pe()}],"rounded-s":[{"rounded-s":pe()}],"rounded-e":[{"rounded-e":pe()}],"rounded-t":[{"rounded-t":pe()}],"rounded-r":[{"rounded-r":pe()}],"rounded-b":[{"rounded-b":pe()}],"rounded-l":[{"rounded-l":pe()}],"rounded-ss":[{"rounded-ss":pe()}],"rounded-se":[{"rounded-se":pe()}],"rounded-ee":[{"rounded-ee":pe()}],"rounded-es":[{"rounded-es":pe()}],"rounded-tl":[{"rounded-tl":pe()}],"rounded-tr":[{"rounded-tr":pe()}],"rounded-br":[{"rounded-br":pe()}],"rounded-bl":[{"rounded-bl":pe()}],"border-w":[{border:me()}],"border-w-x":[{"border-x":me()}],"border-w-y":[{"border-y":me()}],"border-w-s":[{"border-s":me()}],"border-w-e":[{"border-e":me()}],"border-w-bs":[{"border-bs":me()}],"border-w-be":[{"border-be":me()}],"border-w-t":[{"border-t":me()}],"border-w-r":[{"border-r":me()}],"border-w-b":[{"border-b":me()}],"border-w-l":[{"border-l":me()}],"divide-x":[{"divide-x":me()}],"divide-x-reverse":[`divide-x-reverse`],"divide-y":[{"divide-y":me()}],"divide-y-reverse":[`divide-y-reverse`],"border-style":[{border:[...he(),`hidden`,`none`]}],"divide-style":[{divide:[...he(),`hidden`,`none`]}],"border-color":[{border:D()}],"border-color-x":[{"border-x":D()}],"border-color-y":[{"border-y":D()}],"border-color-s":[{"border-s":D()}],"border-color-e":[{"border-e":D()}],"border-color-bs":[{"border-bs":D()}],"border-color-be":[{"border-be":D()}],"border-color-t":[{"border-t":D()}],"border-color-r":[{"border-r":D()}],"border-color-b":[{"border-b":D()}],"border-color-l":[{"border-l":D()}],"divide-color":[{divide:D()}],"outline-style":[{outline:[...he(),`none`,`hidden`]}],"outline-offset":[{"outline-offset":[Y,Z,X]}],"outline-w":[{outline:[``,Y,jv,wv]}],"outline-color":[{outline:D()}],shadow:[{shadow:[``,`none`,u,Iv,Av]}],"shadow-color":[{shadow:D()}],"inset-shadow":[{"inset-shadow":[`none`,d,Iv,Av]}],"inset-shadow-color":[{"inset-shadow":D()}],"ring-w":[{ring:me()}],"ring-w-inset":[`ring-inset`],"ring-color":[{ring:D()}],"ring-offset-w":[{"ring-offset":[Y,wv]}],"ring-offset-color":[{"ring-offset":D()}],"inset-ring-w":[{"inset-ring":me()}],"inset-ring-color":[{"inset-ring":D()}],"text-shadow":[{"text-shadow":[`none`,f,Iv,Av]}],"text-shadow-color":[{"text-shadow":D()}],opacity:[{opacity:[Y,Z,X]}],"mix-blend":[{"mix-blend":[...ge(),`plus-darker`,`plus-lighter`]}],"bg-blend":[{"bg-blend":ge()}],"mask-clip":[{"mask-clip":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]},`mask-no-clip`],"mask-composite":[{mask:[`add`,`subtract`,`intersect`,`exclude`]}],"mask-image-linear-pos":[{"mask-linear":[Y]}],"mask-image-linear-from-pos":[{"mask-linear-from":_e()}],"mask-image-linear-to-pos":[{"mask-linear-to":_e()}],"mask-image-linear-from-color":[{"mask-linear-from":D()}],"mask-image-linear-to-color":[{"mask-linear-to":D()}],"mask-image-t-from-pos":[{"mask-t-from":_e()}],"mask-image-t-to-pos":[{"mask-t-to":_e()}],"mask-image-t-from-color":[{"mask-t-from":D()}],"mask-image-t-to-color":[{"mask-t-to":D()}],"mask-image-r-from-pos":[{"mask-r-from":_e()}],"mask-image-r-to-pos":[{"mask-r-to":_e()}],"mask-image-r-from-color":[{"mask-r-from":D()}],"mask-image-r-to-color":[{"mask-r-to":D()}],"mask-image-b-from-pos":[{"mask-b-from":_e()}],"mask-image-b-to-pos":[{"mask-b-to":_e()}],"mask-image-b-from-color":[{"mask-b-from":D()}],"mask-image-b-to-color":[{"mask-b-to":D()}],"mask-image-l-from-pos":[{"mask-l-from":_e()}],"mask-image-l-to-pos":[{"mask-l-to":_e()}],"mask-image-l-from-color":[{"mask-l-from":D()}],"mask-image-l-to-color":[{"mask-l-to":D()}],"mask-image-x-from-pos":[{"mask-x-from":_e()}],"mask-image-x-to-pos":[{"mask-x-to":_e()}],"mask-image-x-from-color":[{"mask-x-from":D()}],"mask-image-x-to-color":[{"mask-x-to":D()}],"mask-image-y-from-pos":[{"mask-y-from":_e()}],"mask-image-y-to-pos":[{"mask-y-to":_e()}],"mask-image-y-from-color":[{"mask-y-from":D()}],"mask-image-y-to-color":[{"mask-y-to":D()}],"mask-image-radial":[{"mask-radial":[Z,X]}],"mask-image-radial-from-pos":[{"mask-radial-from":_e()}],"mask-image-radial-to-pos":[{"mask-radial-to":_e()}],"mask-image-radial-from-color":[{"mask-radial-from":D()}],"mask-image-radial-to-color":[{"mask-radial-to":D()}],"mask-image-radial-shape":[{"mask-radial":[`circle`,`ellipse`]}],"mask-image-radial-size":[{"mask-radial":[{closest:[`side`,`corner`],farthest:[`side`,`corner`]}]}],"mask-image-radial-pos":[{"mask-radial-at":b()}],"mask-image-conic-pos":[{"mask-conic":[Y]}],"mask-image-conic-from-pos":[{"mask-conic-from":_e()}],"mask-image-conic-to-pos":[{"mask-conic-to":_e()}],"mask-image-conic-from-color":[{"mask-conic-from":D()}],"mask-image-conic-to-color":[{"mask-conic-to":D()}],"mask-mode":[{mask:[`alpha`,`luminance`,`match`]}],"mask-origin":[{"mask-origin":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]}],"mask-position":[{mask:le()}],"mask-repeat":[{mask:ue()}],"mask-size":[{mask:de()}],"mask-type":[{"mask-type":[`alpha`,`luminance`]}],"mask-image":[{mask:[`none`,Z,X]}],filter:[{filter:[``,`none`,Z,X]}],blur:[{blur:ve()}],brightness:[{brightness:[Y,Z,X]}],contrast:[{contrast:[Y,Z,X]}],"drop-shadow":[{"drop-shadow":[``,`none`,p,Iv,Av]}],"drop-shadow-color":[{"drop-shadow":D()}],grayscale:[{grayscale:[``,Y,Z,X]}],"hue-rotate":[{"hue-rotate":[Y,Z,X]}],invert:[{invert:[``,Y,Z,X]}],saturate:[{saturate:[Y,Z,X]}],sepia:[{sepia:[``,Y,Z,X]}],"backdrop-filter":[{"backdrop-filter":[``,`none`,Z,X]}],"backdrop-blur":[{"backdrop-blur":ve()}],"backdrop-brightness":[{"backdrop-brightness":[Y,Z,X]}],"backdrop-contrast":[{"backdrop-contrast":[Y,Z,X]}],"backdrop-grayscale":[{"backdrop-grayscale":[``,Y,Z,X]}],"backdrop-hue-rotate":[{"backdrop-hue-rotate":[Y,Z,X]}],"backdrop-invert":[{"backdrop-invert":[``,Y,Z,X]}],"backdrop-opacity":[{"backdrop-opacity":[Y,Z,X]}],"backdrop-saturate":[{"backdrop-saturate":[Y,Z,X]}],"backdrop-sepia":[{"backdrop-sepia":[``,Y,Z,X]}],"border-collapse":[{border:[`collapse`,`separate`]}],"border-spacing":[{"border-spacing":w()}],"border-spacing-x":[{"border-spacing-x":w()}],"border-spacing-y":[{"border-spacing-y":w()}],"table-layout":[{table:[`auto`,`fixed`]}],caption:[{caption:[`top`,`bottom`]}],transition:[{transition:[``,`all`,`colors`,`opacity`,`shadow`,`transform`,`none`,Z,X]}],"transition-behavior":[{transition:[`normal`,`discrete`]}],duration:[{duration:[Y,`initial`,Z,X]}],ease:[{ease:[`linear`,`initial`,_,Z,X]}],delay:[{delay:[Y,Z,X]}],animate:[{animate:[`none`,v,Z,X]}],backface:[{backface:[`hidden`,`visible`]}],perspective:[{perspective:[h,Z,X]}],"perspective-origin":[{"perspective-origin":x()}],rotate:[{rotate:ye()}],"rotate-x":[{"rotate-x":ye()}],"rotate-y":[{"rotate-y":ye()}],"rotate-z":[{"rotate-z":ye()}],scale:[{scale:be()}],"scale-x":[{"scale-x":be()}],"scale-y":[{"scale-y":be()}],"scale-z":[{"scale-z":be()}],"scale-3d":[`scale-3d`],skew:[{skew:O()}],"skew-x":[{"skew-x":O()}],"skew-y":[{"skew-y":O()}],transform:[{transform:[Z,X,``,`none`,`gpu`,`cpu`]}],"transform-origin":[{origin:x()}],"transform-style":[{transform:[`3d`,`flat`]}],translate:[{translate:xe()}],"translate-x":[{"translate-x":xe()}],"translate-y":[{"translate-y":xe()}],"translate-z":[{"translate-z":xe()}],"translate-none":[`translate-none`],zoom:[{zoom:[pv,Z,X]}],accent:[{accent:D()}],appearance:[{appearance:[`none`,`auto`]}],"caret-color":[{caret:D()}],"color-scheme":[{scheme:[`normal`,`dark`,`light`,`light-dark`,`only-dark`,`only-light`]}],cursor:[{cursor:[`auto`,`default`,`pointer`,`wait`,`text`,`move`,`help`,`not-allowed`,`none`,`context-menu`,`progress`,`cell`,`crosshair`,`vertical-text`,`alias`,`copy`,`no-drop`,`grab`,`grabbing`,`all-scroll`,`col-resize`,`row-resize`,`n-resize`,`e-resize`,`s-resize`,`w-resize`,`ne-resize`,`nw-resize`,`se-resize`,`sw-resize`,`ew-resize`,`ns-resize`,`nesw-resize`,`nwse-resize`,`zoom-in`,`zoom-out`,Z,X]}],"field-sizing":[{"field-sizing":[`fixed`,`content`]}],"pointer-events":[{"pointer-events":[`auto`,`none`]}],resize:[{resize:[`none`,``,`y`,`x`]}],"scroll-behavior":[{scroll:[`auto`,`smooth`]}],"scrollbar-thumb-color":[{"scrollbar-thumb":D()}],"scrollbar-track-color":[{"scrollbar-track":D()}],"scrollbar-gutter":[{"scrollbar-gutter":[`auto`,`stable`,`both`]}],"scrollbar-w":[{scrollbar:[`auto`,`thin`,`none`]}],"scroll-m":[{"scroll-m":w()}],"scroll-mx":[{"scroll-mx":w()}],"scroll-my":[{"scroll-my":w()}],"scroll-ms":[{"scroll-ms":w()}],"scroll-me":[{"scroll-me":w()}],"scroll-mbs":[{"scroll-mbs":w()}],"scroll-mbe":[{"scroll-mbe":w()}],"scroll-mt":[{"scroll-mt":w()}],"scroll-mr":[{"scroll-mr":w()}],"scroll-mb":[{"scroll-mb":w()}],"scroll-ml":[{"scroll-ml":w()}],"scroll-p":[{"scroll-p":w()}],"scroll-px":[{"scroll-px":w()}],"scroll-py":[{"scroll-py":w()}],"scroll-ps":[{"scroll-ps":w()}],"scroll-pe":[{"scroll-pe":w()}],"scroll-pbs":[{"scroll-pbs":w()}],"scroll-pbe":[{"scroll-pbe":w()}],"scroll-pt":[{"scroll-pt":w()}],"scroll-pr":[{"scroll-pr":w()}],"scroll-pb":[{"scroll-pb":w()}],"scroll-pl":[{"scroll-pl":w()}],"snap-align":[{snap:[`start`,`end`,`center`,`align-none`]}],"snap-stop":[{snap:[`normal`,`always`]}],"snap-type":[{snap:[`none`,`x`,`y`,`both`]}],"snap-strictness":[{snap:[`mandatory`,`proximity`]}],touch:[{touch:[`auto`,`none`,`manipulation`]}],"touch-x":[{"touch-pan":[`x`,`left`,`right`]}],"touch-y":[{"touch-pan":[`y`,`up`,`down`]}],"touch-pz":[`touch-pinch-zoom`],select:[{select:[`none`,`text`,`all`,`auto`]}],"will-change":[{"will-change":[`auto`,`scroll`,`contents`,`transform`,Z,X]}],fill:[{fill:[`none`,...D()]}],"stroke-w":[{stroke:[Y,jv,wv,Tv]}],stroke:[{stroke:[`none`,...D()]}],"forced-color-adjust":[{"forced-color-adjust":[`auto`,`none`]}]},conflictingClassGroups:{"container-named":[`container-type`],overflow:[`overflow-x`,`overflow-y`],overscroll:[`overscroll-x`,`overscroll-y`],inset:[`inset-x`,`inset-y`,`inset-bs`,`inset-be`,`start`,`end`,`top`,`right`,`bottom`,`left`],"inset-x":[`right`,`left`],"inset-y":[`top`,`bottom`],flex:[`basis`,`grow`,`shrink`],gap:[`gap-x`,`gap-y`],p:[`px`,`py`,`ps`,`pe`,`pbs`,`pbe`,`pt`,`pr`,`pb`,`pl`],px:[`pr`,`pl`],py:[`pt`,`pb`],m:[`mx`,`my`,`ms`,`me`,`mbs`,`mbe`,`mt`,`mr`,`mb`,`ml`],mx:[`mr`,`ml`],my:[`mt`,`mb`],size:[`w`,`h`],"font-size":[`leading`],"fvn-normal":[`fvn-ordinal`,`fvn-slashed-zero`,`fvn-figure`,`fvn-spacing`,`fvn-fraction`],"fvn-ordinal":[`fvn-normal`],"fvn-slashed-zero":[`fvn-normal`],"fvn-figure":[`fvn-normal`],"fvn-spacing":[`fvn-normal`],"fvn-fraction":[`fvn-normal`],"line-clamp":[`display`,`overflow`],rounded:[`rounded-s`,`rounded-e`,`rounded-t`,`rounded-r`,`rounded-b`,`rounded-l`,`rounded-ss`,`rounded-se`,`rounded-ee`,`rounded-es`,`rounded-tl`,`rounded-tr`,`rounded-br`,`rounded-bl`],"rounded-s":[`rounded-ss`,`rounded-es`],"rounded-e":[`rounded-se`,`rounded-ee`],"rounded-t":[`rounded-tl`,`rounded-tr`],"rounded-r":[`rounded-tr`,`rounded-br`],"rounded-b":[`rounded-br`,`rounded-bl`],"rounded-l":[`rounded-tl`,`rounded-bl`],"border-spacing":[`border-spacing-x`,`border-spacing-y`],"border-w":[`border-w-x`,`border-w-y`,`border-w-s`,`border-w-e`,`border-w-bs`,`border-w-be`,`border-w-t`,`border-w-r`,`border-w-b`,`border-w-l`],"border-w-x":[`border-w-r`,`border-w-l`],"border-w-y":[`border-w-t`,`border-w-b`],"border-color":[`border-color-x`,`border-color-y`,`border-color-s`,`border-color-e`,`border-color-bs`,`border-color-be`,`border-color-t`,`border-color-r`,`border-color-b`,`border-color-l`],"border-color-x":[`border-color-r`,`border-color-l`],"border-color-y":[`border-color-t`,`border-color-b`],translate:[`translate-x`,`translate-y`,`translate-none`],"translate-none":[`translate`,`translate-x`,`translate-y`,`translate-z`],"scroll-m":[`scroll-mx`,`scroll-my`,`scroll-ms`,`scroll-me`,`scroll-mbs`,`scroll-mbe`,`scroll-mt`,`scroll-mr`,`scroll-mb`,`scroll-ml`],"scroll-mx":[`scroll-mr`,`scroll-ml`],"scroll-my":[`scroll-mt`,`scroll-mb`],"scroll-p":[`scroll-px`,`scroll-py`,`scroll-ps`,`scroll-pe`,`scroll-pbs`,`scroll-pbe`,`scroll-pt`,`scroll-pr`,`scroll-pb`,`scroll-pl`],"scroll-px":[`scroll-pr`,`scroll-pl`],"scroll-py":[`scroll-pt`,`scroll-pb`],touch:[`touch-x`,`touch-y`,`touch-pz`],"touch-x":[`touch`],"touch-y":[`touch`],"touch-pz":[`touch`]},conflictingClassGroupModifiers:{"font-size":[`leading`]},postfixLookupClassGroups:[`container-type`],orderSensitiveModifiers:[`*`,`**`,`after`,`backdrop`,`before`,`details-content`,`file`,`first-letter`,`first-line`,`marker`,`placeholder`,`selection`]}});function Yv(...e){return Jv(b_(e))}var Xv=F({__name:`Alert`,props:{class:{type:[Boolean,null,String,Object,Array]},variant:{}},setup(e){let t=e;return(n,r)=>(R(),z(`div`,{"data-slot":`alert`,class:O(N(Yv)(N($v)({variant:e.variant}),t.class)),role:`alert`},[I(n.$slots,`default`)],2))}}),Zv=F({__name:`AlertDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`alert-description`,class:O(N(Yv)(`text-muted-foreground text-sm text-balance md:text-pretty [&_p:not(:last-child)]:mb-4 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[I(e.$slots,`default`)],2))}}),Qv=F({__name:`AlertTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`alert-title`,class:O(N(Yv)(`font-medium group-has-[>svg]/alert:col-start-2 cn-font-heading [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[I(e.$slots,`default`)],2))}}),$v=C_(`grid gap-0.5 rounded-lg border px-2.5 py-2 text-left text-sm has-data-[slot=alert-action]:relative has-data-[slot=alert-action]:pr-18 has-[>svg]:grid-cols-[auto_1fr] has-[>svg]:gap-x-2 *:[svg]:row-span-2 *:[svg]:translate-y-0.5 *:[svg]:text-current *:[svg:not([class*=size-])]:size-4 group/alert relative w-full`,{variants:{variant:{default:`bg-card text-card-foreground`,destructive:`text-destructive bg-card *:data-[slot=alert-description]:text-destructive/90 *:[svg]:text-current`}},defaultVariants:{variant:`default`}});function ey(e){return typeof e==`string`?`'${e}'`:new iy().serialize(e)}var ty=` _-,;:!?.'"()[]{}@*/\\&#%\`^+<=>|~$0123456789abcdefghijklmnopqrstuvwxyz`,ny=(function(){let e=new Uint8Array(128);for(let t=0;t<69;t++)e[ty.charCodeAt(t)]=t+1;for(let t=65;t<=90;t++)e[t]=e[t+32];return e})();function ry(e,t){if(e===t)return 0;let n=Math.min(e.length,t.length),r=0;for(let i=0;i<n;i++){let n=e.charCodeAt(i),a=t.charCodeAt(i);if(n===a)continue;let o=n<128&&ny[n]?ny[n]:n+128,s=a<128&&ny[a]?ny[a]:a+128;if(o!==s)return o<s?-1:1;r===0&&(r=n>a?-1:1)}return e.length===t.length?r:e.length<t.length?-1:1}var iy=(function(){class e{#e=new Map;compare(e,t){let n=typeof e,r=typeof t;return n===`string`&&r===`string`?ry(e,t):n===`number`&&r===`number`?e-t:ry(this.serialize(e,!0),this.serialize(t,!0))}serialize(e,t){if(e===null)return`null`;switch(typeof e){case`string`:return t?e:`'${e}'`;case`bigint`:return`${e}n`;case`object`:return this.$object(e);case`function`:return this.$function(e)}return String(e)}serializeObject(e){let t=Object.prototype.toString.call(e);if(t!==`[object Object]`)return this.serializeBuiltInType(t.length<10?`unknown:${t}`:t.slice(8,-1),e);let n=e.constructor,r=n===Object||n===void 0?``:n.name;if(r!==``&&globalThis[r]===n)return this.serializeBuiltInType(r,e);if(`toJSON`in e&&typeof e.toJSON==`function`){let t=e.toJSON();return r+(typeof t==`object`&&t?this.$object(t):`(${this.serialize(t)})`)}let i=Object.keys(e).sort(ry),a=`${r}{`;for(let t=0;t<i.length;t++){let n=i[t];a+=`${n}:${this.serialize(e[n])}`,t<i.length-1&&(a+=`,`)}return a+`}`}serializeBuiltInType(e,t){let n=this[`$`+e];if(n)return n.call(this,t);if(typeof t.entries==`function`)return this.serializeObjectEntries(e,t.entries());throw Error(`Cannot serialize ${e}`)}serializeObjectEntries(e,t){let n=Array.from(t).sort((e,t)=>this.compare(e[0],t[0])),r=`${e}{`;for(let e=0;e<n.length;e++){let[t,i]=n[e];r+=`${this.serialize(t,!0)}:${this.serialize(i)}`,e<n.length-1&&(r+=`,`)}return r+`}`}$object(e){let t=this.#e.get(e);return t===void 0&&(this.#e.set(e,`#${this.#e.size}`),t=this.serializeObject(e),this.#e.set(e,t)),t}$function(e){let t=Function.prototype.toString.call(e);return t.slice(-15)===`[native code] }`?`${e.name||``}()[native]`:`${e.name}(${e.length})${t.replace(/\s*\n\s*/g,``)}`}$Array(e){let t=`[`;for(let n=0;n<e.length;n++)t+=this.serialize(e[n]),n<e.length-1&&(t+=`,`);return t+`]`}$Date(e){try{return`Date(${e.toISOString()})`}catch{return`Date(null)`}}$ArrayBuffer(e){return`ArrayBuffer[${new Uint8Array(e).join(`,`)}]`}$Set(e){return`Set${this.$Array(Array.from(e).sort((e,t)=>this.compare(e,t)))}`}$Map(e){return this.serializeObjectEntries(`Map`,e.entries())}}for(let t of[`Error`,`RegExp`,`URL`])e.prototype[`$`+t]=function(e){return`${t}(${e})`};for(let t of[`Int8Array`,`Uint8Array`,`Uint8ClampedArray`,`Int16Array`,`Uint16Array`,`Int32Array`,`Uint32Array`,`Float32Array`,`Float64Array`])e.prototype[`$`+t]=function(e){return`${t}[${e.join(`,`)}]`};for(let t of[`BigInt64Array`,`BigUint64Array`])e.prototype[`$`+t]=function(e){return`${t}[${e.join(`n,`)}${e.length>0?`n`:``}]`};return e})();function ay(e,t){return e===t||ey(e)===ey(t)}function oy(e,t){let n=typeof e==`string`&&!t?`${e}Context`:t,r=Symbol(n);return[t=>{let n=yr(r,t);if(n||n===null)return n;throw Error(`Injection \`${r.toString()}\` not found. Component must be used within ${Array.isArray(e)?`one of the following components: ${e.join(`, `)}`:`\`${e}\``}`)},e=>(vr(r,e),e)]}function sy(){let e=document.activeElement;if(e==null)return null;for(;e!=null&&e.shadowRoot!=null&&e.shadowRoot.activeElement!=null;)e=e.shadowRoot.activeElement;return e}function cy(e){return e==null}function ly(e,t){return cy(e)?!1:Array.isArray(e)?e.some(e=>ay(e,t)):ay(e,t)}function uy(e,t){return Fe()?(Ie(e,t),!0):!1}function dy(e){let t=!1,n,r=Pe(!0);return((...i)=>(t||=(n=r.run(()=>e(...i)),!0),n))}var fy=typeof window<`u`&&typeof document<`u`;typeof WorkerGlobalScope<`u`&&globalThis instanceof WorkerGlobalScope;var py=e=>e!==void 0,my=Object.prototype.toString,hy=e=>my.call(e)===`[object Object]`,gy=_y();function _y(){var e,t;return fy&&!!((e=window)!=null&&(e=e.navigator)!=null&&e.userAgent)&&(/iP(?:ad|hone|od)/.test(window.navigator.userAgent)||((t=window)==null||(t=t.navigator)==null?void 0:t.maxTouchPoints)>2&&/iPad|Macintosh/.test(window?.navigator.userAgent))}function vy(e){return Array.isArray(e)?e:[e]}function yy(e){return e||Fs()}function by(e){if(!fy)return e;let t=0,n,r,i=()=>{--t,r&&t<=0&&(r.stop(),n=void 0,r=void 0)};return((...a)=>(t+=1,r||(r=Pe(!0),n=r.run(()=>e(...a))),uy(i),n))}function xy(e){return Zt(j(e)?new Proxy({},{get(t,n,r){return N(Reflect.get(e.value,n,r))},set(t,n,r){return j(e.value[n])&&!j(r)?e.value[n].value=r:e.value[n]=r,!0},deleteProperty(t,n){return Reflect.deleteProperty(e.value,n)},has(t,n){return Reflect.has(e.value,n)},ownKeys(){return Object.keys(e.value)},getOwnPropertyDescriptor(){return{enumerable:!0,configurable:!0}}}):e)}function Sy(e){return xy(W(e))}function Cy(e,...t){let n=t.flat(),r=n[0];return Sy(()=>Object.fromEntries(typeof r==`function`?Object.entries(yn(e)).filter(([e,t])=>!r(mn(t),e)):Object.entries(yn(e)).filter(e=>!n.includes(e[0]))))}function wy(e,t=1e4){return vn((n,r)=>{let i=mn(e),a,o=()=>setTimeout(()=>{i=mn(e),r()},mn(t));return uy(()=>{clearTimeout(a)}),{get(){return n(),i},set(e){i=e,r(),clearTimeout(a),a=o()}}})}function Ty(e,t){yy(t)&&ea(e,t)}function Ey(e,t,n){return Er(e,t,{...n,immediate:!0})}var Dy=fy?window:void 0;fy&&window.document,fy&&window.navigator,fy&&window.location;function Oy(e){let t=mn(e);return t?.$el??t}function ky(...e){let t=(e,t,n,r)=>(e.addEventListener(t,n,r),()=>e.removeEventListener(t,n,r)),n=W(()=>{let t=vy(mn(e[0])).filter(e=>e!=null);return t.every(e=>typeof e!=`string`)?t:void 0});return Ey(()=>[n.value?.map(e=>Oy(e))??[Dy].filter(e=>e!=null),vy(mn(n.value?e[1]:e[0])),vy(N(n.value?e[2]:e[1])),mn(n.value?e[3]:e[2])],([e,n,r,i],a,o)=>{if(!e?.length||!n?.length||!r?.length)return;let s=hy(i)?{...i}:i,c=e.flatMap(e=>n.flatMap(n=>r.map(r=>t(e,n,r,s))));o(()=>{c.forEach(e=>e())})},{flush:`post`})}function Ay(){let e=un(!1),t=Fs();return t&&Zi(()=>{e.value=!0},t),e}function jy(e){let t=Ay();return W(()=>(t.value,!!e()))}function My(e){return typeof e==`function`?e:typeof e==`string`?t=>t.key===e:Array.isArray(e)?t=>e.includes(t.key):()=>!0}function Ny(...e){let t,n,r={};e.length===3?(t=e[0],n=e[1],r=e[2]):e.length===2?typeof e[1]==`object`?(t=!0,n=e[0],r=e[1]):(t=e[0],n=e[1]):(t=!0,n=e[0]);let{target:i=Dy,eventName:a=`keydown`,passive:o=!1,dedupe:s=!1}=r,c=My(t);return ky(i,a,e=>{e.repeat&&mn(s)||c(e)&&n(e)},o)}function Py(e){return JSON.parse(JSON.stringify(e))}function Fy(e,t,n={}){let{window:r=Dy,...i}=n,a,o=jy(()=>r&&`ResizeObserver`in r),s=()=>{a&&=(a.disconnect(),void 0)},c=Er(W(()=>{let t=mn(e);return Array.isArray(t)?t.map(e=>Oy(e)):[Oy(t)]}),e=>{if(s(),o.value&&r){a=new ResizeObserver(t);for(let t of e)t&&a.observe(t,i)}},{immediate:!0,flush:`post`}),l=()=>{s(),c()};return uy(l),{isSupported:o,stop:l}}function Iy(e,t,n,r={}){var i,a;let{clone:o=!1,passive:s=!1,eventName:c,deep:l=!1,defaultValue:u,shouldEmit:d}=r,f=Fs(),p=n||f?.emit||(f==null||(i=f.$emit)==null?void 0:i.bind(f))||(f==null||(a=f.proxy)==null||(a=a.$emit)==null?void 0:a.bind(f?.proxy)),m=c;t||=`modelValue`,m||=`update:${t.toString()}`;let h=e=>o?typeof o==`function`?o(e):Py(e):e,g=()=>py(e[t])?h(e[t]):u,_=e=>{d?d(e)&&p(m,e):p(m,e)};if(s){let n=M(g()),r=!1;return Er(()=>e[t],e=>{r||(r=!0,n.value=h(e),Qn(()=>r=!1))}),Er(n,n=>{!r&&(n!==e[t]||l)&&_(n)},{deep:l}),n}return W({get(){return g()},set(e){_(e)}})}function Ly(e){return e?e.flatMap(e=>e.type===L?Ly(e.children):[e]):[]}var Ry=[`INPUT`,`TEXTAREA`];function zy(e,t,n,r={}){if(!t||r.enableIgnoredElement&&Ry.includes(t.nodeName))return null;let{arrowKeyOptions:i=`both`,attributeName:a=`[data-reka-collection-item]`,itemsArray:o=[],loop:s=!0,dir:c=`ltr`,preventScroll:l=!0,focus:u=!1}=r,[d,f,p,m,h,g]=[e.key===`ArrowRight`,e.key===`ArrowLeft`,e.key===`ArrowUp`,e.key===`ArrowDown`,e.key===`Home`,e.key===`End`],_=p||m,v=d||f;if(!h&&!g&&(!_&&!v||i===`vertical`&&v||i===`horizontal`&&_))return null;let y=n?Array.from(n.querySelectorAll(a)):o;if(!y.length)return null;l&&e.preventDefault();let b=null;return v||_?b=By(y,t,{goForward:_?m:c===`ltr`?d:f,loop:s}):h?b=y.at(0)||null:g&&(b=y.at(-1)||null),u&&b?.focus(),b}function By(e,t,n,r=e.includes(t)?e.length:e.length+1){if(--r===0)return null;let i=e.indexOf(t),a;if(a=i===-1?n.goForward?0:e.length-1:n.goForward?i+1:i-1,!n.loop&&(a<0||a>=e.length))return null;let o=e[(a+e.length)%e.length];return o?o.hasAttribute(`disabled`)&&o.getAttribute(`disabled`)!==`false`?By(e,o,n,r):o:null}var[Vy,Hy]=oy(`ConfigProvider`);function Uy(e){let t=Vy({dir:M(`ltr`)});return W(()=>e?.value||t.dir?.value||`ltr`)}function Wy(e){let t=Fs(),n=t?.type.emits,r={};return n?.length||console.warn(`No emitted event found. Please check component: ${t?.type.__name}`),n?.forEach(t=>{r[ce(E(t))]=(...n)=>e(t,...n)}),r}function Gy(){let e=Fs(),t=M(),n=W(()=>r());$i(()=>{n.value!==r()&&pn(t)});function r(){return t.value&&`$el`in t.value&&[`#text`,`#comment`].includes(t.value.$el.nodeName)?t.value.$el.nextElementSibling:Oy(t)}let i=Object.assign({},e.exposed),a={};for(let t in e.props)Object.defineProperty(a,t,{enumerable:!0,configurable:!0,get:()=>e.props[t]});if(Object.keys(i).length>0)for(let e in i)Object.defineProperty(a,e,{enumerable:!0,configurable:!0,get:()=>i[e]});Object.defineProperty(a,"$el",{enumerable:!0,configurable:!0,get:()=>e.vnode.el}),e.exposed=a;function o(n){if(t.value=n,n&&(Object.defineProperty(a,"$el",{enumerable:!0,configurable:!0,get:()=>n instanceof Element?n:n.$el}),!(n instanceof Element)&&!Object.hasOwn(n,`$el`))){let t=n.$.exposed,r=Object.assign({},a);for(let e in t)Object.defineProperty(r,e,{enumerable:!0,configurable:!0,get:()=>t[e]});e.exposed=r}}return{forwardRef:o,currentRef:t,currentElement:n}}function Ky(e){let t=Fs(),n=Object.keys(t?.type.props??{}).reduce((e,n)=>{let r=(t?.type.props[n]).default;return r!==void 0&&(e[n]=r),e},{}),r=Sn(e);return W(()=>{let e={},i=t?.vnode.props??{};return Object.keys(i).forEach(t=>{e[E(t)]=i[t]}),Object.keys({...n,...e}).reduce((e,t)=>(r.value[t]!==void 0&&(e[t]=r.value[t]),e),{})})}function qy(e,t){let n=Ky(e),r=t?Wy(t):{};return W(()=>({...n.value,...r}))}var Jy=0;function Yy(e,t=`reka`){if(e)return e;let n,r=Vy({useId:void 0});return n=r.useId?r.useId():`useId`in bu?ai?.():`${++Jy}`,t?`${t}-${n}`:n}function Xy(e,t){let n=M(e);function r(e){return t[n.value][e]??n.value}return{state:n,dispatch:e=>{n.value=r(e)}}}function Zy(e,t){let n=M({}),r=M(`none`),i=M(e),a=e.value?`mounted`:`unmounted`,o,s=t.value?.ownerDocument.defaultView??Dy,{state:c,dispatch:l}=Xy(a,{mounted:{UNMOUNT:`unmounted`,ANIMATION_OUT:`unmountSuspended`},unmountSuspended:{MOUNT:`mounted`,ANIMATION_END:`unmounted`},unmounted:{MOUNT:`mounted`}}),u=e=>{if(fy){let n=new CustomEvent(e,{bubbles:!1,cancelable:!1});t.value?.dispatchEvent(n)}};Er(e,async(e,i)=>{let a=i!==e;if(await Qn(),a){let a=r.value,o=Qy(t.value);e?(l(`MOUNT`),u(`enter`),o===`none`&&u(`after-enter`)):o===`none`||o===`undefined`||n.value?.display===`none`?(l(`UNMOUNT`),u(`leave`),u(`after-leave`)):i&&a!==o?(l(`ANIMATION_OUT`),u(`leave`)):(l(`UNMOUNT`),u(`after-leave`))}},{immediate:!0});let d=e=>{if(e.target!==t.value)return;let n=Qy(t.value),r=n.includes(CSS.escape(e.animationName)),a=c.value===`mounted`?`enter`:`leave`;if(r&&(u(`after-${a}`),l(`ANIMATION_END`),!i.value)){let e=t.value.style.animationFillMode;t.value.style.animationFillMode=`forwards`,o=s?.setTimeout(()=>{t.value?.style.animationFillMode===`forwards`&&(t.value.style.animationFillMode=e)})}n===`none`&&l(`ANIMATION_END`)},f=e=>{e.target===t.value&&(r.value=Qy(t.value))},p=Er(t,(e,t)=>{e?(n.value=getComputedStyle(e),e.addEventListener(`animationstart`,f),e.addEventListener(`animationcancel`,d),e.addEventListener(`animationend`,d)):(l(`ANIMATION_END`),o!==void 0&&s?.clearTimeout(o),t?.removeEventListener(`animationstart`,f),t?.removeEventListener(`animationcancel`,d),t?.removeEventListener(`animationend`,d))},{immediate:!0}),m=Er(c,()=>{let e=Qy(t.value);r.value=c.value===`mounted`?e:`none`});return ta(()=>{p(),m(),t.value&&(t.value.removeEventListener(`animationstart`,f),t.value.removeEventListener(`animationcancel`,d),t.value.removeEventListener(`animationend`,d)),o!==void 0&&s?.clearTimeout(o)}),{isPresent:W(()=>[`mounted`,`unmountSuspended`].includes(c.value))}}function Qy(e){return e&&getComputedStyle(e).animationName||`none`}var $y=F({name:`Presence`,props:{present:{type:Boolean,required:!0},forceMount:{type:Boolean}},slots:{},setup(e,{slots:t,expose:n}){let{present:r,forceMount:i}=yn(e),a=M(),{isPresent:o}=Zy(r,a);n({present:o});let s=t.default({present:o.value});s=Ly(s||[]);let c=Fs();if(s&&s?.length>1){let e=c?.parent?.type.name?`<${c.parent.type.name} />`:`component`;throw Error([`Detected an invalid children for \`${e}\` for  \`Presence\` component.`,``,"Note: Presence works similarly to `v-if` directly, but it waits for animation/transition to finished before unmounting. So it expect only one direct child of valid VNode type.",`You can apply a few solutions:`,["Provide a single child element so that `presence` directive attach correctly.",`Ensure the first child is an actual element instead of a raw text node or comment node.`].map(e=>`  - ${e}`).join(`
`)].join(`
`))}return()=>i.value||r.value||o.value?G(t.default({present:o.value})[0],{ref:e=>{let t=Oy(e);return t?.hasAttribute===void 0||(t?.hasAttribute(`data-reka-popper-content-wrapper`)?a.value=t.firstElementChild:a.value=t),t}}):null}}),eb=F({name:`PrimitiveSlot`,inheritAttrs:!1,setup(e,{attrs:t,slots:n}){return()=>{if(!n.default)return null;let e=Ly(n.default()),r=e.findIndex(e=>e.type!==cs);if(r===-1)return e;let i=e[r];delete i.props?.ref;let a=i.props?ks(t,i.props):t,o=Cs({...i,props:{}},a);return e.length===1?o:(e[r]=o,e)}}}),tb=[`area`,`img`,`input`],nb=F({name:`Primitive`,inheritAttrs:!1,props:{asChild:{type:Boolean,default:!1},as:{type:[String,Object],default:`div`}},setup(e,{attrs:t,slots:n}){let r=e.asChild?`template`:e.as;return typeof r==`string`&&tb.includes(r)?()=>G(r,t):r===`template`?()=>G(eb,t,{default:n.default}):()=>G(e.as,t,{default:n.default})}});function rb(){let e=M();return{primitiveElement:e,currentElement:W(()=>[`#text`,`#comment`].includes(e.value?.$el.nodeName)?e.value?.$el.nextElementSibling:Oy(e))}}var[ib,ab]=oy(`CollapsibleRoot`),ob=F({__name:`CollapsibleRoot`,props:{defaultOpen:{type:Boolean,required:!1,default:!1},open:{type:Boolean,required:!1,default:void 0},disabled:{type:Boolean,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:open`],setup(e,{expose:t,emit:n}){let r=e,i=Iy(r,`open`,n,{defaultValue:r.defaultOpen,passive:r.open===void 0}),{disabled:a,unmountOnHide:o}=yn(r);return ab({contentId:``,disabled:a,open:i,unmountOnHide:o,onOpenToggle:()=>{a.value||(i.value=!i.value)}}),t({open:i}),Gy(),(e,t)=>(R(),B(N(nb),{as:e.as,"as-child":r.asChild,"data-state":N(i)?`open`:`closed`,"data-disabled":N(a)?``:void 0},{default:P(()=>[I(e.$slots,`default`,{open:N(i)})]),_:3},8,[`as`,`as-child`,`data-state`,`data-disabled`]))}}),sb=F({inheritAttrs:!1,__name:`CollapsibleContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`contentFound`],setup(e,{emit:t}){let n=e,r=t,i=ib();i.contentId||=Yy(void 0,`reka-collapsible-content`);let a=M(),{forwardRef:o,currentElement:s}=Gy(),c=M(0),l=M(0),u=W(()=>i.open.value),d=M(u.value),f=M();Er(()=>[u.value,a.value?.present],async()=>{await Qn();let e=s.value;if(!e)return;f.value=f.value||{transitionDuration:e.style.transitionDuration,animationName:e.style.animationName},e.style.transitionDuration=`0s`,e.style.animationName=`none`;let t=e.getBoundingClientRect();l.value=t.height,c.value=t.width,d.value||(e.style.transitionDuration=f.value.transitionDuration,e.style.animationName=f.value.animationName)},{immediate:!0});let p=W(()=>d.value&&i.open.value);return Zi(()=>{requestAnimationFrame(()=>{d.value=!1})}),ky(s,`beforematch`,e=>{requestAnimationFrame(()=>{i.onOpenToggle(),r(`contentFound`)})}),(e,t)=>(R(),B(N($y),{ref_key:`presentRef`,ref:a,present:e.forceMount||N(i).open.value,"force-mount":!0},{default:P(({present:t})=>[H(N(nb),ks(e.$attrs,{id:N(i).contentId,ref:N(o),"as-child":n.asChild,as:e.as,hidden:t?void 0:N(i).unmountOnHide.value?``:`until-found`,"data-state":p.value?void 0:N(i).open.value?`open`:`closed`,"data-disabled":N(i).disabled?.value?``:void 0,style:{"--reka-collapsible-content-height":`${l.value}px`,"--reka-collapsible-content-width":`${c.value}px`}}),{default:P(()=>[!N(i).unmountOnHide.value||t?I(e.$slots,`default`,{key:0}):Ts(`v-if`,!0)]),_:2},1040,[`id`,`as-child`,`as`,`hidden`,`data-state`,`data-disabled`,`style`])]),_:3},8,[`present`]))}}),cb=F({__name:`CollapsibleTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e;Gy();let n=ib();return(e,r)=>(R(),B(N(nb),{type:e.as===`button`?`button`:void 0,as:e.as,"as-child":t.asChild,"aria-controls":N(n).contentId,"aria-expanded":N(n).open.value,"data-state":N(n).open.value?`open`:`closed`,"data-disabled":N(n).disabled?.value?``:void 0,disabled:N(n).disabled?.value,onClick:N(n).onOpenToggle},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`type`,`as`,`as-child`,`aria-controls`,`aria-expanded`,`data-state`,`data-disabled`,`disabled`,`onClick`]))}});function lb({type:e,defaultValue:t,modelValue:n}){let r=n||t;return n!==void 0||t!==void 0?Array.isArray(r)?`multiple`:`single`:e??`single`}function ub({type:e,defaultValue:t,modelValue:n}){return e||lb({type:e,defaultValue:t,modelValue:n})}function db({type:e,defaultValue:t}){return t===void 0?e===`single`?void 0:[]:t}function fb(e,t){let n=W(()=>ub(e)),r=Iy(e,`modelValue`,t,{defaultValue:db(e),passive:e.modelValue===void 0,deep:!0});function i(e){if(n.value===`single`)r.value=ay(e,r.value)?void 0:e;else{let t=Array.isArray(r.value)?[...r.value||[]]:[r.value].filter(Boolean);if(ly(t,e)){let n=t.findIndex(t=>ay(t,e));t.splice(n,1)}else t.push(e);r.value=t}}return{modelValue:r,changeModelValue:i,isSingle:W(()=>n.value===`single`)}}var[pb,mb]=oy(`AccordionRoot`),hb=F({__name:`AccordionRoot`,props:{collapsible:{type:Boolean,required:!1,default:!1},disabled:{type:Boolean,required:!1,default:!1},dir:{type:String,required:!1},orientation:{type:String,required:!1,default:`vertical`},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},type:{type:String,required:!1},modelValue:{type:null,required:!1},defaultValue:{type:null,required:!1}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,{dir:i,disabled:a,unmountOnHide:o}=yn(n),s=Uy(i),{modelValue:c,changeModelValue:l,isSingle:u}=fb(n,r),{forwardRef:d,currentElement:f}=Gy();return mb({disabled:a,direction:s,orientation:n.orientation,parentElement:f,isSingle:u,collapsible:n.collapsible,modelValue:c,changeModelValue:l,unmountOnHide:o}),(e,t)=>(R(),B(N(nb),{ref:N(d),"as-child":e.asChild,as:e.as},{default:P(()=>[I(e.$slots,`default`,{modelValue:N(c)})]),_:3},8,[`as-child`,`as`]))}}),gb=function(e){return e.Open=`open`,e.Closed=`closed`,e}(gb||{}),[_b,vb]=oy(`AccordionItem`),yb=F({__name:`AccordionItem`,props:{disabled:{type:Boolean,required:!1},value:{type:String,required:!0},unmountOnHide:{type:Boolean,required:!1,default:void 0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e,{expose:t}){let n=e,r=pb(),i=W(()=>r.isSingle.value?n.value===r.modelValue.value:Array.isArray(r.modelValue.value)&&r.modelValue.value.includes(n.value)),a=W(()=>r.disabled.value||n.disabled),o=W(()=>a.value?``:void 0),s=W(()=>i.value?gb.Open:gb.Closed);t({open:i,dataDisabled:o});let{currentRef:c,currentElement:l}=Gy();vb({open:i,dataState:s,disabled:a,dataDisabled:o,triggerId:``,currentRef:c,currentElement:l,value:W(()=>n.value)});function u(e){let t=e.target;if(Array.from(r.parentElement.value?.querySelectorAll(`[data-reka-collection-item]`)??[]).findIndex(e=>e===t)===-1)return null;zy(e,t,r.parentElement.value,{arrowKeyOptions:r.orientation,dir:r.direction.value,focus:!0})}return(e,t)=>(R(),B(N(ob),{"data-orientation":N(r).orientation,"data-disabled":o.value,"data-state":s.value,disabled:a.value,open:i.value,as:n.as,"as-child":n.asChild,"unmount-on-hide":n.unmountOnHide??N(r).unmountOnHide.value,onKeydown:ou(u,[`up`,`down`,`left`,`right`,`home`,`end`])},{default:P(()=>[I(e.$slots,`default`,{open:i.value})]),_:3},8,[`data-orientation`,`data-disabled`,`data-state`,`disabled`,`open`,`as`,`as-child`,`unmount-on-hide`]))}}),bb=F({__name:`AccordionContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=pb(),r=_b();return Gy(),(e,i)=>(R(),B(N(sb),{role:`region`,"as-child":t.asChild,as:e.as,"force-mount":t.forceMount,"aria-labelledby":N(r).triggerId,"data-state":N(r).dataState.value,"data-disabled":N(r).dataDisabled.value,"data-orientation":N(n).orientation,style:{"--reka-accordion-content-width":`var(--reka-collapsible-content-width)`,"--reka-accordion-content-height":`var(--reka-collapsible-content-height)`},onContentFound:i[0]||=e=>N(n).changeModelValue(N(r).value.value)},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`force-mount`,`aria-labelledby`,`data-state`,`data-disabled`,`data-orientation`]))}}),xb=F({__name:`AccordionHeader`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`h3`}},setup(e){let t=e,n=pb(),r=_b();return Gy(),(e,i)=>(R(),B(N(nb),{as:t.as,"as-child":t.asChild,"data-orientation":N(n).orientation,"data-state":N(r).dataState.value,"data-disabled":N(r).dataDisabled.value},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`data-orientation`,`data-state`,`data-disabled`]))}}),Sb=F({__name:`AccordionTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=pb(),r=_b();r.triggerId||=Yy(void 0,`reka-accordion-trigger`);function i(){let e=n.isSingle.value&&r.open.value&&!n.collapsible;r.disabled.value||e||n.changeModelValue(r.value.value)}return(e,a)=>(R(),B(N(cb),{id:N(r).triggerId,ref:N(r).currentRef,"data-reka-collection-item":``,as:t.as,"as-child":t.asChild,"aria-disabled":N(r).disabled.value||void 0,"aria-expanded":N(r).open.value||!1,"data-disabled":N(r).dataDisabled.value,"data-orientation":N(n).orientation,"data-state":N(r).dataState.value,disabled:N(r).disabled.value,onClick:i},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`id`,`as`,`as-child`,`aria-disabled`,`aria-expanded`,`data-disabled`,`data-orientation`,`data-state`,`disabled`]))}}),Cb=`data-reka-collection-item`;function wb(e={}){let{key:t=``,isProvider:n=!1}=e,r=`${t}CollectionProvider`,i;n?(i={collectionRef:M(),itemMap:M(new Map)},vr(r,i)):i=yr(r);let a=(e=!1)=>{let t=i.collectionRef.value;if(!t)return[];let n=Array.from(t.querySelectorAll(`[${Cb}]`)),r=new Map(n.map((e,t)=>[e,t])),a=Array.from(i.itemMap.value.values()).sort((e,t)=>(r.get(e.ref)??-1)-(r.get(t.ref)??-1));return e?a:a.filter(e=>e.ref.dataset.disabled!==``)},o=F({name:`CollectionSlot`,inheritAttrs:!1,setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=rb();return Er(a,()=>{i.collectionRef.value=a.value}),()=>G(eb,{ref:r,...n},t)}}),s=F({name:`CollectionItem`,inheritAttrs:!1,props:{value:{validator:()=>!0}},setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=rb();return Cr(t=>{if(a.value){let n=sn(a.value);i.itemMap.value.set(n,{ref:a.value,value:e.value}),t(()=>i.itemMap.value.delete(n))}}),()=>G(eb,{...n,[Cb]:``,ref:r},t)}});return{getItems:a,reactiveItems:W(()=>Array.from(i.itemMap.value.values())),itemMapSize:W(()=>i.itemMap.value.size),CollectionSlot:o,CollectionItem:s}}var Tb=`rovingFocusGroup.onEntryFocus`,Eb={bubbles:!1,cancelable:!0},Db={ArrowLeft:`prev`,ArrowUp:`prev`,ArrowRight:`next`,ArrowDown:`next`,PageUp:`first`,Home:`first`,PageDown:`last`,End:`last`};function Ob(e,t){return t===`rtl`?e===`ArrowLeft`?`ArrowRight`:e===`ArrowRight`?`ArrowLeft`:e:e}function kb(e,t,n){let r=Ob(e.key,n);if(!(t===`vertical`&&[`ArrowLeft`,`ArrowRight`].includes(r))&&!(t===`horizontal`&&[`ArrowUp`,`ArrowDown`].includes(r)))return Db[r]}function Ab(e,t=!1){let n=sy();for(let r of e)if(r===n||(r.focus({preventScroll:t}),sy()!==n))return}function jb(e,t){return e.map((n,r)=>e[(t+r)%e.length])}var[Mb,Nb]=oy(`RovingFocusGroup`),Pb=F({__name:`RovingFocusGroup`,props:{orientation:{type:String,required:!1,default:void 0},dir:{type:String,required:!1},loop:{type:Boolean,required:!1,default:!1},currentTabStopId:{type:[String,null],required:!1},defaultCurrentTabStopId:{type:String,required:!1},preventScrollOnEntryFocus:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`entryFocus`,`update:currentTabStopId`],setup(e,{expose:t,emit:n}){let r=e,i=n,{loop:a,orientation:o,dir:s}=yn(r),c=Uy(s),l=Iy(r,`currentTabStopId`,i,{defaultValue:r.defaultCurrentTabStopId,passive:r.currentTabStopId===void 0}),u=M(!1),d=M(!1),f=M(0),{getItems:p,CollectionSlot:m}=wb({isProvider:!0});function h(e){let t=!d.value;if(e.currentTarget&&e.target===e.currentTarget&&t&&!u.value){let t=new CustomEvent(Tb,Eb);if(e.currentTarget.dispatchEvent(t),i(`entryFocus`,t),!t.defaultPrevented){let e=p().map(e=>e.ref).filter(e=>e.dataset.disabled!==``);Ab([e.find(e=>e.getAttribute(`data-active`)===``),e.find(e=>e.getAttribute(`data-highlighted`)===``),e.find(e=>e.id===l.value),...e].filter(Boolean),r.preventScrollOnEntryFocus)}}d.value=!1}function g(){setTimeout(()=>{d.value=!1},1)}return t({getItems:p}),Nb({loop:a,dir:c,orientation:o,currentTabStopId:l,onItemFocus:e=>{l.value=e},onItemShiftTab:()=>{u.value=!0},onFocusableItemAdd:()=>{f.value++},onFocusableItemRemove:()=>{f.value--}}),(e,t)=>(R(),B(N(m),null,{default:P(()=>[H(N(nb),{tabindex:u.value||f.value===0?-1:0,"data-orientation":N(o),as:e.as,"as-child":e.asChild,dir:N(c),style:{outline:`none`},onMousedown:t[0]||=e=>d.value=!0,onMouseup:g,onFocus:h,onBlur:t[1]||=e=>u.value=!1},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`as`,`as-child`,`dir`])]),_:3}))}}),Fb=F({__name:`RovingFocusItem`,props:{tabStopId:{type:String,required:!1},focusable:{type:Boolean,required:!1,default:!0},active:{type:Boolean,required:!1},allowShiftKey:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Mb(),r=Yy(),i=W(()=>t.tabStopId||r),a=W(()=>n.currentTabStopId.value===i.value),{getItems:o,CollectionItem:s}=wb();Zi(()=>{t.focusable&&n.onFocusableItemAdd()}),ta(()=>{t.focusable&&n.onFocusableItemRemove()}),Er(()=>t.focusable,(e,t)=>{e!==t&&(e?n.onFocusableItemAdd():n.onFocusableItemRemove())});function c(e){if(e.key===`Tab`&&e.shiftKey){n.onItemShiftTab();return}if(e.target!==e.currentTarget)return;let r=kb(e,n.orientation.value,n.dir.value);if(r!==void 0){if(e.metaKey||e.ctrlKey||e.altKey||!t.allowShiftKey&&e.shiftKey)return;e.preventDefault();let i=[...o().map(e=>e.ref).filter(e=>e.dataset.disabled!==``)];if(r===`last`)i.reverse();else if(r===`prev`||r===`next`){r===`prev`&&i.reverse();let t=i.indexOf(e.currentTarget);i=n.loop.value?jb(i,t+1):i.slice(t+1)}Qn(()=>Ab(i))}}return(e,t)=>(R(),B(N(s),null,{default:P(()=>[H(N(nb),{tabindex:a.value?0:-1,"data-orientation":N(n).orientation.value,"data-active":e.active?``:void 0,"data-disabled":e.focusable?void 0:``,as:e.as,"as-child":e.asChild,onMousedown:t[0]||=t=>{e.focusable?N(n).onItemFocus(i.value):t.preventDefault()},onFocus:t[1]||=e=>N(n).onItemFocus(i.value),onKeydown:c},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`data-active`,`data-disabled`,`as`,`as-child`])]),_:3}))}}),[Ib,Lb]=oy(`TabsRoot`),Rb=F({__name:`TabsRoot`,props:{defaultValue:{type:null,required:!1},orientation:{type:String,required:!1,default:`horizontal`},dir:{type:String,required:!1},activationMode:{type:String,required:!1,default:`automatic`},modelValue:{type:null,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,{orientation:i,unmountOnHide:a,dir:o}=yn(n),s=Uy(o);Gy();let c=Iy(n,`modelValue`,r,{defaultValue:n.defaultValue,passive:n.modelValue===void 0}),l=M(),u=un(new Set);return Lb({modelValue:c,changeModelValue:e=>{c.value=e},orientation:i,dir:s,unmountOnHide:a,activationMode:n.activationMode,baseId:Yy(void 0,`reka-tabs`),tabsList:l,contentIds:u,registerContent:e=>{u.value=new Set([...u.value,e])},unregisterContent:e=>{let t=new Set(u.value);t.delete(e),u.value=t}}),(e,t)=>(R(),B(N(nb),{dir:N(s),"data-orientation":N(i),"as-child":e.asChild,as:e.as},{default:P(()=>[I(e.$slots,`default`,{modelValue:N(c)})]),_:3},8,[`dir`,`data-orientation`,`as-child`,`as`]))}});function zb(e,t){return`${e}-trigger-${t}`}function Bb(e,t){return`${e}-content-${t}`}var Vb=F({__name:`TabsContent`,props:{value:{type:[String,Number],required:!0},forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{forwardRef:n}=Gy(),r=Ib(),i=W(()=>zb(r.baseId,t.value)),a=W(()=>Bb(r.baseId,t.value)),o=W(()=>t.value===r.modelValue.value),s=M(o.value);return Zi(()=>{r.registerContent(t.value),requestAnimationFrame(()=>{s.value=!1})}),ea(()=>{r.unregisterContent(t.value)}),(e,t)=>(R(),B(N($y),{present:e.forceMount||o.value,"force-mount":``},{default:P(({present:t})=>[H(N(nb),{id:a.value,ref:N(n),"as-child":e.asChild,as:e.as,role:`tabpanel`,"data-state":o.value?`active`:`inactive`,"data-orientation":N(r).orientation.value,"aria-labelledby":i.value,hidden:!t,tabindex:`0`,style:ge({animationDuration:s.value?`0s`:void 0})},{default:P(()=>[!N(r).unmountOnHide.value||t?I(e.$slots,`default`,{key:0}):Ts(`v-if`,!0)]),_:2},1032,[`id`,`as-child`,`as`,`data-state`,`data-orientation`,`aria-labelledby`,`hidden`,`style`])]),_:3},8,[`present`]))}}),Hb=F({__name:`TabsList`,props:{loop:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let{loop:t}=yn(e),{forwardRef:n,currentElement:r}=Gy(),i=Ib();return i.tabsList=r,(e,r)=>(R(),B(N(Pb),{"as-child":``,orientation:N(i).orientation.value,dir:N(i).dir.value,loop:N(t)},{default:P(()=>[H(N(nb),{ref:N(n),role:`tablist`,"as-child":e.asChild,as:e.as,"aria-orientation":N(i).orientation.value},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`aria-orientation`])]),_:3},8,[`orientation`,`dir`,`loop`]))}}),Ub=F({__name:`TabsTrigger`,props:{value:{type:[String,Number],required:!0},disabled:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e,{forwardRef:n}=Gy(),r=Ib(),i=W(()=>zb(r.baseId,t.value)),a=W(()=>r.contentIds.value.has(t.value)?Bb(r.baseId,t.value):void 0),o=W(()=>t.value===r.modelValue.value);return(e,t)=>(R(),B(N(Fb),{"as-child":``,focusable:!e.disabled,active:o.value},{default:P(()=>[H(N(nb),{id:i.value,ref:N(n),role:`tab`,type:e.as===`button`?`button`:void 0,as:e.as,"as-child":e.asChild,"aria-selected":o.value?`true`:`false`,"aria-controls":a.value,"data-state":o.value?`active`:`inactive`,disabled:e.disabled,"data-disabled":e.disabled?``:void 0,"data-orientation":N(r).orientation.value,onMousedown:t[0]||=iu(t=>{!e.disabled&&t.ctrlKey===!1?N(r).changeModelValue(e.value):t.preventDefault()},[`left`]),onKeydown:t[1]||=ou(t=>N(r).changeModelValue(e.value),[`enter`,`space`]),onFocus:t[2]||=()=>{let t=N(r).activationMode!==`manual`;!o.value&&!e.disabled&&t&&N(r).changeModelValue(e.value)}},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`id`,`type`,`as`,`as-child`,`aria-selected`,`aria-controls`,`data-state`,`disabled`,`data-disabled`,`data-orientation`])]),_:3},8,[`focusable`,`active`]))}}),Wb=F({__name:`Button`,props:{variant:{},size:{},class:{type:[Boolean,null,String,Object,Array]},asChild:{type:Boolean},as:{default:`button`}},setup(e){let t=e;return(n,r)=>(R(),B(N(nb),{"data-slot":`button`,"data-variant":e.variant,"data-size":e.size,as:e.as,"as-child":e.asChild,class:O(N(Yv)(N(Gb)({variant:e.variant,size:e.size}),t.class))},{default:P(()=>[I(n.$slots,`default`)]),_:3},8,[`data-variant`,`data-size`,`as`,`as-child`,`class`]))}}),Gb=C_(`focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 rounded-lg border border-transparent bg-clip-padding text-sm font-medium focus-visible:ring-3 aria-invalid:ring-3 active:not-aria-[haspopup]:translate-y-px [&_svg:not([class*=size-])]:size-4 group/button inline-flex shrink-0 items-center justify-center whitespace-nowrap transition-all outline-none select-none disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0`,{variants:{variant:{default:`bg-primary text-primary-foreground [a]:hover:bg-primary/80`,outline:`border-border bg-background hover:bg-muted hover:text-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50 aria-expanded:bg-muted aria-expanded:text-foreground`,secondary:`bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground`,ghost:`hover:bg-muted hover:text-foreground dark:hover:bg-muted/50 aria-expanded:bg-muted aria-expanded:text-foreground`,destructive:`bg-destructive/10 hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/20 text-destructive focus-visible:border-destructive/40 dark:hover:bg-destructive/30`,link:`text-primary underline-offset-4 hover:underline`},size:{default:`h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2`,xs:`h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*=size-])]:size-3`,sm:`h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*=size-])]:size-3.5`,lg:`h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2`,icon:`size-8`,"icon-xs":`size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*=size-])]:size-3`,"icon-sm":`size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg`,"icon-lg":`size-9`}},defaultVariants:{variant:`default`,size:`default`}}),Kb=[`data-size`],qb=F({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e;return(n,r)=>(R(),z(`div`,{"data-slot":`card`,"data-size":e.size,class:O(N(Yv)(`ring-foreground/10 bg-card text-card-foreground gap-4 overflow-hidden rounded-xl py-4 text-sm ring-1 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl group/card flex flex-col`,t.class))},[I(n.$slots,`default`)],10,Kb))}}),Jb=F({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-content`,class:O(N(Yv)(`px-4 group-data-[size=sm]/card:px-3`,t.class))},[I(e.$slots,`default`)],2))}}),Yb=F({__name:`CardDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-description`,class:O(N(Yv)(`text-muted-foreground text-sm`,t.class))},[I(e.$slots,`default`)],2))}}),Xb=F({__name:`CardHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-header`,class:O(N(Yv)(`gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3 group/card-header @container/card-header grid auto-rows-min items-start has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto]`,t.class))},[I(e.$slots,`default`)],2))}}),Zb=F({__name:`CardTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-title`,class:O(N(Yv)(`text-base leading-snug font-medium group-data-[size=sm]/card:text-sm cn-font-heading`,t.class))},[I(e.$slots,`default`)],2))}}),Qb=F({__name:`Input`,props:{defaultValue:{},modelValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=Iy(n,`modelValue`,t,{passive:!0,defaultValue:n.defaultValue});return(e,t)=>gr((R(),z(`input`,{"onUpdate:modelValue":t[0]||=e=>j(r)?r.value=e:null,"data-slot":`input`,class:O(N(Yv)(`dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 disabled:bg-input/50 dark:disabled:bg-input/80 h-8 rounded-lg border bg-transparent px-2.5 py-1 text-base transition-colors file:h-6 file:text-sm file:font-medium focus-visible:ring-3 aria-invalid:ring-3 md:text-sm w-full min-w-0 outline-none file:inline-flex file:border-0 file:bg-transparent file:text-foreground placeholder:text-muted-foreground disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50`,n.class))},null,2)),[[Wl,N(r)]])}}),$b=`llmgwAdminKey`;function ex(){try{return sessionStorage.getItem($b)??``}catch{return``}}function tx(e){try{sessionStorage.setItem($b,e)}catch{}}function nx(){try{sessionStorage.removeItem($b)}catch{}}var rx=t_(`auth`,{state:()=>({apiKey:ex(),error:``}),getters:{isAuthenticated:e=>e.apiKey!==``},actions:{submit(e){e&&(this.apiKey=e,this.error=``,tx(e))},reject(e){this.apiKey=``,this.error=e,nx()}}}),ix=class extends Error{status;constructor(e,t){super(e),this.name=`AdminApiError`,this.status=t}};async function ax(e){let t=rx(),n=t.apiKey,r=await fetch(e,{credentials:`same-origin`,headers:n?{"x-api-key":n}:{}});if(r.status===401||r.status===403)throw t.apiKey===n&&t.reject(`invalid key, or not an admin`),new ix(`${e}: HTTP ${r.status}`,r.status);if(!r.ok)throw new ix(`${e}: HTTP ${r.status}`,r.status);return await r.json()}var ox=5e3,sx=t_(`dashboard`,{state:()=>({overview:null,usage:null,targets:null,lastUpdated:null,error:``,timer:void 0}),actions:{async refresh(){if(!rx().isAuthenticated)return;let[e,t,n]=await Promise.allSettled([ax(`/admin/api/overview`),ax(`/admin/api/usage`),ax(`/admin/api/targets`)]);e.status===`fulfilled`&&(this.overview=e.value),t.status===`fulfilled`&&(this.usage=t.value),n.status===`fulfilled`&&(this.targets=n.value);let r=[];if(e.status===`rejected`&&r.push({label:`overview`,reason:e.reason}),t.status===`rejected`&&r.push({label:`usage`,reason:t.reason}),n.status===`rejected`&&r.push({label:`targets`,reason:n.reason}),r.length===0){this.lastUpdated=new Date,this.error=``;return}r.some(({reason:e})=>e instanceof ix&&(e.status===401||e.status===403))||(r.length<3&&(this.lastUpdated=new Date),this.error=r.map(({label:e,reason:t})=>`${e}: ${t instanceof Error?t.message:String(t)}`).join(`; `))},startPolling(){this.timer===void 0&&(this.refresh(),this.timer=setInterval(()=>void this.refresh(),ox))},stopPolling(){this.timer!==void 0&&(clearInterval(this.timer),this.timer=void 0)}}}),cx={class:`mx-auto flex min-h-[70vh] max-w-md flex-col justify-center px-4`},lx={class:`flex size-12 items-center justify-center rounded-full bg-primary/10 text-primary`},ux={class:`flex flex-col items-center gap-1`},dx={"aria-labelledby":`authgate-security-heading`,class:`flex flex-col gap-1.5 text-xs text-muted-foreground`},fx={class:`flex items-start gap-1.5`},px={class:`flex items-start gap-1.5`},mx={class:`flex items-start gap-1.5`},hx={class:`relative`},gx=((e,t)=>{let n=e.__vccOpts||e;for(let[e,r]of t)n[e]=r;return n})(F({__name:`AuthGate`,setup(e){let t=rx(),n=sx(),r=M(``),i=M(!1),a=M(null),o=W(()=>r.value.trim()!==``);function s(){let e=r.value;r.value=``,t.submit(e),n.refresh()}function c(){Qn(()=>a.value?.$el?.focus())}return Zi(c),Er(()=>t.error,e=>{e&&c()}),(e,n)=>{let c=ca(`FontAwesomeIcon`);return R(),z(`div`,cx,[H(N(qb),null,{default:P(()=>[H(N(Xb),{class:`flex flex-col items-center gap-3 text-center`},{default:P(()=>[V(`div`,lx,[H(c,{icon:N(i_),class:`size-5`,"aria-hidden":`true`},null,8,[`icon`])]),V(`div`,ux,[n[3]||=V(`span`,{class:`text-xs font-medium text-muted-foreground`},`LLM Gateway`,-1),H(N(Zb),{class:`text-lg font-semibold`},{default:P(()=>[...n[2]||=[U(`Admin key required`,-1)]]),_:1})]),H(N(Yb),null,{default:P(()=>[...n[4]||=[U(`Enter an admin API key to continue.`,-1)]]),_:1})]),_:1}),H(N(Jb),{class:`flex flex-col gap-4`},{default:P(()=>[n[10]||=V(`h2`,{id:`authgate-security-heading`,class:`sr-only`},` How this key is handled `,-1),V(`ul`,dx,[V(`li`,fx,[H(c,{icon:N(u_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[5]||=V(`span`,null,`Kept only in this tab's session storage`,-1)]),V(`li`,px,[H(c,{icon:N(u_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[6]||=V(`span`,null,`Never written to disk`,-1)]),V(`li`,mx,[H(c,{icon:N(u_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[7]||=V(`span`,null,`Sent only to this page's own /admin/api/* requests`,-1)])]),V(`form`,{class:`flex flex-col gap-3`,onSubmit:iu(s,[`prevent`])},[V(`div`,hx,[H(N(Qb),{ref_key:`keyInputEl`,ref:a,modelValue:r.value,"onUpdate:modelValue":n[0]||=e=>r.value=e,type:i.value?`text`:`password`,autocomplete:`off`,placeholder:`API key`,"aria-label":`Admin API key`,"aria-invalid":!!N(t).error,"aria-describedby":N(t).error?`authgate-error`:void 0,class:O([`h-10 pr-10`,{"authgate-shake":N(t).error}])},null,8,[`modelValue`,`type`,`aria-invalid`,`aria-describedby`,`class`]),H(N(Wb),{type:`button`,variant:`ghost`,size:`icon-xs`,class:`absolute top-1/2 right-1.5 -translate-y-1/2 text-muted-foreground hover:text-foreground`,"aria-label":i.value?`Hide key`:`Show key`,onClick:n[1]||=e=>i.value=!i.value},{default:P(()=>[H(c,{icon:i.value?N(__):N(o_),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`aria-label`])]),H(N(Wb),{type:`submit`,class:`w-full`,disabled:!o.value},{default:P(()=>[...n[8]||=[U(` Continue `,-1)]]),_:1},8,[`disabled`])],32),N(t).error?(R(),B(N(Xv),{key:0,id:`authgate-error`,variant:`destructive`},{default:P(()=>[H(N(Qv),null,{default:P(()=>[...n[9]||=[U(`Authentication failed`,-1)]]),_:1}),H(N(Zv),null,{default:P(()=>[U(k(N(t).error),1)]),_:1})]),_:1})):Ts(``,!0)]),_:1})]),_:1})])}}}),[[`__scopeId`,`data-v-4be6bc09`]]);function _x(e,t){return typeof e==`function`?e(t):e}function vx(e,t){return n=>{t.setState(t=>({...t,[e]:_x(n,t[e])}))}}function yx(e){return e instanceof Function}function bx(e){return Array.isArray(e)&&e.every(e=>typeof e==`number`)}function xx(e,t){let n=[],r=e=>{e.forEach(e=>{n.push(e);let i=t(e);i!=null&&i.length&&r(i)})};return r(e),n}function Q(e,t,n){let r=[],i;return a=>{let o;n.key&&n.debug&&(o=Date.now());let s=e(a);if(!(s.length!==r.length||s.some((e,t)=>r[t]!==e)))return i;r=s;let c;if(n.key&&n.debug&&(c=Date.now()),i=t(...s),n==null||n.onChange==null||n.onChange(i),n.key&&n.debug&&n!=null&&n.debug()){let e=Math.round((Date.now()-o)*100)/100,t=Math.round((Date.now()-c)*100)/100,r=t/16,i=(e,t)=>{for(e=String(e);e.length<t;)e=` `+e;return e};console.info(`%c⏱ ${i(t,5)} /${i(e,5)} ms`,`
            font-size: .6rem;
            font-weight: bold;
            color: hsl(${Math.max(0,Math.min(120-120*r,120))}deg 100% 31%);`,n?.key)}return i}}function $(e,t,n,r){return{debug:()=>e?.debugAll??e[t],key:!1,onChange:r}}function Sx(e,t,n,r){let i={id:`${t.id}_${n.id}`,row:t,column:n,getValue:()=>t.getValue(r),renderValue:()=>i.getValue()??e.options.renderFallbackValue,getContext:Q(()=>[e,n,t,i],(e,t,n,r)=>({table:e,column:t,row:n,cell:r,getValue:r.getValue,renderValue:r.renderValue}),$(e.options,`debugCells`,`cell.getContext`))};return e._features.forEach(r=>{r.createCell==null||r.createCell(i,n,t,e)},{}),i}function Cx(e,t,n,r){let i={...e._getDefaultColumnDef(),...t},a=i.accessorKey,o=i.id??(a?typeof String.prototype.replaceAll==`function`?a.replaceAll(`.`,`_`):a.replace(/\./g,`_`):void 0)??(typeof i.header==`string`?i.header:void 0),s;if(i.accessorFn?s=i.accessorFn:a&&(s=a.includes(`.`)?e=>{let t=e;for(let e of a.split(`.`))t=t?.[e];return t}:e=>e[i.accessorKey]),!o)throw Error();let c={id:`${String(o)}`,accessorFn:s,parent:r,depth:n,columnDef:i,columns:[],getFlatColumns:Q(()=>[!0],()=>[c,...c.columns?.flatMap(e=>e.getFlatColumns())],$(e.options,`debugColumns`,`column.getFlatColumns`)),getLeafColumns:Q(()=>[e._getOrderColumnsFn()],e=>{var t;return(t=c.columns)!=null&&t.length?e(c.columns.flatMap(e=>e.getLeafColumns())):[c]},$(e.options,`debugColumns`,`column.getLeafColumns`))};for(let t of e._features)t.createColumn==null||t.createColumn(c,e);return c}var wx=`debugHeaders`;function Tx(e,t,n){let r={id:n.id??t.id,column:t,index:n.index,isPlaceholder:!!n.isPlaceholder,placeholderId:n.placeholderId,depth:n.depth,subHeaders:[],colSpan:0,rowSpan:0,headerGroup:null,getLeafHeaders:()=>{let e=[],t=n=>{n.subHeaders&&n.subHeaders.length&&n.subHeaders.map(t),e.push(n)};return t(r),e},getContext:()=>({table:e,header:r,column:t})};return e._features.forEach(t=>{t.createHeader==null||t.createHeader(r,e)}),r}var Ex={createTable:e=>{e.getHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(t,n,r,i)=>{let a=r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],o=i?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],s=n.filter(e=>!(r!=null&&r.includes(e.id))&&!(i!=null&&i.includes(e.id)));return Dx(t,[...a,...s,...o],e)},$(e.options,wx,`getHeaderGroups`)),e.getCenterHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(t,n,r,i)=>(n=n.filter(e=>!(r!=null&&r.includes(e.id))&&!(i!=null&&i.includes(e.id))),Dx(t,n,e,`center`)),$(e.options,wx,`getCenterHeaderGroups`)),e.getLeftHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left],(t,n,r)=>Dx(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`left`),$(e.options,wx,`getLeftHeaderGroups`)),e.getRightHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.right],(t,n,r)=>Dx(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`right`),$(e.options,wx,`getRightHeaderGroups`)),e.getFooterGroups=Q(()=>[e.getHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getFooterGroups`)),e.getLeftFooterGroups=Q(()=>[e.getLeftHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getLeftFooterGroups`)),e.getCenterFooterGroups=Q(()=>[e.getCenterHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getCenterFooterGroups`)),e.getRightFooterGroups=Q(()=>[e.getRightHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getRightFooterGroups`)),e.getFlatHeaders=Q(()=>[e.getHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getFlatHeaders`)),e.getLeftFlatHeaders=Q(()=>[e.getLeftHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getLeftFlatHeaders`)),e.getCenterFlatHeaders=Q(()=>[e.getCenterHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getCenterFlatHeaders`)),e.getRightFlatHeaders=Q(()=>[e.getRightHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getRightFlatHeaders`)),e.getCenterLeafHeaders=Q(()=>[e.getCenterFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getCenterLeafHeaders`)),e.getLeftLeafHeaders=Q(()=>[e.getLeftFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getLeftLeafHeaders`)),e.getRightLeafHeaders=Q(()=>[e.getRightFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getRightLeafHeaders`)),e.getLeafHeaders=Q(()=>[e.getLeftHeaderGroups(),e.getCenterHeaderGroups(),e.getRightHeaderGroups()],(e,t,n)=>[...e[0]?.headers??[],...t[0]?.headers??[],...n[0]?.headers??[]].map(e=>e.getLeafHeaders()).flat(),$(e.options,wx,`getLeafHeaders`))}};function Dx(e,t,n,r){let i=0,a=function(e,t){t===void 0&&(t=1),i=Math.max(i,t),e.filter(e=>e.getIsVisible()).forEach(e=>{var n;(n=e.columns)!=null&&n.length&&a(e.columns,t+1)},0)};a(e);let o=[],s=(e,t)=>{let i={depth:t,id:[r,`${t}`].filter(Boolean).join(`_`),headers:[]},a=[];e.forEach(e=>{let o=[...a].reverse()[0],s=e.column.depth===i.depth,c,l=!1;if(s&&e.column.parent?c=e.column.parent:(c=e.column,l=!0),o&&o?.column===c)o.subHeaders.push(e);else{let i=Tx(n,c,{id:[r,t,c.id,e?.id].filter(Boolean).join(`_`),isPlaceholder:l,placeholderId:l?`${a.filter(e=>e.column===c).length}`:void 0,depth:t,index:a.length});i.subHeaders.push(e),a.push(i)}i.headers.push(e),e.headerGroup=i}),o.push(i),t>0&&s(a,t-1)};s(t.map((e,t)=>Tx(n,e,{depth:i,index:t})),i-1),o.reverse();let c=e=>e.filter(e=>e.column.getIsVisible()).map(e=>{let t=0,n=0,r=[0];e.subHeaders&&e.subHeaders.length?(r=[],c(e.subHeaders).forEach(e=>{let{colSpan:n,rowSpan:i}=e;t+=n,r.push(i)})):t=1;let i=Math.min(...r);return n+=i,e.colSpan=t,e.rowSpan=n,{colSpan:t,rowSpan:n}});return c(o[0]?.headers??[]),o}var Ox=(e,t,n,r,i,a,o)=>{let s={id:t,index:r,original:n,depth:i,parentId:o,_valuesCache:{},_uniqueValuesCache:{},getValue:t=>{if(s._valuesCache.hasOwnProperty(t))return s._valuesCache[t];let n=e.getColumn(t);if(n!=null&&n.accessorFn)return s._valuesCache[t]=n.accessorFn(s.original,r),s._valuesCache[t]},getUniqueValues:t=>{if(s._uniqueValuesCache.hasOwnProperty(t))return s._uniqueValuesCache[t];let n=e.getColumn(t);if(n!=null&&n.accessorFn)return n.columnDef.getUniqueValues?(s._uniqueValuesCache[t]=n.columnDef.getUniqueValues(s.original,r),s._uniqueValuesCache[t]):(s._uniqueValuesCache[t]=[s.getValue(t)],s._uniqueValuesCache[t])},renderValue:t=>s.getValue(t)??e.options.renderFallbackValue,subRows:a??[],getLeafRows:()=>xx(s.subRows,e=>e.subRows),getParentRow:()=>s.parentId?e.getRow(s.parentId,!0):void 0,getParentRows:()=>{let e=[],t=s;for(;;){let n=t.getParentRow();if(!n)break;e.push(n),t=n}return e.reverse()},getAllCells:Q(()=>[e.getAllLeafColumns()],t=>t.map(t=>Sx(e,s,t,t.id)),$(e.options,`debugRows`,`getAllCells`)),_getAllCellsByColumnId:Q(()=>[s.getAllCells()],e=>e.reduce((e,t)=>(e[t.column.id]=t,e),{}),$(e.options,`debugRows`,`getAllCellsByColumnId`))};for(let t=0;t<e._features.length;t++){let n=e._features[t];n==null||n.createRow==null||n.createRow(s,e)}return s},kx={createColumn:(e,t)=>{e._getFacetedRowModel=t.options.getFacetedRowModel&&t.options.getFacetedRowModel(t,e.id),e.getFacetedRowModel=()=>e._getFacetedRowModel?e._getFacetedRowModel():t.getPreFilteredRowModel(),e._getFacetedUniqueValues=t.options.getFacetedUniqueValues&&t.options.getFacetedUniqueValues(t,e.id),e.getFacetedUniqueValues=()=>e._getFacetedUniqueValues?e._getFacetedUniqueValues():new Map,e._getFacetedMinMaxValues=t.options.getFacetedMinMaxValues&&t.options.getFacetedMinMaxValues(t,e.id),e.getFacetedMinMaxValues=()=>{if(e._getFacetedMinMaxValues)return e._getFacetedMinMaxValues()}}},Ax=(e,t,n)=>{var r,i;let a=n==null||(r=n.toString())==null?void 0:r.toLowerCase();return!!((i=e.getValue(t))!=null&&(i=i.toString())!=null&&(i=i.toLowerCase())!=null&&i.includes(a))};Ax.autoRemove=e=>Bx(e);var jx=(e,t,n)=>{var r;return!!((r=e.getValue(t))!=null&&(r=r.toString())!=null&&r.includes(n))};jx.autoRemove=e=>Bx(e);var Mx=(e,t,n)=>{var r;return((r=e.getValue(t))==null||(r=r.toString())==null?void 0:r.toLowerCase())===n?.toLowerCase()};Mx.autoRemove=e=>Bx(e);var Nx=(e,t,n)=>e.getValue(t)?.includes(n);Nx.autoRemove=e=>Bx(e);var Px=(e,t,n)=>!n.some(n=>{var r;return!((r=e.getValue(t))!=null&&r.includes(n))});Px.autoRemove=e=>Bx(e)||!(e!=null&&e.length);var Fx=(e,t,n)=>n.some(n=>e.getValue(t)?.includes(n));Fx.autoRemove=e=>Bx(e)||!(e!=null&&e.length);var Ix=(e,t,n)=>e.getValue(t)===n;Ix.autoRemove=e=>Bx(e);var Lx=(e,t,n)=>e.getValue(t)==n;Lx.autoRemove=e=>Bx(e);var Rx=(e,t,n)=>{let[r,i]=n,a=e.getValue(t);return a>=r&&a<=i};Rx.resolveFilterValue=e=>{let[t,n]=e,r=typeof t==`number`?t:parseFloat(t),i=typeof n==`number`?n:parseFloat(n),a=t===null||Number.isNaN(r)?-1/0:r,o=n===null||Number.isNaN(i)?1/0:i;if(a>o){let e=a;a=o,o=e}return[a,o]},Rx.autoRemove=e=>Bx(e)||Bx(e[0])&&Bx(e[1]);var zx={includesString:Ax,includesStringSensitive:jx,equalsString:Mx,arrIncludes:Nx,arrIncludesAll:Px,arrIncludesSome:Fx,equals:Ix,weakEquals:Lx,inNumberRange:Rx};function Bx(e){return e==null||e===``}var Vx={getDefaultColumnDef:()=>({filterFn:`auto`}),getInitialState:e=>({columnFilters:[],...e}),getDefaultOptions:e=>({onColumnFiltersChange:vx(`columnFilters`,e),filterFromLeafRows:!1,maxLeafRowFilterDepth:100}),createColumn:(e,t)=>{e.getAutoFilterFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);return typeof n==`string`?zx.includesString:typeof n==`number`?zx.inNumberRange:typeof n==`boolean`||typeof n==`object`&&n?zx.equals:Array.isArray(n)?zx.arrIncludes:zx.weakEquals},e.getFilterFn=()=>yx(e.columnDef.filterFn)?e.columnDef.filterFn:e.columnDef.filterFn===`auto`?e.getAutoFilterFn():t.options.filterFns?.[e.columnDef.filterFn]??zx[e.columnDef.filterFn],e.getCanFilter=()=>(e.columnDef.enableColumnFilter??!0)&&(t.options.enableColumnFilters??!0)&&(t.options.enableFilters??!0)&&!!e.accessorFn,e.getIsFiltered=()=>e.getFilterIndex()>-1,e.getFilterValue=()=>{var n;return(n=t.getState().columnFilters)==null||(n=n.find(t=>t.id===e.id))==null?void 0:n.value},e.getFilterIndex=()=>t.getState().columnFilters?.findIndex(t=>t.id===e.id)??-1,e.setFilterValue=n=>{t.setColumnFilters(t=>{let r=e.getFilterFn(),i=t?.find(t=>t.id===e.id),a=_x(n,i?i.value:void 0);if(Hx(r,a,e))return t?.filter(t=>t.id!==e.id)??[];let o={id:e.id,value:a};return i?t?.map(t=>t.id===e.id?o:t)??[]:t!=null&&t.length?[...t,o]:[o]})}},createRow:(e,t)=>{e.columnFilters={},e.columnFiltersMeta={}},createTable:e=>{e.setColumnFilters=t=>{let n=e.getAllLeafColumns();e.options.onColumnFiltersChange==null||e.options.onColumnFiltersChange(e=>_x(t,e)?.filter(e=>{let t=n.find(t=>t.id===e.id);return!(t&&Hx(t.getFilterFn(),e.value,t))}))},e.resetColumnFilters=t=>{e.setColumnFilters(t?[]:e.initialState?.columnFilters??[])},e.getPreFilteredRowModel=()=>e.getCoreRowModel(),e.getFilteredRowModel=()=>(!e._getFilteredRowModel&&e.options.getFilteredRowModel&&(e._getFilteredRowModel=e.options.getFilteredRowModel(e)),e.options.manualFiltering||!e._getFilteredRowModel?e.getPreFilteredRowModel():e._getFilteredRowModel())}};function Hx(e,t,n){return(e&&e.autoRemove?e.autoRemove(t,n):!1)||t===void 0||typeof t==`string`&&!t}var Ux={sum:(e,t,n)=>n.reduce((t,n)=>{let r=n.getValue(e);return t+(typeof r==`number`?r:0)},0),min:(e,t,n)=>{let r;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r>n||r===void 0&&n>=n)&&(r=n)}),r},max:(e,t,n)=>{let r;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r<n||r===void 0&&n>=n)&&(r=n)}),r},extent:(e,t,n)=>{let r,i;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r===void 0?n>=n&&(r=i=n):(r>n&&(r=n),i<n&&(i=n)))}),[r,i]},mean:(e,t)=>{let n=0,r=0;if(t.forEach(t=>{let i=t.getValue(e);i!=null&&(i=+i)>=i&&(++n,r+=i)}),n)return r/n},median:(e,t)=>{if(!t.length)return;let n=t.map(t=>t.getValue(e));if(!bx(n))return;if(n.length===1)return n[0];let r=Math.floor(n.length/2),i=n.sort((e,t)=>e-t);return n.length%2==0?(i[r-1]+i[r])/2:i[r]},unique:(e,t)=>Array.from(new Set(t.map(t=>t.getValue(e))).values()),uniqueCount:(e,t)=>new Set(t.map(t=>t.getValue(e))).size,count:(e,t)=>t.length},Wx={getDefaultColumnDef:()=>({aggregatedCell:e=>{var t;return((t=e.getValue())==null||t.toString==null?void 0:t.toString())??null},aggregationFn:`auto`}),getInitialState:e=>({grouping:[],...e}),getDefaultOptions:e=>({onGroupingChange:vx(`grouping`,e),groupedColumnMode:`reorder`}),createColumn:(e,t)=>{e.toggleGrouping=()=>{t.setGrouping(t=>t!=null&&t.includes(e.id)?t.filter(t=>t!==e.id):[...t??[],e.id])},e.getCanGroup=()=>(e.columnDef.enableGrouping??!0)&&(t.options.enableGrouping??!0)&&(!!e.accessorFn||!!e.columnDef.getGroupingValue),e.getIsGrouped=()=>t.getState().grouping?.includes(e.id),e.getGroupedIndex=()=>t.getState().grouping?.indexOf(e.id),e.getToggleGroupingHandler=()=>{let t=e.getCanGroup();return()=>{t&&e.toggleGrouping()}},e.getAutoAggregationFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);if(typeof n==`number`)return Ux.sum;if(Object.prototype.toString.call(n)===`[object Date]`)return Ux.extent},e.getAggregationFn=()=>{if(!e)throw Error();return yx(e.columnDef.aggregationFn)?e.columnDef.aggregationFn:e.columnDef.aggregationFn===`auto`?e.getAutoAggregationFn():t.options.aggregationFns?.[e.columnDef.aggregationFn]??Ux[e.columnDef.aggregationFn]}},createTable:e=>{e.setGrouping=t=>e.options.onGroupingChange==null?void 0:e.options.onGroupingChange(t),e.resetGrouping=t=>{e.setGrouping(t?[]:e.initialState?.grouping??[])},e.getPreGroupedRowModel=()=>e.getFilteredRowModel(),e.getGroupedRowModel=()=>(!e._getGroupedRowModel&&e.options.getGroupedRowModel&&(e._getGroupedRowModel=e.options.getGroupedRowModel(e)),e.options.manualGrouping||!e._getGroupedRowModel?e.getPreGroupedRowModel():e._getGroupedRowModel())},createRow:(e,t)=>{e.getIsGrouped=()=>!!e.groupingColumnId,e.getGroupingValue=n=>{if(e._groupingValuesCache.hasOwnProperty(n))return e._groupingValuesCache[n];let r=t.getColumn(n);return r!=null&&r.columnDef.getGroupingValue?(e._groupingValuesCache[n]=r.columnDef.getGroupingValue(e.original),e._groupingValuesCache[n]):e.getValue(n)},e._groupingValuesCache={}},createCell:(e,t,n,r)=>{e.getIsGrouped=()=>t.getIsGrouped()&&t.id===n.groupingColumnId,e.getIsPlaceholder=()=>!e.getIsGrouped()&&t.getIsGrouped(),e.getIsAggregated=()=>{var t;return!e.getIsGrouped()&&!e.getIsPlaceholder()&&!!((t=n.subRows)!=null&&t.length)}}};function Gx(e,t,n){if(!(t!=null&&t.length)||!n)return e;let r=e.filter(e=>!t.includes(e.id));return n===`remove`?r:[...t.map(t=>e.find(e=>e.id===t)).filter(Boolean),...r]}var Kx={getInitialState:e=>({columnOrder:[],...e}),getDefaultOptions:e=>({onColumnOrderChange:vx(`columnOrder`,e)}),createColumn:(e,t)=>{e.getIndex=Q(e=>[rS(t,e)],t=>t.findIndex(t=>t.id===e.id),$(t.options,`debugColumns`,`getIndex`)),e.getIsFirstColumn=n=>rS(t,n)[0]?.id===e.id,e.getIsLastColumn=n=>{let r=rS(t,n);return r[r.length-1]?.id===e.id}},createTable:e=>{e.setColumnOrder=t=>e.options.onColumnOrderChange==null?void 0:e.options.onColumnOrderChange(t),e.resetColumnOrder=t=>{e.setColumnOrder(t?[]:e.initialState.columnOrder??[])},e._getOrderColumnsFn=Q(()=>[e.getState().columnOrder,e.getState().grouping,e.options.groupedColumnMode],(e,t,n)=>r=>{let i=[];if(!(e!=null&&e.length))i=r;else{let t=[...e],n=[...r];for(;n.length&&t.length;){let e=t.shift(),r=n.findIndex(t=>t.id===e);r>-1&&i.push(n.splice(r,1)[0])}i=[...i,...n]}return Gx(i,t,n)},$(e.options,`debugTable`,`_getOrderColumnsFn`))}},qx=()=>({left:[],right:[]}),Jx={getInitialState:e=>({columnPinning:qx(),...e}),getDefaultOptions:e=>({onColumnPinningChange:vx(`columnPinning`,e)}),createColumn:(e,t)=>{e.pin=n=>{let r=e.getLeafColumns().map(e=>e.id).filter(Boolean);t.setColumnPinning(e=>n===`right`?{left:(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),right:[...(e?.right??[]).filter(e=>!(r!=null&&r.includes(e))),...r]}:n===`left`?{left:[...(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),...r],right:(e?.right??[]).filter(e=>!(r!=null&&r.includes(e)))}:{left:(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),right:(e?.right??[]).filter(e=>!(r!=null&&r.includes(e)))})},e.getCanPin=()=>e.getLeafColumns().some(e=>(e.columnDef.enablePinning??!0)&&(t.options.enableColumnPinning??t.options.enablePinning??!0)),e.getIsPinned=()=>{let n=e.getLeafColumns().map(e=>e.id),{left:r,right:i}=t.getState().columnPinning,a=n.some(e=>r?.includes(e)),o=n.some(e=>i?.includes(e));return a?`left`:o?`right`:!1},e.getPinnedIndex=()=>{var n;let r=e.getIsPinned();return r?((n=t.getState().columnPinning)==null||(n=n[r])==null?void 0:n.indexOf(e.id))??-1:0}},createRow:(e,t)=>{e.getCenterVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.left,t.getState().columnPinning.right],(e,t,n)=>{let r=[...t??[],...n??[]];return e.filter(e=>!r.includes(e.column.id))},$(t.options,`debugRows`,`getCenterVisibleCells`)),e.getLeftVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.column.id===t)).filter(Boolean).map(e=>({...e,position:`left`})),$(t.options,`debugRows`,`getLeftVisibleCells`)),e.getRightVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.column.id===t)).filter(Boolean).map(e=>({...e,position:`right`})),$(t.options,`debugRows`,`getRightVisibleCells`))},createTable:e=>{e.setColumnPinning=t=>e.options.onColumnPinningChange==null?void 0:e.options.onColumnPinningChange(t),e.resetColumnPinning=t=>e.setColumnPinning(t?qx():e.initialState?.columnPinning??qx()),e.getIsSomeColumnsPinned=t=>{let n=e.getState().columnPinning;return t?!!n[t]?.length:!!(n.left?.length||n.right?.length)},e.getLeftLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),$(e.options,`debugColumns`,`getLeftLeafColumns`)),e.getRightLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),$(e.options,`debugColumns`,`getRightLeafColumns`)),e.getCenterLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(e,t,n)=>{let r=[...t??[],...n??[]];return e.filter(e=>!r.includes(e.id))},$(e.options,`debugColumns`,`getCenterLeafColumns`))}};function Yx(e){return e||(typeof document<`u`?document:null)}var Xx={size:150,minSize:20,maxSize:2**53-1},Zx=()=>({startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,isResizingColumn:!1,columnSizingStart:[]}),Qx={getDefaultColumnDef:()=>Xx,getInitialState:e=>({columnSizing:{},columnSizingInfo:Zx(),...e}),getDefaultOptions:e=>({columnResizeMode:`onEnd`,columnResizeDirection:`ltr`,onColumnSizingChange:vx(`columnSizing`,e),onColumnSizingInfoChange:vx(`columnSizingInfo`,e)}),createColumn:(e,t)=>{e.getSize=()=>{let n=t.getState().columnSizing[e.id];return Math.min(Math.max(e.columnDef.minSize??Xx.minSize,n??e.columnDef.size??Xx.size),e.columnDef.maxSize??Xx.maxSize)},e.getStart=Q(e=>[e,rS(t,e),t.getState().columnSizing],(t,n)=>n.slice(0,e.getIndex(t)).reduce((e,t)=>e+t.getSize(),0),$(t.options,`debugColumns`,`getStart`)),e.getAfter=Q(e=>[e,rS(t,e),t.getState().columnSizing],(t,n)=>n.slice(e.getIndex(t)+1).reduce((e,t)=>e+t.getSize(),0),$(t.options,`debugColumns`,`getAfter`)),e.resetSize=()=>{t.setColumnSizing(t=>{let{[e.id]:n,...r}=t;return r})},e.getCanResize=()=>(e.columnDef.enableResizing??!0)&&(t.options.enableColumnResizing??!0),e.getIsResizing=()=>t.getState().columnSizingInfo.isResizingColumn===e.id},createHeader:(e,t)=>{e.getSize=()=>{let t=0,n=e=>{e.subHeaders.length?e.subHeaders.forEach(n):t+=e.column.getSize()??0};return n(e),t},e.getStart=()=>{if(e.index>0){let t=e.headerGroup.headers[e.index-1];return t.getStart()+t.getSize()}return 0},e.getResizeHandler=n=>{let r=t.getColumn(e.column.id),i=r?.getCanResize();return a=>{if(!r||!i||(a.persist==null||a.persist(),tS(a)&&a.touches&&a.touches.length>1))return;let o=e.getSize(),s=e?e.getLeafHeaders().map(e=>[e.column.id,e.column.getSize()]):[[r.id,r.getSize()]],c=tS(a)?Math.round(a.touches[0].clientX):a.clientX,l={},u=(e,n)=>{typeof n==`number`&&(t.setColumnSizingInfo(e=>{let r=t.options.columnResizeDirection===`rtl`?-1:1,i=(n-(e?.startOffset??0))*r,a=Math.max(i/(e?.startSize??0),-.999999);return e.columnSizingStart.forEach(e=>{let[t,n]=e;l[t]=Math.round(Math.max(n+n*a,0)*100)/100}),{...e,deltaOffset:i,deltaPercentage:a}}),(t.options.columnResizeMode===`onChange`||e===`end`)&&t.setColumnSizing(e=>({...e,...l})))},d=e=>u(`move`,e),f=e=>{u(`end`,e),t.setColumnSizingInfo(e=>({...e,isResizingColumn:!1,startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,columnSizingStart:[]}))},p=Yx(n),m={moveHandler:e=>d(e.clientX),upHandler:e=>{p?.removeEventListener(`mousemove`,m.moveHandler),p?.removeEventListener(`mouseup`,m.upHandler),f(e.clientX)}},h={moveHandler:e=>(e.cancelable&&(e.preventDefault(),e.stopPropagation()),d(e.touches[0].clientX),!1),upHandler:e=>{p?.removeEventListener(`touchmove`,h.moveHandler),p?.removeEventListener(`touchend`,h.upHandler),e.cancelable&&(e.preventDefault(),e.stopPropagation()),f(e.touches[0]?.clientX)}},g=eS()?{passive:!1}:!1;tS(a)?(p?.addEventListener(`touchmove`,h.moveHandler,g),p?.addEventListener(`touchend`,h.upHandler,g)):(p?.addEventListener(`mousemove`,m.moveHandler,g),p?.addEventListener(`mouseup`,m.upHandler,g)),t.setColumnSizingInfo(e=>({...e,startOffset:c,startSize:o,deltaOffset:0,deltaPercentage:0,columnSizingStart:s,isResizingColumn:r.id}))}}},createTable:e=>{e.setColumnSizing=t=>e.options.onColumnSizingChange==null?void 0:e.options.onColumnSizingChange(t),e.setColumnSizingInfo=t=>e.options.onColumnSizingInfoChange==null?void 0:e.options.onColumnSizingInfoChange(t),e.resetColumnSizing=t=>{e.setColumnSizing(t?{}:e.initialState.columnSizing??{})},e.resetHeaderSizeInfo=t=>{e.setColumnSizingInfo(t?Zx():e.initialState.columnSizingInfo??Zx())},e.getTotalSize=()=>e.getHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getLeftTotalSize=()=>e.getLeftHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getCenterTotalSize=()=>e.getCenterHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getRightTotalSize=()=>e.getRightHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0}},$x=null;function eS(){if(typeof $x==`boolean`)return $x;let e=!1;try{let t={get passive(){return e=!0,!1}},n=()=>{};window.addEventListener(`test`,n,t),window.removeEventListener(`test`,n)}catch{e=!1}return $x=e,$x}function tS(e){return e.type===`touchstart`}var nS={getInitialState:e=>({columnVisibility:{},...e}),getDefaultOptions:e=>({onColumnVisibilityChange:vx(`columnVisibility`,e)}),createColumn:(e,t)=>{e.toggleVisibility=n=>{e.getCanHide()&&t.setColumnVisibility(t=>({...t,[e.id]:n??!e.getIsVisible()}))},e.getIsVisible=()=>{let n=e.columns;return(n.length?n.some(e=>e.getIsVisible()):t.getState().columnVisibility?.[e.id])??!0},e.getCanHide=()=>(e.columnDef.enableHiding??!0)&&(t.options.enableHiding??!0),e.getToggleVisibilityHandler=()=>t=>{e.toggleVisibility==null||e.toggleVisibility(t.target.checked)}},createRow:(e,t)=>{e._getAllVisibleCells=Q(()=>[e.getAllCells(),t.getState().columnVisibility],e=>e.filter(e=>e.column.getIsVisible()),$(t.options,`debugRows`,`_getAllVisibleCells`)),e.getVisibleCells=Q(()=>[e.getLeftVisibleCells(),e.getCenterVisibleCells(),e.getRightVisibleCells()],(e,t,n)=>[...e,...t,...n],$(t.options,`debugRows`,`getVisibleCells`))},createTable:e=>{let t=(t,n)=>Q(()=>[n(),n().filter(e=>e.getIsVisible()).map(e=>e.id).join(`_`)],e=>e.filter(e=>e.getIsVisible==null?void 0:e.getIsVisible()),$(e.options,`debugColumns`,t));e.getVisibleFlatColumns=t(`getVisibleFlatColumns`,()=>e.getAllFlatColumns()),e.getVisibleLeafColumns=t(`getVisibleLeafColumns`,()=>e.getAllLeafColumns()),e.getLeftVisibleLeafColumns=t(`getLeftVisibleLeafColumns`,()=>e.getLeftLeafColumns()),e.getRightVisibleLeafColumns=t(`getRightVisibleLeafColumns`,()=>e.getRightLeafColumns()),e.getCenterVisibleLeafColumns=t(`getCenterVisibleLeafColumns`,()=>e.getCenterLeafColumns()),e.setColumnVisibility=t=>e.options.onColumnVisibilityChange==null?void 0:e.options.onColumnVisibilityChange(t),e.resetColumnVisibility=t=>{e.setColumnVisibility(t?{}:e.initialState.columnVisibility??{})},e.toggleAllColumnsVisible=t=>{t??=!e.getIsAllColumnsVisible(),e.setColumnVisibility(e.getAllLeafColumns().reduce((e,n)=>({...e,[n.id]:t||!(n.getCanHide!=null&&n.getCanHide())}),{}))},e.getIsAllColumnsVisible=()=>!e.getAllLeafColumns().some(e=>!(e.getIsVisible!=null&&e.getIsVisible())),e.getIsSomeColumnsVisible=()=>e.getAllLeafColumns().some(e=>e.getIsVisible==null?void 0:e.getIsVisible()),e.getToggleAllColumnsVisibilityHandler=()=>t=>{e.toggleAllColumnsVisible(t.target?.checked)}}};function rS(e,t){return t?t===`center`?e.getCenterVisibleLeafColumns():t===`left`?e.getLeftVisibleLeafColumns():e.getRightVisibleLeafColumns():e.getVisibleLeafColumns()}var iS={createTable:e=>{e._getGlobalFacetedRowModel=e.options.getFacetedRowModel&&e.options.getFacetedRowModel(e,`__global__`),e.getGlobalFacetedRowModel=()=>e.options.manualFiltering||!e._getGlobalFacetedRowModel?e.getPreFilteredRowModel():e._getGlobalFacetedRowModel(),e._getGlobalFacetedUniqueValues=e.options.getFacetedUniqueValues&&e.options.getFacetedUniqueValues(e,`__global__`),e.getGlobalFacetedUniqueValues=()=>e._getGlobalFacetedUniqueValues?e._getGlobalFacetedUniqueValues():new Map,e._getGlobalFacetedMinMaxValues=e.options.getFacetedMinMaxValues&&e.options.getFacetedMinMaxValues(e,`__global__`),e.getGlobalFacetedMinMaxValues=()=>{if(e._getGlobalFacetedMinMaxValues)return e._getGlobalFacetedMinMaxValues()}}},aS={getInitialState:e=>({globalFilter:void 0,...e}),getDefaultOptions:e=>({onGlobalFilterChange:vx(`globalFilter`,e),globalFilterFn:`auto`,getColumnCanGlobalFilter:t=>{var n;let r=(n=e.getCoreRowModel().flatRows[0])==null||(n=n._getAllCellsByColumnId()[t.id])==null?void 0:n.getValue();return typeof r==`string`||typeof r==`number`}}),createColumn:(e,t)=>{e.getCanGlobalFilter=()=>(e.columnDef.enableGlobalFilter??!0)&&(t.options.enableGlobalFilter??!0)&&(t.options.enableFilters??!0)&&((t.options.getColumnCanGlobalFilter==null?void 0:t.options.getColumnCanGlobalFilter(e))??!0)&&!!e.accessorFn},createTable:e=>{e.getGlobalAutoFilterFn=()=>zx.includesString,e.getGlobalFilterFn=()=>{let{globalFilterFn:t}=e.options;return yx(t)?t:t===`auto`?e.getGlobalAutoFilterFn():e.options.filterFns?.[t]??zx[t]},e.setGlobalFilter=t=>{e.options.onGlobalFilterChange==null||e.options.onGlobalFilterChange(t)},e.resetGlobalFilter=t=>{e.setGlobalFilter(t?void 0:e.initialState.globalFilter)}}},oS={getInitialState:e=>({expanded:{},...e}),getDefaultOptions:e=>({onExpandedChange:vx(`expanded`,e),paginateExpandedRows:!0}),createTable:e=>{let t=!1,n=!1;e._autoResetExpanded=()=>{if(!t){e._queue(()=>{t=!0});return}if(e.options.autoResetAll??e.options.autoResetExpanded??!e.options.manualExpanding){if(n)return;n=!0,e._queue(()=>{e.resetExpanded(),n=!1})}},e.setExpanded=t=>e.options.onExpandedChange==null?void 0:e.options.onExpandedChange(t),e.toggleAllRowsExpanded=t=>{t??!e.getIsAllRowsExpanded()?e.setExpanded(!0):e.setExpanded({})},e.resetExpanded=t=>{e.setExpanded(t?{}:e.initialState?.expanded??{})},e.getCanSomeRowsExpand=()=>e.getPrePaginationRowModel().flatRows.some(e=>e.getCanExpand()),e.getToggleAllRowsExpandedHandler=()=>t=>{t.persist==null||t.persist(),e.toggleAllRowsExpanded()},e.getIsSomeRowsExpanded=()=>{let t=e.getState().expanded;return t===!0||Object.values(t).some(Boolean)},e.getIsAllRowsExpanded=()=>{let t=e.getState().expanded;return typeof t==`boolean`?t===!0:!(!Object.keys(t).length||e.getRowModel().flatRows.some(e=>!e.getIsExpanded()))},e.getExpandedDepth=()=>{let t=0;return(e.getState().expanded===!0?Object.keys(e.getRowModel().rowsById):Object.keys(e.getState().expanded)).forEach(e=>{let n=e.split(`.`);t=Math.max(t,n.length)}),t},e.getPreExpandedRowModel=()=>e.getSortedRowModel(),e.getExpandedRowModel=()=>(!e._getExpandedRowModel&&e.options.getExpandedRowModel&&(e._getExpandedRowModel=e.options.getExpandedRowModel(e)),e.options.manualExpanding||!e._getExpandedRowModel?e.getPreExpandedRowModel():e._getExpandedRowModel())},createRow:(e,t)=>{e.toggleExpanded=n=>{t.setExpanded(r=>{let i=r===!0||!!(r!=null&&r[e.id]),a={};if(r===!0?Object.keys(t.getRowModel().rowsById).forEach(e=>{a[e]=!0}):a=r,n??=!i,!i&&n)return{...a,[e.id]:!0};if(i&&!n){let{[e.id]:t,...n}=a;return n}return r})},e.getIsExpanded=()=>{let n=t.getState().expanded;return!!((t.options.getIsRowExpanded==null?void 0:t.options.getIsRowExpanded(e))??(n===!0||n?.[e.id]))},e.getCanExpand=()=>{var n;return(t.options.getRowCanExpand==null?void 0:t.options.getRowCanExpand(e))??((t.options.enableExpanding??!0)&&!!((n=e.subRows)!=null&&n.length))},e.getIsAllParentsExpanded=()=>{let n=!0,r=e;for(;n&&r.parentId;)r=t.getRow(r.parentId,!0),n=r.getIsExpanded();return n},e.getToggleExpandedHandler=()=>{let t=e.getCanExpand();return()=>{t&&e.toggleExpanded()}}}},sS=0,cS=10,lS=()=>({pageIndex:sS,pageSize:cS}),uS={getInitialState:e=>({...e,pagination:{...lS(),...e?.pagination}}),getDefaultOptions:e=>({onPaginationChange:vx(`pagination`,e)}),createTable:e=>{let t=!1,n=!1;e._autoResetPageIndex=()=>{if(!t){e._queue(()=>{t=!0});return}if(e.options.autoResetAll??e.options.autoResetPageIndex??!e.options.manualPagination){if(n)return;n=!0,e._queue(()=>{e.resetPageIndex(),n=!1})}},e.setPagination=t=>e.options.onPaginationChange==null?void 0:e.options.onPaginationChange(e=>_x(t,e)),e.resetPagination=t=>{e.setPagination(t?lS():e.initialState.pagination??lS())},e.setPageIndex=t=>{e.setPagination(n=>{let r=_x(t,n.pageIndex),i=e.options.pageCount===void 0||e.options.pageCount===-1?2**53-1:e.options.pageCount-1;return r=Math.max(0,Math.min(r,i)),{...n,pageIndex:r}})},e.resetPageIndex=t=>{var n;e.setPageIndex(t?sS:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageIndex)??sS)},e.resetPageSize=t=>{var n;e.setPageSize(t?cS:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageSize)??cS)},e.setPageSize=t=>{e.setPagination(e=>{let n=Math.max(1,_x(t,e.pageSize)),r=e.pageSize*e.pageIndex,i=Math.floor(r/n);return{...e,pageIndex:i,pageSize:n}})},e.setPageCount=t=>e.setPagination(n=>{let r=_x(t,e.options.pageCount??-1);return typeof r==`number`&&(r=Math.max(-1,r)),{...n,pageCount:r}}),e.getPageOptions=Q(()=>[e.getPageCount()],e=>{let t=[];return e&&e>0&&(t=[...Array(e)].fill(null).map((e,t)=>t)),t},$(e.options,`debugTable`,`getPageOptions`)),e.getCanPreviousPage=()=>e.getState().pagination.pageIndex>0,e.getCanNextPage=()=>{let{pageIndex:t}=e.getState().pagination,n=e.getPageCount();return n===-1||n!==0&&t<n-1},e.previousPage=()=>e.setPageIndex(e=>e-1),e.nextPage=()=>e.setPageIndex(e=>e+1),e.firstPage=()=>e.setPageIndex(0),e.lastPage=()=>e.setPageIndex(e.getPageCount()-1),e.getPrePaginationRowModel=()=>e.getExpandedRowModel(),e.getPaginationRowModel=()=>(!e._getPaginationRowModel&&e.options.getPaginationRowModel&&(e._getPaginationRowModel=e.options.getPaginationRowModel(e)),e.options.manualPagination||!e._getPaginationRowModel?e.getPrePaginationRowModel():e._getPaginationRowModel()),e.getPageCount=()=>e.options.pageCount??Math.ceil(e.getRowCount()/e.getState().pagination.pageSize),e.getRowCount=()=>e.options.rowCount??e.getPrePaginationRowModel().rows.length}},dS=()=>({top:[],bottom:[]}),fS={getInitialState:e=>({rowPinning:dS(),...e}),getDefaultOptions:e=>({onRowPinningChange:vx(`rowPinning`,e)}),createRow:(e,t)=>{e.pin=(n,r,i)=>{let a=r?e.getLeafRows().map(e=>{let{id:t}=e;return t}):[],o=i?e.getParentRows().map(e=>{let{id:t}=e;return t}):[],s=new Set([...o,e.id,...a]);t.setRowPinning(e=>n===`bottom`?{top:(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),bottom:[...(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e))),...Array.from(s)]}:n===`top`?{top:[...(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),...Array.from(s)],bottom:(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e)))}:{top:(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),bottom:(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e)))})},e.getCanPin=()=>{let{enableRowPinning:n,enablePinning:r}=t.options;return typeof n==`function`?n(e):n??r??!0},e.getIsPinned=()=>{let n=[e.id],{top:r,bottom:i}=t.getState().rowPinning,a=n.some(e=>r?.includes(e)),o=n.some(e=>i?.includes(e));return a?`top`:o?`bottom`:!1},e.getPinnedIndex=()=>{let n=e.getIsPinned();return n?((n===`top`?t.getTopRows():t.getBottomRows())?.map(e=>{let{id:t}=e;return t}))?.indexOf(e.id)??-1:-1}},createTable:e=>{e.setRowPinning=t=>e.options.onRowPinningChange==null?void 0:e.options.onRowPinningChange(t),e.resetRowPinning=t=>e.setRowPinning(t?dS():e.initialState?.rowPinning??dS()),e.getIsSomeRowsPinned=t=>{let n=e.getState().rowPinning;return t?!!n[t]?.length:!!(n.top?.length||n.bottom?.length)},e._getPinnedRows=(t,n,r)=>(e.options.keepPinnedRows??!0?(n??[]).map(t=>{let n=e.getRow(t,!0);return n.getIsAllParentsExpanded()?n:null}):(n??[]).map(e=>t.find(t=>t.id===e))).filter(Boolean).map(e=>({...e,position:r})),e.getTopRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.top],(t,n)=>e._getPinnedRows(t,n,`top`),$(e.options,`debugRows`,`getTopRows`)),e.getBottomRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.bottom],(t,n)=>e._getPinnedRows(t,n,`bottom`),$(e.options,`debugRows`,`getBottomRows`)),e.getCenterRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.top,e.getState().rowPinning.bottom],(e,t,n)=>{let r=new Set([...t??[],...n??[]]);return e.filter(e=>!r.has(e.id))},$(e.options,`debugRows`,`getCenterRows`))}},pS={getInitialState:e=>({rowSelection:{},...e}),getDefaultOptions:e=>({onRowSelectionChange:vx(`rowSelection`,e),enableRowSelection:!0,enableMultiRowSelection:!0,enableSubRowSelection:!0}),createTable:e=>{e.setRowSelection=t=>e.options.onRowSelectionChange==null?void 0:e.options.onRowSelectionChange(t),e.resetRowSelection=t=>e.setRowSelection(t?{}:e.initialState.rowSelection??{}),e.toggleAllRowsSelected=t=>{e.setRowSelection(n=>{t=t===void 0?!e.getIsAllRowsSelected():t;let r={...n},i=e.getPreGroupedRowModel().flatRows;return t?i.forEach(e=>{e.getCanSelect()&&(r[e.id]=!0)}):i.forEach(e=>{delete r[e.id]}),r})},e.toggleAllPageRowsSelected=t=>e.setRowSelection(n=>{let r=t===void 0?!e.getIsAllPageRowsSelected():t,i={...n};return e.getRowModel().rows.forEach(t=>{mS(i,t.id,r,!0,e)}),i}),e.getPreSelectedRowModel=()=>e.getCoreRowModel(),e.getSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getCoreRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getSelectedRowModel`)),e.getFilteredSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getFilteredRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getFilteredSelectedRowModel`)),e.getGroupedSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getSortedRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getGroupedSelectedRowModel`)),e.getIsAllRowsSelected=()=>{let t=e.getFilteredRowModel().flatRows,{rowSelection:n}=e.getState(),r=!!(t.length&&Object.keys(n).length);return r&&t.some(e=>e.getCanSelect()&&!n[e.id])&&(r=!1),r},e.getIsAllPageRowsSelected=()=>{let t=e.getPaginationRowModel().flatRows.filter(e=>e.getCanSelect()),{rowSelection:n}=e.getState(),r=!!t.length;return r&&t.some(e=>!n[e.id])&&(r=!1),r},e.getIsSomeRowsSelected=()=>{let t=Object.keys(e.getState().rowSelection??{}).length;return t>0&&t<e.getFilteredRowModel().flatRows.length},e.getIsSomePageRowsSelected=()=>{let t=e.getPaginationRowModel().flatRows;return!e.getIsAllPageRowsSelected()&&t.filter(e=>e.getCanSelect()).some(e=>e.getIsSelected()||e.getIsSomeSelected())},e.getToggleAllRowsSelectedHandler=()=>t=>{e.toggleAllRowsSelected(t.target.checked)},e.getToggleAllPageRowsSelectedHandler=()=>t=>{e.toggleAllPageRowsSelected(t.target.checked)}},createRow:(e,t)=>{e.toggleSelected=(n,r)=>{let i=e.getIsSelected();t.setRowSelection(a=>{if(n=n===void 0?!i:n,e.getCanSelect()&&i===n)return a;let o={...a};return mS(o,e.id,n,r?.selectChildren??!0,t),o})},e.getIsSelected=()=>{let{rowSelection:n}=t.getState();return gS(e,n)},e.getIsSomeSelected=()=>{let{rowSelection:n}=t.getState();return _S(e,n)===`some`},e.getIsAllSubRowsSelected=()=>{let{rowSelection:n}=t.getState();return _S(e,n)===`all`},e.getCanSelect=()=>typeof t.options.enableRowSelection==`function`?t.options.enableRowSelection(e):t.options.enableRowSelection??!0,e.getCanSelectSubRows=()=>typeof t.options.enableSubRowSelection==`function`?t.options.enableSubRowSelection(e):t.options.enableSubRowSelection??!0,e.getCanMultiSelect=()=>typeof t.options.enableMultiRowSelection==`function`?t.options.enableMultiRowSelection(e):t.options.enableMultiRowSelection??!0,e.getToggleSelectedHandler=()=>{let t=e.getCanSelect();return n=>{t&&e.toggleSelected(n.target?.checked)}}}},mS=(e,t,n,r,i)=>{var a;let o=i.getRow(t,!0);n?(o.getCanMultiSelect()||Object.keys(e).forEach(t=>delete e[t]),o.getCanSelect()&&(e[t]=!0)):delete e[t],r&&(a=o.subRows)!=null&&a.length&&o.getCanSelectSubRows()&&o.subRows.forEach(t=>mS(e,t.id,n,r,i))};function hS(e,t){let n=e.getState().rowSelection,r=[],i={},a=function(e,t){return e.map(e=>{var t;let o=gS(e,n);if(o&&(r.push(e),i[e.id]=e),(t=e.subRows)!=null&&t.length&&(e={...e,subRows:a(e.subRows)}),o)return e}).filter(Boolean)};return{rows:a(t.rows),flatRows:r,rowsById:i}}function gS(e,t){return t[e.id]??!1}function _S(e,t,n){var r;if(!((r=e.subRows)!=null&&r.length))return!1;let i=!0,a=!1;return e.subRows.forEach(e=>{if(!(a&&!i)&&(e.getCanSelect()&&(gS(e,t)?a=!0:i=!1),e.subRows&&e.subRows.length)){let n=_S(e,t);n===`all`?a=!0:(n===`some`&&(a=!0),i=!1)}}),i?`all`:a?`some`:!1}var vS=/([0-9]+)/gm,yS=(e,t,n)=>DS(ES(e.getValue(n)).toLowerCase(),ES(t.getValue(n)).toLowerCase()),bS=(e,t,n)=>DS(ES(e.getValue(n)),ES(t.getValue(n))),xS=(e,t,n)=>TS(ES(e.getValue(n)).toLowerCase(),ES(t.getValue(n)).toLowerCase()),SS=(e,t,n)=>TS(ES(e.getValue(n)),ES(t.getValue(n))),CS=(e,t,n)=>{let r=e.getValue(n),i=t.getValue(n);return r>i?1:r<i?-1:0},wS=(e,t,n)=>TS(e.getValue(n),t.getValue(n));function TS(e,t){return e===t?0:e>t?1:-1}function ES(e){return typeof e==`number`?isNaN(e)||e===1/0||e===-1/0?``:String(e):typeof e==`string`?e:``}function DS(e,t){let n=e.split(vS).filter(Boolean),r=t.split(vS).filter(Boolean);for(;n.length&&r.length;){let e=n.shift(),t=r.shift(),i=parseInt(e,10),a=parseInt(t,10),o=[i,a].sort();if(isNaN(o[0])){if(e>t)return 1;if(t>e)return-1;continue}if(isNaN(o[1]))return isNaN(i)?-1:1;if(i>a)return 1;if(a>i)return-1}return n.length-r.length}var OS={alphanumeric:yS,alphanumericCaseSensitive:bS,text:xS,textCaseSensitive:SS,datetime:CS,basic:wS},kS=[Ex,nS,Kx,Jx,kx,Vx,iS,aS,{getInitialState:e=>({sorting:[],...e}),getDefaultColumnDef:()=>({sortingFn:`auto`,sortUndefined:1}),getDefaultOptions:e=>({onSortingChange:vx(`sorting`,e),isMultiSortEvent:e=>e.shiftKey}),createColumn:(e,t)=>{e.getAutoSortingFn=()=>{let n=t.getFilteredRowModel().flatRows.slice(10),r=!1;for(let t of n){let n=t?.getValue(e.id);if(Object.prototype.toString.call(n)===`[object Date]`)return OS.datetime;if(typeof n==`string`&&(r=!0,n.split(vS).length>1))return OS.alphanumeric}return r?OS.text:OS.basic},e.getAutoSortDir=()=>typeof t.getFilteredRowModel().flatRows[0]?.getValue(e.id)==`string`?`asc`:`desc`,e.getSortingFn=()=>{if(!e)throw Error();return yx(e.columnDef.sortingFn)?e.columnDef.sortingFn:e.columnDef.sortingFn===`auto`?e.getAutoSortingFn():t.options.sortingFns?.[e.columnDef.sortingFn]??OS[e.columnDef.sortingFn]},e.toggleSorting=(n,r)=>{let i=e.getNextSortingOrder(),a=n!=null;t.setSorting(o=>{let s=o?.find(t=>t.id===e.id),c=o?.findIndex(t=>t.id===e.id),l=[],u,d=a?n:i===`desc`;return u=o!=null&&o.length&&e.getCanMultiSort()&&r?s?`toggle`:`add`:o!=null&&o.length&&c!==o.length-1?`replace`:s?`toggle`:`replace`,u===`toggle`&&(a||i||(u=`remove`)),u===`add`?(l=[...o,{id:e.id,desc:d}],l.splice(0,l.length-(t.options.maxMultiSortColCount??2**53-1))):l=u===`toggle`?o.map(t=>t.id===e.id?{...t,desc:d}:t):u===`remove`?o.filter(t=>t.id!==e.id):[{id:e.id,desc:d}],l})},e.getFirstSortDir=()=>e.columnDef.sortDescFirst??t.options.sortDescFirst??e.getAutoSortDir()===`desc`?`desc`:`asc`,e.getNextSortingOrder=n=>{let r=e.getFirstSortDir(),i=e.getIsSorted();return i?i!==r&&(t.options.enableSortingRemoval??!0)&&(!n||(t.options.enableMultiRemove??!0))?!1:i===`desc`?`asc`:`desc`:r},e.getCanSort=()=>(e.columnDef.enableSorting??!0)&&(t.options.enableSorting??!0)&&!!e.accessorFn,e.getCanMultiSort=()=>e.columnDef.enableMultiSort??t.options.enableMultiSort??!!e.accessorFn,e.getIsSorted=()=>{let n=t.getState().sorting?.find(t=>t.id===e.id);return n?n.desc?`desc`:`asc`:!1},e.getSortIndex=()=>t.getState().sorting?.findIndex(t=>t.id===e.id)??-1,e.clearSorting=()=>{t.setSorting(t=>t!=null&&t.length?t.filter(t=>t.id!==e.id):[])},e.getToggleSortingHandler=()=>{let n=e.getCanSort();return r=>{n&&(r.persist==null||r.persist(),e.toggleSorting==null||e.toggleSorting(void 0,e.getCanMultiSort()?t.options.isMultiSortEvent==null?void 0:t.options.isMultiSortEvent(r):!1))}}},createTable:e=>{e.setSorting=t=>e.options.onSortingChange==null?void 0:e.options.onSortingChange(t),e.resetSorting=t=>{e.setSorting(t?[]:e.initialState?.sorting??[])},e.getPreSortedRowModel=()=>e.getGroupedRowModel(),e.getSortedRowModel=()=>(!e._getSortedRowModel&&e.options.getSortedRowModel&&(e._getSortedRowModel=e.options.getSortedRowModel(e)),e.options.manualSorting||!e._getSortedRowModel?e.getPreSortedRowModel():e._getSortedRowModel())}},Wx,oS,uS,fS,pS,Qx];function AS(e){let t=[...kS,...e._features??[]],n={_features:t},r=n._features.reduce((e,t)=>Object.assign(e,t.getDefaultOptions==null?void 0:t.getDefaultOptions(n)),{}),i=e=>n.options.mergeOptions?n.options.mergeOptions(r,e):{...r,...e},a={...e.initialState??{}};n._features.forEach(e=>{a=(e.getInitialState==null?void 0:e.getInitialState(a))??a});let o=[],s=!1,c={_features:t,options:{...r,...e},initialState:a,_queue:e=>{o.push(e),s||(s=!0,Promise.resolve().then(()=>{for(;o.length;)o.shift()();s=!1}).catch(e=>setTimeout(()=>{throw e})))},reset:()=>{n.setState(n.initialState)},setOptions:e=>{let t=_x(e,n.options);n.options=i(t)},getState:()=>n.options.state,setState:e=>{n.options.onStateChange==null||n.options.onStateChange(e)},_getRowId:(e,t,r)=>(n.options.getRowId==null?void 0:n.options.getRowId(e,t,r))??`${r?[r.id,t].join(`.`):t}`,getCoreRowModel:()=>(n._getCoreRowModel||=n.options.getCoreRowModel(n),n._getCoreRowModel()),getRowModel:()=>n.getPaginationRowModel(),getRow:(e,t)=>{let r=(t?n.getPrePaginationRowModel():n.getRowModel()).rowsById[e];if(!r&&(r=n.getCoreRowModel().rowsById[e],!r))throw Error();return r},_getDefaultColumnDef:Q(()=>[n.options.defaultColumn],e=>(e??={},{header:e=>{let t=e.header.column.columnDef;return t.accessorKey?t.accessorKey:t.accessorFn?t.id:null},cell:e=>{var t;return((t=e.renderValue())==null||t.toString==null?void 0:t.toString())??null},...n._features.reduce((e,t)=>Object.assign(e,t.getDefaultColumnDef==null?void 0:t.getDefaultColumnDef()),{}),...e}),$(e,`debugColumns`,`_getDefaultColumnDef`)),_getColumnDefs:()=>n.options.columns,getAllColumns:Q(()=>[n._getColumnDefs()],e=>{let t=function(e,r,i){return i===void 0&&(i=0),e.map(e=>{let a=Cx(n,e,i,r),o=e;return a.columns=o.columns?t(o.columns,a,i+1):[],a})};return t(e)},$(e,`debugColumns`,`getAllColumns`)),getAllFlatColumns:Q(()=>[n.getAllColumns()],e=>e.flatMap(e=>e.getFlatColumns()),$(e,`debugColumns`,`getAllFlatColumns`)),_getAllFlatColumnsById:Q(()=>[n.getAllFlatColumns()],e=>e.reduce((e,t)=>(e[t.id]=t,e),{}),$(e,`debugColumns`,`getAllFlatColumnsById`)),getAllLeafColumns:Q(()=>[n.getAllColumns(),n._getOrderColumnsFn()],(e,t)=>t(e.flatMap(e=>e.getLeafColumns())),$(e,`debugColumns`,`getAllLeafColumns`)),getColumn:e=>n._getAllFlatColumnsById()[e]};Object.assign(n,c);for(let e=0;e<n._features.length;e++){let t=n._features[e];t==null||t.createTable==null||t.createTable(n)}return n}function jS(){return e=>Q(()=>[e.options.data],t=>{let n={rows:[],flatRows:[],rowsById:{}},r=function(t,i,a){i===void 0&&(i=0);let o=[];for(let c=0;c<t.length;c++){let l=Ox(e,e._getRowId(t[c],c,a),t[c],c,i,void 0,a?.id);if(n.flatRows.push(l),n.rowsById[l.id]=l,o.push(l),e.options.getSubRows){var s;l.originalSubRows=e.options.getSubRows(t[c],c),(s=l.originalSubRows)!=null&&s.length&&(l.subRows=r(l.originalSubRows,i+1,l))}}return o};return n.rows=r(t),n},$(e.options,`debugTable`,`getRowModel`,()=>e._autoResetPageIndex()))}function MS(){return e=>Q(()=>[e.getState().sorting,e.getPreSortedRowModel()],(t,n)=>{if(!n.rows.length||!(t!=null&&t.length))return n;let r=e.getState().sorting,i=[],a=r.filter(t=>e.getColumn(t.id)?.getCanSort()),o={};a.forEach(t=>{let n=e.getColumn(t.id);n&&(o[t.id]={sortUndefined:n.columnDef.sortUndefined,invertSorting:n.columnDef.invertSorting,sortingFn:n.getSortingFn()})});let s=e=>{let t=e.map(e=>({...e}));return t.sort((e,t)=>{for(let n=0;n<a.length;n+=1){let r=a[n],i=o[r.id],s=i.sortUndefined,c=r?.desc??!1,l=0;if(s){let n=e.getValue(r.id),i=t.getValue(r.id),a=n===void 0,o=i===void 0;if(a||o){if(s===`first`)return a?-1:1;if(s===`last`)return a?1:-1;l=a&&o?0:a?s:-s}}if(l===0&&(l=i.sortingFn(e,t,r.id)),l!==0)return c&&(l*=-1),i.invertSorting&&(l*=-1),l}return e.index-t.index}),t.forEach(e=>{var t;i.push(e),(t=e.subRows)!=null&&t.length&&(e.subRows=s(e.subRows))}),t};return{rows:s(n.rows),flatRows:i,rowsById:n.rowsById}},$(e.options,`debugTable`,`getSortedRowModel`,()=>e._autoResetPageIndex()))}function NS(){return!0}var PS=Symbol(`merge-proxy`),FS={get(e,t,n){return t===PS?n:e.get(t)},has(e,t){return e.has(t)},set:NS,deleteProperty:NS,getOwnPropertyDescriptor(e,t){return{configurable:!0,enumerable:!0,get(){return e.get(t)},set:NS,deleteProperty:NS}},ownKeys(e){return e.keys()}};function IS(e){return`value`in e?e.value:e}function LS(){var e=[...arguments];return new Proxy({get(t){for(let n=e.length-1;n>=0;n--){let r=IS(e[n])[t];if(r!==void 0)return r}},has(t){for(let n=e.length-1;n>=0;n--)if(t in IS(e[n]))return!0;return!1},keys(){let t=[];for(let n=0;n<e.length;n++)t.push(...Object.keys(IS(e[n])));return[...Array.from(new Set(t))]}},FS)}var RS=F({props:[`render`,`props`],setup:e=>()=>typeof e.render==`function`||typeof e.render==`object`?G(e.render,e.props):e.render});function zS(e){return LS(e,{data:N(e.data)})}function BS(e){let t=j(e.data),n=AS(LS({state:{},onStateChange:()=>{},renderFallbackValue:null,mergeOptions(e,n){return t?{...e,...n}:LS(e,n)}},t?zS(e):e));if(t){let t=un(e.data);Er(t,()=>{n.setState(e=>({...e,data:t.value}))},{immediate:!0})}let r=M(n.initialState);return Cr(()=>{n.setOptions(n=>{let i=new Proxy({},{get:(e,t)=>r.value[t]});return LS(n,t?zS(e):e,{state:LS(i,e.state??{}),onStateChange:t=>{t instanceof Function?r.value=t(r.value):r.value=t,e.onStateChange==null||e.onStateChange(t)}})})}),n}var VS=[`aria-label`],HS=F({__name:`SortHeaderButton`,props:{header:{}},setup(e){let t=e,n=W(()=>t.header.column.getIsSorted()),r=W(()=>n.value===`asc`?a_:n.value===`desc`?v_:d_),i=W(()=>{let e=t.header.column.columnDef.header;return typeof e==`string`?e:t.header.column.id}),a=W(()=>{let e=n.value===`asc`?`ascending`:n.value===`desc`?`descending`:`none`;return`Sort by ${i.value}, currently ${e}`});function o(){t.header.column.toggleSorting(n.value===`asc`)}return(t,i)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`button`,{type:`button`,"aria-label":a.value,class:`inline-flex items-center gap-1 rounded px-1.5 py-0.5 hover:text-foreground focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring`,onClick:o},[e.header.isPlaceholder?Ts(``,!0):(R(),B(N(RS),{key:0,render:e.header.column.columnDef.header,props:e.header.getContext()},null,8,[`render`,`props`])),H(s,{icon:r.value,class:O([`size-3 shrink-0`,n.value?`text-foreground`:`text-muted-foreground/60`]),"aria-hidden":`true`},null,8,[`icon`,`class`])],8,VS)}}}),US={"data-slot":`table-container`,class:`relative w-full overflow-x-auto`},WS=F({__name:`Table`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,US,[V(`table`,{"data-slot":`table`,class:O(N(Yv)(`w-full caption-bottom text-sm`,t.class))},[I(e.$slots,`default`)],2)]))}}),GS=F({__name:`TableBody`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`tbody`,{"data-slot":`table-body`,class:O(N(Yv)(`[&_tr:last-child]:border-0`,t.class))},[I(e.$slots,`default`)],2))}}),KS=F({__name:`TableCell`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`td`,{"data-slot":`table-cell`,class:O(N(Yv)(`p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[I(e.$slots,`default`)],2))}}),qS=F({__name:`TableRow`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`tr`,{"data-slot":`table-row`,class:O(N(Yv)(`hover:bg-muted/50 data-[state=selected]:bg-muted border-b transition-colors has-aria-expanded:bg-muted/50`,t.class))},[I(e.$slots,`default`)],2))}}),JS={class:`flex items-center justify-center py-10`},YS=F({__name:`TableEmpty`,props:{class:{type:[Boolean,null,String,Object,Array]},colspan:{default:1}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(qS,null,{default:P(()=>[H(KS,ks({class:N(Yv)(`p-4 whitespace-nowrap align-middle text-sm text-foreground`,t.class)},N(n)),{default:P(()=>[V(`div`,JS,[I(e.$slots,`default`)])]),_:3},16,[`class`])]),_:3}))}}),XS=F({__name:`TableHead`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`th`,{"data-slot":`table-head`,class:O(N(Yv)(`text-foreground h-10 px-2 text-left align-middle font-medium whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[I(e.$slots,`default`)],2))}}),ZS=F({__name:`TableHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`thead`,{"data-slot":`table-header`,class:O(N(Yv)(`[&_tr]:border-b`,t.class))},[I(e.$slots,`default`)],2))}});function QS(e,t){t.value=typeof e==`function`?e(t.value):e}var $S=F({__name:`DataTable`,props:{columns:{},data:{},rowClass:{type:Function},emptyMessage:{}},setup(e){let t=e,n=M([]),r=BS({get data(){return t.data},get columns(){return t.columns},getCoreRowModel:jS(),getSortedRowModel:MS(),onSortingChange:e=>QS(e,n),state:{get sorting(){return n.value}}});function i(e){if(e===`asc`)return`ascending`;if(e===`desc`)return`descending`}return(t,n)=>(R(),B(N(WS),null,{default:P(()=>[H(N(ZS),null,{default:P(()=>[(R(!0),z(L,null,ma(N(r).getHeaderGroups(),e=>(R(),B(N(qS),{key:e.id},{default:P(()=>[(R(!0),z(L,null,ma(e.headers,e=>(R(),B(N(XS),{key:e.id,class:O(e.column.columnDef.meta?.align===`right`?`text-right`:void 0),"aria-sort":e.column.getCanSort()?i(e.column.getIsSorted())??`none`:void 0},{default:P(()=>[e.column.getCanSort()?(R(),B(HS,{key:0,header:e,class:`-mx-1.5`},null,8,[`header`])):e.isPlaceholder?Ts(``,!0):(R(),B(N(RS),{key:1,render:e.column.columnDef.header,props:e.getContext()},null,8,[`render`,`props`]))]),_:2},1032,[`class`,`aria-sort`]))),128))]),_:2},1024))),128))]),_:1}),H(N(GS),null,{default:P(()=>[N(r).getRowModel().rows.length===0?(R(),B(N(YS),{key:0,colspan:e.columns.length,class:`text-muted-foreground`},{default:P(()=>[U(k(e.emptyMessage??`none`),1)]),_:1},8,[`colspan`])):Ts(``,!0),(R(!0),z(L,null,ma(N(r).getRowModel().rows,t=>(R(),B(N(qS),{key:t.id,class:O(e.rowClass?.(t.original))},{default:P(()=>[(R(!0),z(L,null,ma(t.getVisibleCells(),e=>(R(),B(N(KS),{key:e.id,class:O(e.column.columnDef.meta?.align===`right`?`text-right tabular-nums`:void 0)},{default:P(()=>[H(N(RS),{render:e.column.columnDef.cell,props:e.getContext()},null,8,[`render`,`props`])]),_:2},1032,[`class`]))),128))]),_:2},1032,[`class`]))),128))]),_:1})]),_:1}))}}),eC=F({__name:`Badge`,props:{asChild:{type:Boolean},as:{},variant:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(r,i)=>(R(),B(N(nb),ks({"data-slot":`badge`,"data-variant":e.variant,class:N(Yv)(N(tC)({variant:e.variant}),t.class)},N(n)),{default:P(()=>[I(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),tC=C_(`h-5 gap-1 rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium transition-all has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&>svg]:size-3! group/badge inline-flex w-fit shrink-0 items-center justify-center overflow-hidden whitespace-nowrap focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none`,{variants:{variant:{default:`bg-primary text-primary-foreground [a]:hover:bg-primary/80`,secondary:`bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80`,destructive:`bg-destructive/10 [a]:hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 text-destructive dark:bg-destructive/20`,outline:`border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground`,ghost:`hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50`,link:`text-primary underline-offset-4 hover:underline`}},defaultVariants:{variant:`default`}});async function nC(e,t){if(navigator.clipboard?.writeText)try{return await navigator.clipboard.writeText(e),`copied`}catch{}if(!t)return`failed`;let n=document.createRange();n.selectNodeContents(t);let r=window.getSelection();return r?(r.removeAllRanges(),r.addRange(n),`selected`):`failed`}var rC=`0001-01-01T00:00:00Z`;function iC(e,t){return`${e}/${t}`}function aC(e){return`$${(e/1e6).toFixed(4)}`}function oC(e){return e.toLocaleString(`en-US`)}function sC(e){let t=Math.abs(e);if(t<1e4)return oC(e);let n=e<0?`-`:``,[r,i]=t<1e6?[1e3,`k`]:t<1e9?[1e6,`M`]:[1e9,`B`],a=t/r,o=3-(Math.floor(a)>=100?3:Math.floor(a)>=10?2:1),s=10**o,c=(Math.floor(t*s/r)/s).toFixed(o);return o>0&&(c=c.replace(/0+$/,``).replace(/\.$/,``)),`${n}${c}${i}`}function cC(e){return e>0&&!(e&e-1)}function lC(e){return e<1024?`${e}`:cC(e)?e<1048576?`${Math.round(e/1024)}k`:`${Math.round(e/1048576)}M`:e<1e6?`${Math.round(e/1e3)}k`:`${Math.round(e/1e6)}M`}function uC(e){return`$${e.toFixed(2)}`}function dC(e,t){return e===0&&t===0?`free`:`in ${uC(e)} / out ${uC(t)} per MTok`}function fC(e){return e<1e3?`${Math.round(e)}ms`:`${(e/1e3).toFixed(1)}s`}function pC(e,t){if(!e||e===rC)return null;let n=new Date(e).getTime();return Number.isNaN(n)?null:Math.max(0,Math.round((t-n)/1e3))}function mC(e){let t=pC(e,Date.now());return t===null?``:` (${t}s ago)`}function hC(e,t=Date.now()){let n=pC(e,t);return n===null?``:`${n}s ago`}function gC(e){if(!e||e===rC)return``;let t=new Date(e).getTime();if(Number.isNaN(t))return``;let n=Math.round((t-Date.now())/1e3);return n<=0?``:`in ${n}s`}function _C(e){if(!e||e===rC)return`never`;let t=new Date(e);return Number.isNaN(t.getTime())?e:t.toLocaleString()}function vC(e,t){return e?mC(t)?`refreshed`:`pending`:`off`}function yC(e,t){switch(vC(e,t)){case`off`:return`discovery off`;case`pending`:return`pending`;case`refreshed`:return`refreshed${mC(t)}`}}function bC(e,t){switch(vC(e,t)){case`off`:return`discovery off`;case`pending`:return`pending`;case`refreshed`:return _C(t)}}function xC(e){if(!e)return`none`;let t=[];return e.requestsPerMinute&&t.push(`req/min ${e.requestsPerMinute}`),e.requestsPerDay&&t.push(`req/day ${e.requestsPerDay}`),e.tokensPerDay&&t.push(`tok/day ${e.tokensPerDay}`),e.tokensPerMonth&&t.push(`tok/month ${e.tokensPerMonth}`),e.costPerDayUSD&&t.push(`cost/day $${e.costPerDayUSD}`),e.costPerMonthUSD&&t.push(`cost/month $${e.costPerMonthUSD}`),t.length?t.join(`, `):`none`}function SC(e,t){switch(t){case`hour`:return`${e.slice(8,10)}:00`;case`day`:{let t=Number(e.slice(0,4)),n=Number(e.slice(4,6)),r=Number(e.slice(6,8));return new Date(t,n-1,r).toLocaleDateString(void 0,{month:`short`,day:`numeric`})}case`month`:{let t=Number(e.slice(0,4)),n=Number(e.slice(4,6));return new Date(t,n-1,1).toLocaleDateString(void 0,{month:`short`,year:`numeric`})}}}var CC=F({__name:`ModelChip`,props:{id:{},contextTokens:{},inputPerMTokUsd:{},outputPerMTokUsd:{}},setup(e){let t=e,n=si(`label`),r=M(`idle`),i;function a(){clearTimeout(i),i=setTimeout(()=>{r.value=`idle`},1500)}async function o(){let e=await nC(t.id,n.value??void 0);r.value=e,a()}let s={idle:g_,copied:u_,selected:u_,failed:h_},c=W(()=>({idle:`Copy ${t.id}`,copied:`Copied`,selected:`Selected — press Ctrl/Cmd+C`,failed:`Copy failed`})),l=W(()=>{let e=[];return t.inputPerMTokUsd!==void 0&&t.outputPerMTokUsd!==void 0&&e.push(dC(t.inputPerMTokUsd,t.outputPerMTokUsd)),t.contextTokens!==void 0&&e.push(`${lC(t.contextTokens)} context`),e.join(` · `)}),u=W(()=>{let e=c.value[r.value];return l.value?`${e} · ${l.value}`:e});return ta(()=>{clearTimeout(i)}),(t,n)=>{let i=ca(`FontAwesomeIcon`);return R(),B(N(eC),{as:`button`,type:`button`,variant:`secondary`,class:O([`cursor-pointer gap-1 font-mono text-xs font-normal transition-colors hover:bg-accent hover:text-accent-foreground`,r.value===`failed`?`text-destructive`:``]),title:u.value,"aria-label":u.value,onClick:o},{default:P(()=>[V(`span`,{ref:`label`,class:`select-text`},k(e.id),513),H(i,{icon:s[r.value],class:`size-2.5 shrink-0`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`class`,`title`,`aria-label`])}}});function wC(e,t){return!Number.isFinite(e)||e<=0?null:(e-(Number.isFinite(t)?t:0))/e}function TC(e){return e===null?`no-traffic`:e<.9?`severe`:e<.99?`degraded`:`healthy`}function EC(e,t){let n=wC(e,t);return n!==null&&n<.99}function DC(e){return e>=1?`100%`:`${Math.floor(e*100)}%`}function OC(e,t,n){return e===1?t:n}function kC(e,t){if(e<=0)return`no traffic in the last minute`;let n=wC(e,t),r=n===null?``:` (${DC(n)})`;return`${e} ${OC(e,`attempt`,`attempts`)}, ${t} ${OC(t,`failure`,`failures`)} in the last minute${r}`}function AC(e,t){if(e<=0)return`no traffic today`;let n=wC(e,t),r=n===null?``:` (${DC(n)})`;return`${e} ${OC(e,`attempt`,`attempts`)}, ${t} ${OC(t,`failure`,`failures`)} today${r}`}var jC={"aria-hidden":`true`},MC={class:`sr-only`},NC=F({__name:`ProviderRateBadge`,props:{attemptsDay:{},failuresDay:{},attemptsMinute:{},failuresMinute:{}},setup(e){let t=e,n=W(()=>wC(t.attemptsDay,t.failuresDay)),r=W(()=>TC(n.value)),i=W(()=>r.value===`no-traffic`?`no traffic`:DC(n.value)),a=W(()=>t.attemptsMinute===void 0||t.failuresMinute===void 0?AC(t.attemptsDay,t.failuresDay):kC(t.attemptsMinute,t.failuresMinute)),o=W(()=>r.value===`severe`?`destructive`:r.value===`healthy`?`secondary`:`outline`),s=W(()=>r.value===`degraded`?`border-status-warn/40 text-status-warn`:r.value===`no-traffic`?`text-muted-foreground`:``);return(e,t)=>(R(),B(N(eC),{as:`span`,variant:o.value,class:O([s.value,`font-normal tabular-nums`]),title:a.value},{default:P(()=>[V(`span`,jC,k(i.value),1),V(`span`,MC,k(a.value),1)]),_:1},8,[`variant`,`class`,`title`]))}}),PC=F({__name:`SearchInput`,props:{modelValue:{},placeholder:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=W(()=>n.modelValue.length>0);function a(e){r(`update:modelValue`,String(e))}function o(){r(`update:modelValue`,``)}return(t,r)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`div`,{class:O(N(Yv)(`relative`,n.class))},[H(s,{icon:N(r_),class:`pointer-events-none absolute top-1/2 left-2.5 size-3.5 -translate-y-1/2 text-muted-foreground`,"aria-hidden":`true`},null,8,[`icon`]),H(N(Qb),{"model-value":e.modelValue,type:`text`,placeholder:e.placeholder,"aria-label":e.placeholder,class:`pr-8 pl-8`,"onUpdate:modelValue":a},null,8,[`model-value`,`placeholder`,`aria-label`]),i.value?(R(),B(N(Wb),{key:0,type:`button`,variant:`ghost`,size:`icon-xs`,"aria-label":`Clear search`,class:`absolute top-1/2 right-1 -translate-y-1/2 text-muted-foreground hover:text-foreground`,onClick:o},{default:P(()=>[H(s,{icon:N(f_),class:`size-3.5`},null,8,[`icon`])]),_:1})):Ts(``,!0)],2)}}}),FC=F({__name:`Accordion`,props:{collapsible:{type:Boolean},disabled:{type:Boolean},dir:{},orientation:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},type:{},modelValue:{},defaultValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=qy(Cy(n,`class`),r);return(e,t)=>(R(),B(N(hb),ks({"data-slot":`accordion`},N(i),{class:N(Yv)(`flex w-full flex-col`,n.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`class`]))}}),IC=F({__name:`AccordionContent`,props:{forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(N(bb),ks({"data-slot":`accordion-content`},N(n),{class:`data-open:animate-accordion-down data-closed:animate-accordion-up text-sm overflow-hidden`}),{default:P(()=>[V(`div`,{class:O(N(Yv)(`pt-0 pb-2.5 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4`,t.class))},[I(e.$slots,`default`)],2)]),_:3},16))}}),LC=F({__name:`AccordionItem`,props:{disabled:{type:Boolean},value:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Ky(Cy(t,`class`));return(e,r)=>(R(),B(N(yb),ks({"data-slot":`accordion-item`},N(n),{class:N(Yv)(`not-last:border-b`,t.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`class`]))}}),RC=F({__name:`AccordionTrigger`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>{let i=ca(`FontAwesomeIcon`);return R(),B(N(xb),{class:`flex`},{default:P(()=>[H(N(Sb),ks({"data-slot":`accordion-trigger`},N(n),{class:N(Yv)(`focus-visible:ring-ring/50 focus-visible:border-ring focus-visible:after:border-ring **:data-[slot=accordion-trigger-icon]:text-muted-foreground rounded-lg py-2.5 text-left text-sm font-medium hover:underline focus-visible:ring-3 **:data-[slot=accordion-trigger-icon]:ml-auto **:data-[slot=accordion-trigger-icon]:size-4 group/accordion-trigger relative flex flex-1 items-start justify-between border border-transparent transition-all outline-none disabled:pointer-events-none disabled:opacity-50`,t.class)}),{default:P(()=>[I(e.$slots,`default`),I(e.$slots,`icon`,{},()=>[H(i,{icon:N(m_),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden`},null,8,[`icon`]),H(i,{icon:N(s_),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none hidden shrink-0 group-aria-expanded/accordion-trigger:inline`},null,8,[`icon`])])]),_:3},16,[`class`])]),_:3})}}});function zC(){let e=M(``),t=W(()=>e.value.trim().toLowerCase());return{query:e,normalized:t,hasQuery:W(()=>t.value.length>0)}}function BC(e,t,n){if(!t)return new Set(e.manuallyExpanded);let r=new Set(e.manuallyExpanded);for(let t of n)e.manuallyCollapsed.has(t)||r.add(t);return r}function VC(e,t,n){n?(e.manuallyExpanded.delete(t),e.manuallyCollapsed.add(t)):(e.manuallyCollapsed.delete(t),e.manuallyExpanded.add(t))}function HC(e){e.manuallyCollapsed.clear()}var UC={class:`flex flex-col gap-6`},WC={class:`grid gap-4 sm:grid-cols-3`},GC={class:`font-medium`},KC={key:0,class:`flex items-start gap-1.5 text-destructive`},qC={class:`font-medium`},JC={key:0,class:`text-muted-foreground`},YC={class:`font-medium`},XC={key:0,class:`text-muted-foreground`},ZC={key:0,class:`py-6 text-center text-sm text-muted-foreground`},QC={key:1,class:`py-6 text-center text-sm text-muted-foreground`},$C={class:`flex flex-1 flex-wrap items-center gap-x-3 gap-y-1 pr-2 text-left`},ew={class:`font-medium`},tw={class:`text-xs text-muted-foreground tabular-nums`},nw={class:`text-xs text-muted-foreground`},rw={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-3`},iw={class:`break-all`},aw={key:0},ow={key:1},sw={class:`text-destructive`},cw={key:0,class:`flex flex-wrap gap-1.5`},lw={key:0,title:`context window`,class:`text-xs text-muted-foreground tabular-nums`},uw={key:1,class:`text-sm text-muted-foreground`},dw={key:0,class:`text-xs text-muted-foreground`},fw=`Per-replica, in-process only — not a fleet-wide average across this deployment’s replicas.`,pw=F({__name:`ProvidersView`,setup(e){let t=sx(),n=W(()=>t.overview),r=Zt({manuallyExpanded:new Set,manuallyCollapsed:new Set}),{query:i,normalized:a,hasQuery:o}=zC();function s(e,t){return iC(e,t).toLowerCase().includes(a.value)}function c(e){return e.models.some(t=>s(e.name,t))}function l(e){return e.alias.toLowerCase().includes(a.value)||e.target.toLowerCase().includes(a.value)}let u=W(()=>{let e=n.value?.providers??[];return o.value?e.filter(c):e}),d=W(()=>{let e=n.value?.aliases??[];return o.value?e.filter(l):e}),f=W(()=>BC(r,o.value,u.value.map(e=>e.name)));function p(e){VC(r,e,f.value.has(e))}let m=W({get:()=>Array.from(f.value),set:e=>{let t=new Set(e);for(let e of f.value)t.has(e)||p(e);for(let e of t)f.value.has(e)||p(e)}});Er(i,e=>{e.trim()===``&&HC(r)});function h(e){return o.value?e.models.filter(t=>s(e.name,t)):e.models}let g={attemptsDay:0,failuresDay:0};function _(e,t){return e.modelRates?.[t]??g}function v(e,t){let n=_(e,t);return EC(n.attemptsDay,n.failuresDay)}let y={};function b(e,t){return e.modelMeta?.[t]??y}function x(e){switch(e){case`open`:return`destructive`;case`half-open`:return`secondary`;default:return}}function S(e){let t=gC(e.openUntil);return t?`${e.healthState} (${t})`:e.healthState}function C(e){return e===`open`?`text-destructive`:`text-muted-foreground`}function w(e){return e.latency?.streaming}function ee(e){return e.latency?.[`non-streaming`]}function te(e){return e.count===void 0?`no observations counted`:`${e.count} ${e.count===1?`observation`:`observations`} on this replica`}function T(e){return`Average time to first byte, the load-sensitive reading for streaming traffic. ${te(e)}. ${fw}`}function ne(e){return`Average total response time, including generation — not a load-sensitive signal like streaming ttfb, since this provider buffers the whole completion before sending anything. ${te(e)}. ${fw}`}function re(e){return e.provenance?.estimated}function ie(e){return e.provenance?.unbilled}function E(e){let t=e.requests===1?``:`s`;return`${e.requests} non-streaming response${t} carried no usage from the provider — prompt tokens were estimated from request body size instead (${e.tokens} tokens billed from the estimate), completion billed as zero. ${fw}`}function ae(e){let t=e.requests===1?``:`s`;return`${e.requests} streaming response${t} carried no usage from the provider — the request was counted but zero tokens were billed. If this keeps happening, this provider may be serving completions entirely free against every budget. ${fw}`}let oe=[{id:`alias`,header:`Alias`,accessorFn:e=>e.alias,cell:({row:e})=>G(CC,{id:e.original.alias,contextTokens:e.original.modelMeta?.contextTokens,inputPerMTokUsd:e.original.modelMeta?.inputPerMTokUsd,outputPerMTokUsd:e.original.modelMeta?.outputPerMTokUsd})},{id:`target`,header:`Target`,accessorFn:e=>e.target,cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},e.original.target)}],se=W(()=>n.value?.aliases.length?o.value?`no aliases match "${i.value}"`:`none`:`none configured`);return(e,t)=>{let r=ca(`FontAwesomeIcon`);return R(),z(`div`,UC,[V(`div`,WC,[H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.redis.configured?N(p_):N(c_),class:O([n.value?.redis.configured?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[2]||=U(` Redis `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`flex flex-col gap-1 text-sm`},{default:P(()=>[V(`p`,GC,k(n.value?.redis.configured?`Configured`:`Not configured`),1),n.value?.redis.lastErr?(R(),z(`p`,KC,[H(r,{icon:N(h_),class:`mt-0.5 size-3.5 shrink-0`},null,8,[`icon`]),V(`span`,null,k(n.value.redis.lastErr)+k(N(mC)(n.value.redis.lastErrAt)),1)])):Ts(``,!0)]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.cache.enabled?N(p_):N(c_),class:O([n.value?.cache.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[3]||=U(` Response cache `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`text-sm`},{default:P(()=>[V(`p`,qC,k(n.value?.cache.enabled?`Enabled`:`Disabled`),1),n.value?.cache.enabled?(R(),z(`p`,JC,`ttl `+k(n.value.cache.ttl),1)):Ts(``,!0)]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.retry.enabled?N(p_):N(c_),class:O([n.value?.retry.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[4]||=U(` Retry `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`text-sm`},{default:P(()=>[V(`p`,YC,k(n.value?.retry.enabled?`Enabled`:`Disabled`),1),n.value?.retry.enabled?(R(),z(`p`,XC,` attempts `+k(n.value.retry.attempts)+`, backoff `+k(n.value.retry.backoff),1)):Ts(``,!0)]),_:1})]),_:1})]),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[5]||=[U(`Providers`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[6]||=[U(` Every configured upstream and its last discovery refresh. Search filters providers and aliases by model id. `,-1)]]),_:1}),H(PC,{modelValue:N(i),"onUpdate:modelValue":t[0]||=e=>j(i)?i.value=e:null,placeholder:`Search models or aliases...`,class:`mt-2 max-w-sm`},null,8,[`modelValue`])]),_:1}),H(N(Jb),null,{default:P(()=>[n.value?.providers.length?N(o)&&u.value.length===0?(R(),z(`p`,QC,` no providers match "`+k(N(i))+`" `,1)):(R(),B(N(FC),{key:2,modelValue:m.value,"onUpdate:modelValue":t[1]||=e=>m.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:P(()=>[(R(!0),z(L,null,ma(u.value,e=>(R(),B(N(LC),{key:e.name,value:e.name},{default:P(()=>[H(N(RC),null,{default:P(()=>[V(`span`,$C,[V(`span`,ew,k(e.name),1),H(N(eC),{as:`span`,variant:`secondary`,class:`font-normal`},{default:P(()=>[U(k(e.type),1)]),_:2},1024),V(`span`,tw,k(e.modelCount)+` models`,1),H(NC,{"attempts-day":e.attemptsDay,"failures-day":e.failuresDay,"attempts-minute":e.attemptsMinute,"failures-minute":e.failuresMinute},null,8,[`attempts-day`,`failures-day`,`attempts-minute`,`failures-minute`]),e.healthState===`closed`?Ts(``,!0):(R(),B(N(eC),{key:0,as:`span`,variant:x(e.healthState),class:`font-normal`,title:e.healthState===`open`?`discovery is backing off after repeated failures`:`a discovery probe is deciding whether to recover`},{default:P(()=>[U(k(S(e)),1)]),_:2},1032,[`variant`,`title`])),w(e)?.avgTtfbMs===void 0?Ts(``,!0):(R(),B(N(eC),{key:1,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:T(w(e))},{default:P(()=>[U(` streaming ttfb `+k(N(fC)(w(e).avgTtfbMs)),1)]),_:2},1032,[`title`])),ee(e)?.avgDurationMs===void 0?Ts(``,!0):(R(),B(N(eC),{key:2,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:ne(ee(e))},{default:P(()=>[U(` non-streaming avg `+k(N(fC)(ee(e).avgDurationMs)),1)]),_:2},1032,[`title`])),re(e)?(R(),B(N(eC),{key:3,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:E(re(e))},{default:P(()=>[U(` estimated `+k(re(e).requests),1)]),_:2},1032,[`title`])):Ts(``,!0),ie(e)?(R(),B(N(eC),{key:4,as:`span`,variant:`destructive`,class:`font-normal tabular-nums`,title:ae(ie(e))},{default:P(()=>[U(` unbilled `+k(ie(e).requests),1)]),_:2},1032,[`title`])):Ts(``,!0),e.lastErr?(R(),B(r,{key:5,icon:N(h_),class:`size-3.5 shrink-0 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):Ts(``,!0),V(`span`,nw,k(N(yC)(e.discoveryEnabled,e.lastRefresh)),1)])]),_:2},1024),H(N(IC),null,{default:P(()=>[V(`dl`,rw,[V(`div`,null,[t[7]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Base URL`,-1),V(`dd`,iw,k(e.baseUrl),1)]),V(`div`,null,[t[8]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Last refresh`,-1),V(`dd`,null,k(N(bC)(e.discoveryEnabled,e.lastRefresh)),1)]),e.healthState===`closed`?Ts(``,!0):(R(),z(`div`,aw,[t[9]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Discovery health`,-1),V(`dd`,{class:O(C(e.healthState))},k(S(e)),3)])),e.lastErr?(R(),z(`div`,ow,[t[10]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Last error`,-1),V(`dd`,sw,k(e.lastErr),1)])):Ts(``,!0)]),h(e).length?(R(),z(`div`,cw,[(R(!0),z(L,null,ma(h(e),t=>(R(),z(`span`,{key:t,class:`inline-flex items-center gap-1`},[H(CC,{id:N(iC)(e.name,t),"context-tokens":b(e,t).contextTokens,"input-per-m-tok-usd":b(e,t).inputPerMTokUsd,"output-per-m-tok-usd":b(e,t).outputPerMTokUsd},null,8,[`id`,`context-tokens`,`input-per-m-tok-usd`,`output-per-m-tok-usd`]),b(e,t).contextTokens===void 0?Ts(``,!0):(R(),z(`span`,lw,k(N(lC)(b(e,t).contextTokens)),1)),v(e,t)?(R(),B(NC,{key:1,"attempts-day":_(e,t).attemptsDay,"failures-day":_(e,t).failuresDay},null,8,[`attempts-day`,`failures-day`])):Ts(``,!0)]))),128))])):(R(),z(`p`,uw,`no models known yet`))]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):(R(),z(`p`,ZC,`none`))]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[11]||=[U(`Model aliases`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[12]||=[U(`Operator-defined alias → target model mappings.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:oe,data:d.value,"empty-message":se.value},null,8,[`data`,`empty-message`])]),_:1})]),_:1}),n.value?.version?(R(),z(`p`,dw,`Version: `+k(n.value.version),1)):Ts(``,!0)])}}}),mw=[`title`],hw={"aria-hidden":`true`},gw={class:`sr-only`},_w=F({__name:`CompactNumber`,props:{value:{}},setup(e){let t=e,n=W(()=>sC(t.value)),r=W(()=>oC(t.value));return(e,t)=>(R(),z(`span`,{title:r.value},[V(`span`,hw,k(n.value),1),V(`span`,gw,k(r.value),1)],8,mw))}});function vw(e,t,n){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>G(_w,{value:n(e.original)})}}var yw=`not observed yet — no traffic and probes disabled or not yet run`;function bw(e){let t=hC(e.lastCheck);return t?`unhealthy (${t})`:`unhealthy`}function xw(e){let t=e.consecutiveFailures===1?`failure`:`failures`,n=e.source?` via ${e.source}`:``,r=`${e.consecutiveFailures} consecutive ${t}${n}`;return e.lastError?`${r}: ${e.lastError}`:r}function Sw(e){let t=hC(e.lastCheck);return t?e.source?`${t} via ${e.source}`:t:e.source?`via ${e.source}`:``}function Cw(e){if(e.consecutiveFailures<=0&&!e.lastError)return yw;let t=e.consecutiveFailures===1?`failure`:`failures`,n=e.source?` via ${e.source}`:``,r=`${e.consecutiveFailures} ${t} so far${n}`;return e.lastError?`${r}: ${e.lastError}`:r}function ww(e){if(e.state===`unhealthy`)return G(eC,{as:`span`,variant:`destructive`,class:`font-normal`,title:xw(e)},()=>bw(e));if(e.state===`healthy`){let t=e.latencyMs===void 0?``:` · ${fC(e.latencyMs)}`;return G(`span`,{class:`text-muted-foreground`,title:Sw(e)},`healthy${t}`)}return G(eC,{as:`span`,variant:`outline`,class:`font-normal`,title:Cw(e)},()=>`unknown`)}function Tw(){return[{id:`name`,header:`Name`,accessorFn:e=>e.name,cell:({row:e})=>G(`span`,{class:`font-medium`},e.original.name)},{id:`url`,header:`URL`,accessorFn:e=>e.url,cell:({row:e})=>G(`span`,{class:`block max-w-xs truncate text-muted-foreground`,title:e.original.url},e.original.url)},{id:`health`,header:`Health`,enableSorting:!1,accessorFn:e=>e.health.state,cell:({row:e})=>ww(e.original.health)},{id:`access`,header:`Access`,enableSorting:!1,accessorFn:e=>(e.access??[]).join(`, `),cell:({row:e})=>{let t=e.original.access;return t?.length?G(`div`,{class:`flex flex-wrap gap-1.5`},t.map(e=>G(eC,{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},()=>e))):G(`span`,{class:`text-muted-foreground`},`All groups`)}},vw(`reqMin`,`req/min`,e=>e.counters.requestsPerMinute),vw(`reqDay`,`req/day`,e=>e.counters.requestsPerDay),vw(`reqMonth`,`req/month`,e=>e.counters.requestsPerMonth)]}var Ew={class:`flex flex-col gap-6`},Dw=F({__name:`TargetsView`,setup(e){let t=sx(),n=W(()=>t.targets),{query:r,normalized:i,hasQuery:a}=zC();function o(e){return e.name.toLowerCase().includes(i.value)}let s=W(()=>{let e=n.value?.mcpServers??[];return a.value?e.filter(o):e}),c=W(()=>{let e=n.value?.agents??[];return a.value?e.filter(o):e});function l(e,t){return e?a.value&&t===0?`no targets match "${r.value}"`:`none`:`none configured`}let u=W(()=>l(n.value?.mcpServers.length??0,s.value.length)),d=W(()=>l(n.value?.agents.length??0,c.value.length)),f=Tw();return(e,t)=>(R(),z(`div`,Ew,[H(PC,{modelValue:N(r),"onUpdate:modelValue":t[0]||=e=>j(r)?r.value=e:null,placeholder:`Filter MCP servers or agents`,class:`max-w-sm`},null,8,[`modelValue`]),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[1]||=[U(`MCP servers`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[2]||=[U(`Configured MCP proxy targets, the groups allowed to reach them, and their request counters.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:N(f),data:s.value,"empty-message":u.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[3]||=[U(`Agents`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[4]||=[U(`Configured A2A agent proxy targets, the groups allowed to reach them, and their request counters.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:N(f),data:c.value,"empty-message":d.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1})]))}}),Ow=F({__name:`Tabs`,props:{defaultValue:{},orientation:{},dir:{},activationMode:{},modelValue:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=qy(Cy(n,`class`),r);return(e,t)=>(R(),B(N(Rb),ks({"data-slot":`tabs`,"data-orientation":N(i).orientation||`horizontal`},N(i),{class:N(Yv)(`gap-2 group/tabs flex data-horizontal:flex-col`,n.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`data-orientation`,`class`]))}}),kw=F({__name:`TabsContent`,props:{value:{},forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(N(Vb),ks({"data-slot":`tabs-content`,class:N(Yv)(`text-sm flex-1 outline-none`,t.class)},N(n)),{default:P(()=>[I(e.$slots,`default`)]),_:3},16,[`class`]))}}),Aw=F({__name:`TabsList`,props:{loop:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]},variant:{default:`default`}},setup(e){let t=e,n=Cy(t,`class`,`variant`);return(r,i)=>(R(),B(N(Hb),ks({"data-slot":`tabs-list`,"data-variant":e.variant},N(n),{class:N(Yv)(N(Mw)({variant:e.variant}),t.class)}),{default:P(()=>[I(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),jw=F({__name:`TabsTrigger`,props:{value:{},disabled:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Ky(Cy(t,`class`));return(e,r)=>(R(),B(N(Ub),ks({"data-slot":`tabs-trigger`,class:N(Yv)(`gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg:not([class*=size-])]:size-4 has-data-[icon=inline-end]:pr-1 has-data-[icon=inline-start]:pl-1 relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center whitespace-nowrap text-foreground/60 transition-all group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 dark:text-muted-foreground dark:hover:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0`,`group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent`,`data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground`,`after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100`,t.class)},N(n)),{default:P(()=>[I(e.$slots,`default`)]),_:3},16,[`class`]))}}),Mw=C_(`rounded-lg p-0.75 group-data-horizontal/tabs:h-8 data-[variant=line]:rounded-none group/tabs-list inline-flex w-fit items-center justify-center text-muted-foreground group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col`,{variants:{variant:{default:`bg-muted`,line:`gap-1 bg-transparent`}},defaultVariants:{variant:`default`}});function Nw(e,t,n,r=String,i=!0){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>{if(e.original.storeDown)return`?`;let t=n(e.original);return i?G(_w,{value:t}):r(t)}}}function Pw(e,t,n){return[{id:`id`,header:e,accessorFn:e=>e.id,cell:({row:e})=>G(`span`,{class:`font-medium`},e.original.id)},{id:`secondary`,header:t,accessorFn:n,cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},n(e.original))},{id:`limits`,header:`Limits`,accessorFn:e=>xC(e.limits),cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},xC(e.original.limits))},Nw(`reqMin`,`req/min`,e=>e.requestsPerMinute),Nw(`reqDay`,`req/day`,e=>e.requestsPerDay),Nw(`tokInDay`,`tokIn/day`,e=>e.tokensInPerDay),Nw(`tokOutDay`,`tokOut/day`,e=>e.tokensOutPerDay),Nw(`tokInMonth`,`tokIn/month`,e=>e.tokensInPerMonth),Nw(`tokOutMonth`,`tokOut/month`,e=>e.tokensOutPerMonth),Nw(`costDay`,`cost/day`,e=>e.costPerDayMicroUsd,aC,!1),Nw(`costMonth`,`cost/month`,e=>e.costPerMonthMicroUsd,aC,!1)]}var Fw=F({__name:`UsageTable`,props:{idLabel:{},entries:{},secondaryColumnLabel:{},secondaryValue:{type:Function},emptyMessage:{}},setup(e){let t=e,n=W(()=>Pw(t.idLabel,t.secondaryColumnLabel,t.secondaryValue));return(t,r)=>(R(),B($S,{columns:n.value,data:e.entries,"empty-message":e.emptyMessage,"row-class":e=>e.storeDown?`bg-destructive/10`:void 0},null,8,[`columns`,`data`,`empty-message`,`row-class`]))}});function Iw(e,t){return e.id.toLowerCase().includes(t)}function Lw(e,t){return e.id.toLowerCase().includes(t)}function Rw(e,t){return t.filter(t=>t.groupName===e.id)}function zw(e,t,n){return Rw(e,t).filter(e=>Iw(e,n))}function Bw(e,t,n){return Lw(e,n)||zw(e,t,n).length>0}var Vw={class:`flex flex-col gap-6`},Hw={class:`text-lg font-semibold tabular-nums`},Uw={class:`text-lg font-semibold tabular-nums`},Ww={class:`text-lg font-semibold tabular-nums`},Gw={class:`text-lg font-semibold tabular-nums`},Kw={key:0,class:`mb-3 flex flex-wrap gap-x-4 gap-y-1 text-xs font-medium text-muted-foreground`},qw={class:`flex flex-1 flex-wrap items-center gap-x-4 gap-y-1 pr-2 text-left`},Jw={class:`font-medium`},Yw={class:`text-xs text-muted-foreground tabular-nums`},Xw={class:`text-xs text-muted-foreground tabular-nums`},Zw={class:`text-xs text-muted-foreground tabular-nums`},Qw={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},$w={key:0,class:`flex flex-wrap gap-1.5`},eT={key:1,class:`text-muted-foreground`},tT={key:0,class:`flex flex-wrap gap-1.5`},nT={key:1,class:`text-muted-foreground`},rT={key:0,class:`flex flex-wrap gap-1.5`},iT={key:1,class:`text-muted-foreground`},aT={key:0,class:`flex flex-wrap gap-1.5`},oT={key:1,class:`text-muted-foreground`},sT={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},cT={class:`tabular-nums`},lT={class:`tabular-nums`},uT={class:`tabular-nums`},dT={class:`tabular-nums`},fT={class:`tabular-nums`},pT={class:`tabular-nums`},mT={key:2,class:`py-6 text-center text-sm text-muted-foreground`},hT=`Glob pattern — matches like a shell wildcard (*, ?, [...])`,gT=F({__name:`UsageView`,setup(e){let t=sx(),n=W(()=>t.usage),r=W(()=>{let e={};for(let n of t.overview?.groups??[])e[n.name]=n.memberCount;return e});function i(e){return e.groupName??``}function a(e){let t=r.value[e.id];return t===void 0?``:String(t)}let{query:o,normalized:s,hasQuery:c}=zC(),l=W(()=>{let e=n.value?.groups??[];if(!c.value)return e;let t=n.value?.users??[];return e.filter(e=>Bw(e,t,s.value))}),u=W(()=>c.value?l.value.filter(e=>!Lw(e,s.value)).map(e=>e.id):[]);function d(e){let t=n.value?.users??[];return!c.value||Lw(e,s.value)?Rw(e,t):zw(e,t,s.value)}let f=W(()=>n.value?.groups.length?c.value?`no groups match "${o.value}"`:`none`:`none configured`),p=W(()=>{let e=n.value?.users??[];if(!c.value)return e;let t=n.value?.groups??[],r=new Set(t.filter(e=>Lw(e,s.value)).map(e=>e.id));return e.filter(e=>Iw(e,s.value)||e.groupName!==void 0&&r.has(e.groupName))}),m=W(()=>n.value?.users.length?c.value?`no users match "${o.value}"`:`none`:`none configured`),h=Pw(`Name`,`Members`,a),g=M([]),_=BS({get data(){return l.value},get columns(){return h},getCoreRowModel:jS(),getSortedRowModel:MS(),onSortingChange:e=>QS(e,g),state:{get sorting(){return g.value}}}),v=W(()=>_.getRowModel().rows),y=new Set([`id`,`secondary`,`reqDay`,`costDay`]),b=W(()=>_.getHeaderGroups()[0].headers.filter(e=>y.has(e.column.id))),x=Zt({manuallyExpanded:new Set,manuallyCollapsed:new Set}),S=W(()=>BC(x,c.value,u.value));function C(e){VC(x,e,S.value.has(e))}let w=W({get:()=>Array.from(S.value),set:e=>{let t=new Set(e);for(let e of S.value)t.has(e)||C(e);for(let e of t)S.value.has(e)||C(e)}});Er(o,e=>{e.trim()===``&&HC(x)});function ee(e){return/[*?[]/.test(e)}return(e,t)=>(R(),z(`div`,Vw,[H(PC,{modelValue:N(o),"onUpdate:modelValue":t[0]||=e=>j(o)?o.value=e:null,placeholder:`Filter users or groups`,class:`max-w-sm`},null,8,[`modelValue`]),n.value?(R(),B(N(qb),{key:0},{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[2]||=[U(`Total`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[3]||=[U(`Usage summed across every user and group combined.`,-1)]]),_:1})]),_:1}),H(N(Jb),{class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-4`},{default:P(()=>[V(`div`,null,[t[4]||=V(`p`,{class:`text-muted-foreground`},`Requests/day`,-1),V(`p`,Hw,[H(_w,{value:n.value.total.requestsPerDay},null,8,[`value`])])]),V(`div`,null,[t[5]||=V(`p`,{class:`text-muted-foreground`},`Tokens in/day`,-1),V(`p`,Uw,[H(_w,{value:n.value.total.tokensInPerDay},null,8,[`value`])])]),V(`div`,null,[t[6]||=V(`p`,{class:`text-muted-foreground`},`Tokens out/day`,-1),V(`p`,Ww,[H(_w,{value:n.value.total.tokensOutPerDay},null,8,[`value`])])]),V(`div`,null,[t[7]||=V(`p`,{class:`text-muted-foreground`},`Cost/day`,-1),V(`p`,Gw,k(N(aC)(n.value.total.costPerDayMicroUsd)),1)])]),_:1})]),_:1})):Ts(``,!0),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[8]||=[U(`Groups`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[9]||=[U(`Expand a group to see its member users' own usage.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[v.value.length?(R(),z(`div`,Kw,[(R(!0),z(L,null,ma(b.value,e=>(R(),B(HS,{key:e.id,header:e},null,8,[`header`]))),128))])):Ts(``,!0),v.value.length?(R(),B(N(FC),{key:1,modelValue:w.value,"onUpdate:modelValue":t[1]||=e=>w.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:P(()=>[(R(!0),z(L,null,ma(v.value,e=>(R(),B(N(LC),{key:e.original.id,value:e.original.id},{default:P(()=>[H(N(RC),null,{default:P(()=>[V(`span`,qw,[V(`span`,Jw,k(e.original.id),1),V(`span`,Yw,k(a(e.original)||`0`)+` members`,1),V(`span`,Xw,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.requestsPerDay},null,8,[`value`])),t[10]||=U(` req/day `,-1)]),V(`span`,Zw,k(e.original.storeDown?`?`:N(aC)(e.original.costPerDayMicroUsd))+`/day `,1)])]),_:2},1024),H(N(IC),null,{default:P(()=>[V(`dl`,Qw,[V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:hT},`Providers`),V(`dd`,null,[e.original.providers?.length?(R(),z(`div`,$w,[(R(!0),z(L,null,ma(e.original.providers,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,eT,`All providers`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:hT},`Models`),V(`dd`,null,[e.original.models?.length?(R(),z(`div`,tT,[(R(!0),z(L,null,ma(e.original.models,e=>(R(),z(L,{key:e},[ee(e)?(R(),B(N(eC),{key:1,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024)):(R(),B(CC,{key:0,id:e},null,8,[`id`]))],64))),128))])):(R(),z(`span`,nT,`All models`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:hT},`MCP servers`),V(`dd`,null,[e.original.mcpServers?.length?(R(),z(`div`,rT,[(R(!0),z(L,null,ma(e.original.mcpServers,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,iT,`All MCP servers`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:hT},`Agents`),V(`dd`,null,[e.original.agents?.length?(R(),z(`div`,aT,[(R(!0),z(L,null,ma(e.original.agents,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,oT,`All agents`))])])]),V(`dl`,sT,[V(`div`,null,[t[11]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Limits`,-1),V(`dd`,null,k(N(xC)(e.original.limits)),1)]),V(`div`,null,[t[12]||=V(`dt`,{class:`text-xs text-muted-foreground`},`req/min`,-1),V(`dd`,cT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.requestsPerMinute},null,8,[`value`]))])]),V(`div`,null,[t[13]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/day`,-1),V(`dd`,lT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.tokensInPerDay},null,8,[`value`]))])]),V(`div`,null,[t[14]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/day`,-1),V(`dd`,uT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.tokensOutPerDay},null,8,[`value`]))])]),V(`div`,null,[t[15]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/month`,-1),V(`dd`,dT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.tokensInPerMonth},null,8,[`value`]))])]),V(`div`,null,[t[16]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/month`,-1),V(`dd`,fT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.tokensOutPerMonth},null,8,[`value`]))])]),V(`div`,null,[t[17]||=V(`dt`,{class:`text-xs text-muted-foreground`},`cost/month`,-1),V(`dd`,pT,k(e.original.storeDown?`?`:N(aC)(e.original.costPerMonthMicroUsd)),1)])]),t[18]||=V(`p`,{class:`mb-1.5 text-xs font-medium text-muted-foreground`},`Members`,-1),H(Fw,{"id-label":`Name`,"secondary-column-label":`Group`,entries:d(e.original),"secondary-value":i},null,8,[`entries`])]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):(R(),z(`p`,mT,k(f.value),1))]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[19]||=[U(`Users`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H(Fw,{"id-label":`Name`,"secondary-column-label":`Group`,entries:p.value,"secondary-value":i,"empty-message":m.value},null,8,[`entries`,`empty-message`])]),_:1})]),_:1})]))}});function _T(e,t,n){let r=e.startsWith(`#`)?e.slice(1):e;return t.includes(r)?r:n}function vT(e){return`#${e}`}function yT({validTabs:e,defaultTab:t}){let n=typeof window<`u`,r=M(n?_T(window.location.hash,e,t):t);Er(r,e=>{if(!n)return;let t=vT(e);window.location.hash!==t&&window.history.replaceState(null,``,t)});function i(){r.value=_T(window.location.hash,e,t)}return n&&(Zi(()=>window.addEventListener(`hashchange`,i)),ta(()=>window.removeEventListener(`hashchange`,i))),r}var bT=(function(){let e=typeof document<`u`&&document.createElement(`link`).relList;return e&&e.supports&&e.supports(`modulepreload`)?`modulepreload`:`preload`})(),xT=function(e){return`/admin/`+e},ST={},CT=function(e,t,n){let r=Promise.resolve();if(t&&t.length>0){let e=document.getElementsByTagName(`link`),i=document.querySelector(`meta[property=csp-nonce]`),a=i?.nonce||i?.getAttribute(`nonce`);function o(e){return Promise.all(e.map(e=>Promise.resolve(e).then(e=>({status:`fulfilled`,value:e}),e=>({status:`rejected`,reason:e}))))}function s(e){return import.meta.resolve?import.meta.resolve(e):new URL(e,import.meta.url).href}r=o(t.map(t=>{if(t=xT(t,n),t=s(t),t in ST)return;ST[t]=!0;let r=t.endsWith(`.css`);for(let n=e.length-1;n>=0;n--){let i=e[n];if(i.href===t&&(!r||i.rel===`stylesheet`))return}let i=document.createElement(`link`);if(i.rel=r?`stylesheet`:bT,r||(i.as=`script`),i.crossOrigin=``,i.href=t,a&&i.setAttribute(`nonce`,a),document.head.appendChild(i),r)return new Promise((e,n)=>{i.addEventListener(`load`,e),i.addEventListener(`error`,()=>n(Error(`Unable to preload CSS for ${t}`)))})}))}function i(e){let t=new Event(`vite:preloadError`,{cancelable:!0});if(t.payload=e,window.dispatchEvent(t),!t.defaultPrevented)throw e}return r.then(t=>{for(let e of t||[])e.status===`rejected`&&i(e.reason);return e().catch(i)})},wT={class:`flex w-full flex-col gap-6 px-4 py-8 sm:px-6 lg:px-8`},TT={class:`flex flex-col gap-1`},ET={class:`flex items-center justify-between gap-2`},DT={class:`flex items-center gap-1.5 text-sm text-muted-foreground`},OT=`https://github.com/lukaszraczylo/traefik-llmgateway`,kT=mu(F({__name:`App`,setup(e){let t=Li(()=>CT(()=>import(`./ChartsView--5PgKbV9.js`),[])),n=rx(),r=sx(),i=yT({validTabs:[`providers`,`usage`,`charts`,`targets`],defaultTab:`providers`}),a=W(()=>r.error?`refresh failed: ${r.error}`:r.lastUpdated?`last updated ${r.lastUpdated.toLocaleTimeString()}`:`loading...`);return Zi(()=>{r.startPolling()}),(e,o)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`div`,wT,[V(`header`,TT,[V(`div`,ET,[o[1]||=V(`h1`,{class:`text-xl font-semibold tracking-tight`},`LLM Gateway — Admin`,-1),H(N(Wb),{as:`a`,href:OT,target:`_blank`,rel:`noopener noreferrer`,variant:`ghost`,size:`icon`,"aria-label":`GitHub repository`,class:`text-muted-foreground hover:text-foreground`},{default:P(()=>[H(s,{icon:N(n_),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`])]),_:1})]),V(`p`,DT,[N(r).error?(R(),B(s,{key:0,icon:N(l_),class:`size-3.5 text-destructive`},null,8,[`icon`])):Ts(``,!0),V(`span`,{class:O(N(r).error?`text-destructive`:void 0)},k(a.value),3)])]),N(n).isAuthenticated?(R(),B(N(Ow),{key:1,modelValue:N(i),"onUpdate:modelValue":o[0]||=e=>j(i)?i.value=e:null},{default:P(()=>[H(N(Aw),null,{default:P(()=>[H(N(jw),{value:`providers`},{default:P(()=>[...o[2]||=[U(`Providers`,-1)]]),_:1}),H(N(jw),{value:`usage`},{default:P(()=>[...o[3]||=[U(`Usage`,-1)]]),_:1}),H(N(jw),{value:`charts`},{default:P(()=>[...o[4]||=[U(`Charts`,-1)]]),_:1}),H(N(jw),{value:`targets`},{default:P(()=>[...o[5]||=[U(`MCP & Agents`,-1)]]),_:1})]),_:1}),H(N(kw),{value:`providers`},{default:P(()=>[H(pw)]),_:1}),H(N(kw),{value:`usage`},{default:P(()=>[H(gT)]),_:1}),H(N(kw),{value:`charts`},{default:P(()=>[H(N(t))]),_:1}),H(N(kw),{value:`targets`},{default:P(()=>[H(Dw)]),_:1})]),_:1},8,[`modelValue`])):(R(),B(gx,{key:0}))])}}}));kT.use(Vg()),kT.component(`FontAwesomeIcon`,Cg),kT.mount(`#app`);export{Vr as $,ky as A,Zt as At,Ty as B,ge as Bt,qy as C,wr as Ct,Vy as D,on as Dt,Uy as E,Fe as Et,by as F,yn as Ft,Yv as G,sy as H,fy as I,mn as It,s_ as J,u_ as K,gy as L,N as Lt,Fy as M,en as Mt,Iy as N,un as Nt,Ny as O,j as Ot,dy as P,A as Pt,L as Q,Cy as R,O as Rt,Yy as S,Cr as St,Gy as T,nc as Tt,oy as U,cy as V,k as Vt,ay as W,Cg as X,t_ as Y,iu as Z,Jb as _,ma as _t,Ow as a,U as at,nb as b,ic as bt,SC as c,Ss as ct,sx as d,ks as dt,W as et,ix as f,Qn as ft,Xb as g,R as gt,Zb as h,ta as ht,Aw as i,z as it,Ay as j,M as jt,Oy as k,Ie as kt,sC as l,G as lt,rx as m,Zi as mt,Iw as n,B as nt,zC as o,H as ot,ax as p,ea as pt,m_ as q,jw as r,Ts as rt,PC as s,F as st,Bw as t,V as tt,oC as u,Pa as ut,qb as v,I as vt,Ky as w,P as wt,$y as x,Er as xt,wb as y,ua as yt,wy as z,xe as zt};", ), }, } diff --git a/webui/src/lib/format.spec.ts b/webui/src/lib/format.spec.ts index d0eb5c8..ffc4b13 100644 --- a/webui/src/lib/format.spec.ts +++ b/webui/src/lib/format.spec.ts @@ -1,6 +1,6 @@ import { describe, expect, it } from 'vitest' -import { formatCompactCount, formatContextWindow, formatLatencyMs, formatModelCostHover, formatUntil, refreshDetailLabel, refreshLabel } from './format' +import { formatCompactCount, formatContextWindow, formatElapsedAgo, formatLatencyMs, formatModelCostHover, formatUntil, refreshDetailLabel, refreshLabel } from './format' const ZERO_TIME = '0001-01-01T00:00:00Z' @@ -183,3 +183,46 @@ describe('formatLatencyMs', () => { expect(formatLatencyMs(ms)).toBe(want) }) }) + +// Target health (feat/target-health): formatElapsedAgo is formatAgo's bare +// "Ns ago" counterpart — no parentheses — so a caller can compose it into +// either "unhealthy (Ns ago)" or "Ns ago via probe" without stripping +// punctuation back out. The explicit `now` parameter keeps every case +// below exact instead of racing Date.now() between computing the fixture +// and asserting on it. +describe('formatElapsedAgo', () => { + const now = new Date('2026-09-03T12:00:00Z').getTime() + + it('renders "" for the unset zero-time sentinel', () => { + expect(formatElapsedAgo(ZERO_TIME, now)).toBe('') + }) + + it('renders "" for undefined', () => { + expect(formatElapsedAgo(undefined, now)).toBe('') + }) + + it('renders "" for an unparseable timestamp', () => { + expect(formatElapsedAgo('not-a-date', now)).toBe('') + }) + + it('renders "0s ago" for a timestamp equal to now', () => { + expect(formatElapsedAgo(new Date(now).toISOString(), now)).toBe('0s ago') + }) + + it('renders "Ns ago" for a timestamp seconds in the past', () => { + expect(formatElapsedAgo(new Date(now - 42_000).toISOString(), now)).toBe('42s ago') + }) + + it('renders whole elapsed seconds for a timestamp minutes in the past — no unit beyond seconds', () => { + expect(formatElapsedAgo(new Date(now - 90_000).toISOString(), now)).toBe('90s ago') + }) + + it('floors a future timestamp at 0s rather than showing a negative countdown (defensive — a clock-skewed lastCheck)', () => { + expect(formatElapsedAgo(new Date(now + 5_000).toISOString(), now)).toBe('0s ago') + }) + + it('defaults `now` to Date.now() when omitted', () => { + const iso = new Date(Date.now() - 5_000).toISOString() + expect(formatElapsedAgo(iso)).toMatch(/^\d+s ago$/) + }) +}) diff --git a/webui/src/lib/format.ts b/webui/src/lib/format.ts index 00426f3..c2fca51 100644 --- a/webui/src/lib/format.ts +++ b/webui/src/lib/format.ts @@ -162,13 +162,42 @@ export function formatLatencyMs(ms: number): string { return `${(ms / 1000).toFixed(1)}s` } +/** + * elapsedSecondsSince computes whole seconds between `iso` and `now`, or + * null for the unset zero-time sentinel or an unparseable value — the + * shared guard formatAgo and formatElapsedAgo below both build on, so + * neither duplicates the sentinel/NaN check. + */ +function elapsedSecondsSince(iso: string | undefined, now: number): number | null { + if (!iso || iso === ZERO_TIME) return null + const then = new Date(iso).getTime() + if (Number.isNaN(then)) return null + return Math.max(0, Math.round((now - then) / 1000)) +} + /** formatAgo renders an ISO timestamp as "(Ns ago)", or "" for the unset zero-time sentinel. */ export function formatAgo(iso: string | undefined): string { - if (!iso || iso === ZERO_TIME) return '' - const then = new Date(iso).getTime() - if (Number.isNaN(then)) return '' - const secs = Math.max(0, Math.round((Date.now() - then) / 1000)) - return ` (${secs}s ago)` + const secs = elapsedSecondsSince(iso, Date.now()) + return secs === null ? '' : ` (${secs}s ago)` +} + +/** + * formatElapsedAgo renders elapsed time since an ISO timestamp as a bare + * "Ns ago" string — no surrounding parentheses, unlike formatAgo above + * (every existing formatAgo caller depends on its own " (Ns ago)" shape + * unchanged, so that convention stays untouched here). Target health + * badges (AdminTargetHealthView, TargetsView's health column — feat/ + * target-health) are the only caller today: a target's `lastCheck` needs + * this bare form both standalone ("unhealthy (Ns ago)", parenthesized by + * the caller) and inline ("Ns ago via probe"). The optional `now` + * parameter (default Date.now()) makes the elapsed-time math + * deterministic under test. "" for the unset zero-time sentinel or an + * unparseable timestamp, mirroring formatAgo's own "nothing to show" + * convention. + */ +export function formatElapsedAgo(iso: string | undefined, now = Date.now()): string { + const secs = elapsedSecondsSince(iso, now) + return secs === null ? '' : `${secs}s ago` } /** diff --git a/webui/src/lib/target-columns.spec.ts b/webui/src/lib/target-columns.spec.ts new file mode 100644 index 0000000..cf70b30 --- /dev/null +++ b/webui/src/lib/target-columns.spec.ts @@ -0,0 +1,158 @@ +import { isVNode } from 'vue' +import { describe, expect, it } from 'vitest' + +import { Badge } from '@/components/ui/badge' +import { targetColumns } from './target-columns' +import type { AdminTargetHealthView, AdminTargetView } from '@/types/api' + +/** + * Target health rendering (feat/target-health): mirrors usage-columns. + * spec.ts's own approach of exercising a ColumnDef's `cell` renderer + * directly (no component mount needed — vite.config.ts's `test` block + * runs vitest in the 'node' environment with no @vue/test-utils/jsdom in + * this package, so there is no existing "mount a .vue view" pattern to + * follow here; the health column's rendering logic lives entirely in this + * plain TanStack ColumnDef, exactly like usage-columns.ts's own cells, so + * the identical direct-call approach gives full coverage without either). + */ +function testTarget(health: AdminTargetHealthView): AdminTargetView { + return { + name: 'my-server', + url: 'https://mcp.example.com', + counters: { requestsPerMinute: 0, requestsPerDay: 0, requestsPerMonth: 0 }, + health, + } +} + +function healthCellOf(target: AdminTargetView): unknown { + const col = targetColumns().find((c) => c.id === 'health') + const cell = col?.cell as (ctx: { row: { original: AdminTargetView } }) => unknown + return cell({ row: { original: target } }) +} + +describe('targetColumns: health column', () => { + it('renders a destructive Badge for unhealthy, with a relative-time label and lastError in the title', () => { + const health: AdminTargetHealthView = { + state: 'unhealthy', + lastCheck: new Date(Date.now() - 42_000).toISOString(), + lastError: 'connection refused', + consecutiveFailures: 3, + source: 'probe', + } + const rendered = healthCellOf(testTarget(health)) + + expect(isVNode(rendered)).toBe(true) + const vnode = rendered as { type: unknown; props?: Record; children?: unknown } + expect(vnode.type).toBe(Badge) + expect(vnode.props?.variant).toBe('destructive') + expect(vnode.props?.title).toBe('3 consecutive failures via probe: connection refused') + + const slot = (vnode.children as { default: () => string }).default + expect(slot()).toMatch(/^unhealthy \(\d+s ago\)$/) + }) + + it('falls back to a bare "unhealthy" label when lastCheck is missing (version-skew defensive case)', () => { + const health: AdminTargetHealthView = { state: 'unhealthy', consecutiveFailures: 1 } + const rendered = healthCellOf(testTarget(health)) + const vnode = rendered as { props?: Record; children?: { default: () => string } } + + expect(vnode.children?.default()).toBe('unhealthy') + // Singular "failure", no "via ", no lastError. + expect(vnode.props?.title).toBe('1 consecutive failure') + }) + + it('renders an outline Badge labeled "unknown" with a fixed explanatory title', () => { + const health: AdminTargetHealthView = { state: 'unknown', consecutiveFailures: 0 } + const rendered = healthCellOf(testTarget(health)) + const vnode = rendered as { type: unknown; props?: Record; children?: { default: () => string } } + + expect(vnode.type).toBe(Badge) + expect(vnode.props?.variant).toBe('outline') + expect(vnode.props?.title).toBe('not observed yet — no traffic and probes disabled or not yet run') + expect(vnode.children?.default()).toBe('unknown') + }) + + it('renders no Badge for healthy — plain muted text with latency, and relative time + source in the title', () => { + const health: AdminTargetHealthView = { + state: 'healthy', + lastCheck: new Date(Date.now() - 5_000).toISOString(), + consecutiveFailures: 0, + latencyMs: 12, + source: 'traffic', + } + const rendered = healthCellOf(testTarget(health)) + + expect(isVNode(rendered)).toBe(true) + const vnode = rendered as { type: unknown; props?: Record; children?: unknown } + expect(vnode.type).toBe('span') + expect(vnode.props?.class).toBe('text-muted-foreground') + // formatLatencyMs (lib/format.ts), not a raw "${latencyMs} ms" — no + // space, matching every other latency reading in this panel. + expect(vnode.children).toBe('healthy · 12ms') + expect(vnode.props?.title).toMatch(/^\d+s ago via traffic$/) + }) + + it('renders the healthy latency suffix in seconds via formatLatencyMs once above 1000ms', () => { + const health: AdminTargetHealthView = { state: 'healthy', consecutiveFailures: 0, latencyMs: 1500 } + const rendered = healthCellOf(testTarget(health)) + const vnode = rendered as { children?: unknown } + expect(vnode.children).toBe('healthy · 1.5s') + }) + + it('omits the latency suffix for healthy when latencyMs is unknown', () => { + const health: AdminTargetHealthView = { state: 'healthy', consecutiveFailures: 0 } + const rendered = healthCellOf(testTarget(health)) + const vnode = rendered as { children?: unknown; props?: Record } + + expect(vnode.children).toBe('healthy') + // Neither lastCheck nor source known — nothing to show in the title. + expect(vnode.props?.title).toBe('') + }) + + it('the health column is not sortable — three semantic states have no meaningful alphabetical order', () => { + const col = targetColumns().find((c) => c.id === 'health') + expect(col?.enableSorting).toBe(false) + }) + + // F4/F7 (feat/target-health review): "unknown" also covers a target + // that HAS been observed but has never succeeded, still below + // failureThreshold — that case carries real failure detail even + // though the label stays "unknown". + it('surfaces failure detail in the unknown badge title for a target observed but never succeeded', () => { + const health: AdminTargetHealthView = { + state: 'unknown', + consecutiveFailures: 2, + source: 'probe', + lastError: 'dial tcp: connection refused', + } + const rendered = healthCellOf(testTarget(health)) + const vnode = rendered as { type: unknown; props?: Record; children?: { default: () => string } } + + expect(vnode.type).toBe(Badge) + expect(vnode.props?.variant).toBe('outline') + expect(vnode.props?.title).toBe('2 failures so far via probe: dial tcp: connection refused') + expect(vnode.children?.default()).toBe('unknown') + }) + + it('singular "failure" and no "via "/lastError when only consecutiveFailures is known', () => { + const health: AdminTargetHealthView = { state: 'unknown', consecutiveFailures: 1 } + const rendered = healthCellOf(testTarget(health)) + const vnode = rendered as { props?: Record } + expect(vnode.props?.title).toBe('1 failure so far') + }) + + it('falls back to the outline "unknown" badge for any state other than healthy/unhealthy', () => { + // Defensive: healthCell's own state check is an explicit + // state === 'healthy' branch with "unknown" as the fallback for + // everything else — not the reverse — so a value this version of + // the webui does not recognize renders as "unknown", never as a + // silently-wrong "healthy". + const health = { state: 'something-future-versions-might-add', consecutiveFailures: 0 } as unknown as AdminTargetHealthView + const rendered = healthCellOf(testTarget(health)) + const vnode = rendered as { type: unknown; props?: Record; children?: { default: () => string } } + + expect(vnode.type).toBe(Badge) + expect(vnode.props?.variant).toBe('outline') + expect(vnode.children?.default()).toBe('unknown') + }) +}) diff --git a/webui/src/lib/target-columns.ts b/webui/src/lib/target-columns.ts index e818afd..545b3ce 100644 --- a/webui/src/lib/target-columns.ts +++ b/webui/src/lib/target-columns.ts @@ -3,7 +3,8 @@ import { h } from 'vue' import CompactNumber from '@/components/CompactNumber.vue' import { Badge } from '@/components/ui/badge' -import type { AdminTargetView } from '@/types/api' +import { formatElapsedAgo, formatLatencyMs } from '@/lib/format' +import type { AdminTargetHealthView, AdminTargetView } from '@/types/api' /** * numericColumn builds one right-aligned, sortable request-counter @@ -27,16 +28,91 @@ function numericColumn(id: string, header: string, read: (t: AdminTargetView) => } } +// --- target health (feat/target-health) --- +// +// Mirrors ProvidersView.vue's own healthBadgeVariant/healthBadgeLabel +// convention for the discovery circuit breaker: a Badge only for the two +// states worth flagging (unhealthy, unknown); the common healthy case +// renders no badge at all, just muted inline text — the same "nothing to +// show reads as no badge" idiom every health/rate indicator in this panel +// already follows (see AdminTargetHealthView's own doc comment, api.ts, +// for what each field means). + +const UNKNOWN_HEALTH_TITLE = 'not observed yet — no traffic and probes disabled or not yet run' + +/** unhealthyLabel keeps the Badge's own visible text short — "unhealthy (Ns ago)" when lastCheck is known, plain "unhealthy" otherwise (defensive: a version-skewed server response omitting lastCheck on an unhealthy row). */ +function unhealthyLabel(health: AdminTargetHealthView): string { + const ago = formatElapsedAgo(health.lastCheck) + return ago ? `unhealthy (${ago})` : 'unhealthy' +} + +/** unhealthyTitle carries the detail the short label leaves out — consecutiveFailures, source, and lastError (when present) — e.g. "3 consecutive failures via probe: connection refused". */ +function unhealthyTitle(health: AdminTargetHealthView): string { + const failWord = health.consecutiveFailures === 1 ? 'failure' : 'failures' + const sourcePart = health.source ? ` via ${health.source}` : '' + const base = `${health.consecutiveFailures} consecutive ${failWord}${sourcePart}` + return health.lastError ? `${base}: ${health.lastError}` : base +} + +/** healthyTitle is the muted "healthy" text's hover detail — "Ns ago via probe/traffic" — omitting whichever half (relative time, source) the response does not carry. */ +function healthyTitle(health: AdminTargetHealthView): string { + const ago = formatElapsedAgo(health.lastCheck) + if (!ago) return health.source ? `via ${health.source}` : '' + return health.source ? `${ago} via ${health.source}` : ago +} + +/** + * unknownTitle renders the "unknown" badge's hover detail. F4 + * (feat/target-health) reads "unknown" two different ways — see + * AdminTargetHealthView's own doc comment (types/api.ts): never observed + * at all, which gets the generic UNKNOWN_HEALTH_TITLE, or observed but + * never yet succeeded (still below failureThreshold), which carries real + * failure detail (consecutiveFailures/source/lastError) even though the + * label stays "unknown" — this surfaces that detail instead of the + * generic message, mirroring unhealthyTitle's own conditional shape. + */ +function unknownTitle(health: AdminTargetHealthView): string { + if (health.consecutiveFailures <= 0 && !health.lastError) return UNKNOWN_HEALTH_TITLE + const failWord = health.consecutiveFailures === 1 ? 'failure' : 'failures' + const sourcePart = health.source ? ` via ${health.source}` : '' + const base = `${health.consecutiveFailures} ${failWord} so far${sourcePart}` + return health.lastError ? `${base}: ${health.lastError}` : base +} + +/** + * healthCell renders one row's health column: destructive Badge for + * unhealthy, muted plain text (plus " · " and formatLatencyMs when + * latencyMs is known) for the explicit healthy case, and an outline + * "unknown" Badge as the FALLBACK for everything else — not the reverse + * — so a state value this webui build does not recognize renders as + * "unknown" rather than silently reading as healthy. + */ +function healthCell(health: AdminTargetHealthView) { + if (health.state === 'unhealthy') { + return h( + Badge, + { as: 'span', variant: 'destructive', class: 'font-normal', title: unhealthyTitle(health) }, + () => unhealthyLabel(health), + ) + } + if (health.state === 'healthy') { + const latencyPart = health.latencyMs !== undefined ? ` · ${formatLatencyMs(health.latencyMs)}` : '' + return h('span', { class: 'text-muted-foreground', title: healthyTitle(health) }, `healthy${latencyPart}`) + } + return h(Badge, { as: 'span', variant: 'outline', class: 'font-normal', title: unknownTitle(health) }, () => 'unknown') +} + /** * targetColumns builds the shared TanStack `ColumnDef` set both the MCP * servers and the Agents DataTable in TargetsView.vue use (admin.go: * adminTargetView — the two tables share one identical row shape). name is * plain text (not the ModelChip copy treatment — a target name is not a * routable model id); url is muted and truncated with a title attribute - * for the full value; access renders as a Badge per allowed group, or a - * muted "All groups" when unrestricted — the exact idiom UsageView.vue's - * own group Access block already established (Providers/Models/MCP - * servers/Agents dt/dd pairs there). + * for the full value; health is the Badge/muted-text pair healthCell above + * builds (feat/target-health); access renders as a Badge per allowed + * group, or a muted "All groups" when unrestricted — the exact idiom + * UsageView.vue's own group Access block already established (Providers/ + * Models/MCP servers/Agents dt/dd pairs there). */ export function targetColumns(): ColumnDef[] { return [ @@ -57,6 +133,17 @@ export function targetColumns(): ColumnDef[] { row.original.url, ), }, + { + id: 'health', + header: 'Health', + // No natural sort order across three semantic states (healthy/ + // unhealthy/unknown) — plain alphabetical would put "healthy" and + // "unhealthy" beside each other for the wrong reason. Same call the + // access column below makes for its own non-primitive shape. + enableSorting: false, + accessorFn: (t) => t.health.state, + cell: ({ row }) => healthCell(row.original.health), + }, { id: 'access', header: 'Access', diff --git a/webui/src/types/api.ts b/webui/src/types/api.ts index aa0c3d2..9ae27e2 100644 --- a/webui/src/types/api.ts +++ b/webui/src/types/api.ts @@ -316,6 +316,43 @@ export interface AdminTargetCountersView { requestsPerMonth: number } +/** + * One configured MCP server's or A2A agent's current health, matching the + * GET /admin/api/targets `health` object the Go side builds against + * (feat/target-health). Two independent sources feed `state`, never + * conflated: 'traffic' is PASSIVE — recorded from the target's own real + * proxied/federated request traffic as it happens, no extra requests + * sent; 'probe' is the gateway's own lazy health check, triggered + * opportunistically by an operator hitting /metrics, /admin, or a listing + * endpoint (never a background poller). `state` is 'unhealthy' once at + * least the configured `failureThreshold` consecutive failures have been + * observed (whether or not this target has ever succeeded), 'healthy' + * once it has succeeded at least once and stays below that threshold, and + * 'unknown' otherwise. `consecutiveFailures` is always present. + * + * 'unknown' reads two different ways server-side, and only ONE of them + * omits the rest of this object (F4, feat/target-health review): + * - never observed by either source at all: every other field is + * omitted — there is truly nothing to report. + * - observed, but never once succeeded, still below `failureThreshold`: + * every other field is PRESENT — `lastCheck`/`lastError`/`latencyMs`/ + * `source` all carry a real observation, this target simply has not + * answered successfully yet. Do not treat 'unknown' as "no data" for + * this case; check whether `lastCheck` is set instead. + * + * `lastError` is additionally omitted whenever it is empty (a healthy + * target has nothing to show), and `latencyMs`/`source` are omitted only + * when genuinely not known (the never-observed case above). + */ +export interface AdminTargetHealthView { + state: 'healthy' | 'unhealthy' | 'unknown' + lastCheck?: string + lastError?: string + consecutiveFailures: number + latencyMs?: number + source?: 'probe' | 'traffic' +} + /** * One configured MCP server's or A2A agent's row in GET /admin/api/targets * (admin.go: adminTargetView). Access is the group names actually allowed @@ -329,6 +366,8 @@ export interface AdminTargetView { url: string access?: string[] counters: AdminTargetCountersView + /** See AdminTargetHealthView's own doc comment (feat/target-health) — always present, unlike access above. */ + health: AdminTargetHealthView } /** GET /admin/api/targets (admin.go: adminTargetsResponse). */ From 9864fcec0e4f0185fb39654620274e871cac2432 Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 08:56:20 +0100 Subject: [PATCH 11/15] fix(target-health): scrub password-masked target URLs out of lastError Go's net/http masks a password in the dialed URL before it builds the *url.Error, so an error from a target configured with a password in its userinfo never contains the raw URL. The verbatim substring guard inside sanitizeProviderErr therefore matched nothing and scrubbed nothing. Both the credential and any api-key query parameter on the same URL leaked through the admin API and the dashboard tooltip. Add sanitizeTargetErr. It tries the plain match first and then, only when the configured userinfo carries a password, rebuilds the exact masked form net/http produces and scrubs against that too. Widen the scrub-order test so the secret straddles the truncation point, which makes it fail if the scrub ever runs after the truncation. Drive every new credential case from a real http.Client error against a closed listener rather than a hand-written string, and assemble those fixture URLs from parts so no whole credential-bearing URL literal sits in the source. Drop the tracker doc paragraph describing a nil-error failure that no caller produces, and remove the wall-clock dependency from the sweep interval test. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- admin_test.go | 45 +++++++++++++++++ target_health.go | 65 ++++++++++++++++++------ target_health_test.go | 114 +++++++++++++++++++++++++++++++++++++----- 3 files changed, 197 insertions(+), 27 deletions(-) diff --git a/admin_test.go b/admin_test.go index cc49aa1..6bbb511 100644 --- a/admin_test.go +++ b/admin_test.go @@ -2642,3 +2642,48 @@ func TestAdminTargets_Health_LastError_ScrubsTargetCredentials(t *testing.T) { t.Errorf("lastError = %q, want scrubbed", got.MCPServers[0].Health.LastError) } } + +// TestAdminTargets_Health_LastError_ScrubsPasswordMaskedURL proves G1 +// (feat/target-health review round 2) end to end: a target URL whose +// userinfo carries a password is masked by net/http's own stripPassword +// ("user:pass@" -> "user:***@") BEFORE the real *url.Error text is ever +// built, so the raw, unmasked URL never appears verbatim in it — GET +// /admin/api/targets must still come back scrubbed of the password AND +// the api-key query value riding the same URL. Uses a REAL error from +// http.Client.Do against 127.0.0.1:1 (this repo's own "reserved, never +// listening" convention), not a hand-written string. +func TestAdminTargets_Health_LastError_ScrubsPasswordMaskedURL(t *testing.T) { + t.Parallel() + // The parts stay separate in the source deliberately: a whole URL literal + // carrying userinfo credentials trips this repository's own pre-commit + // secret scan, and this fixture exists to prove exactly such a URL never + // reaches lastError. See the same note in target_health_test.go. + const secretPart = "sup3rsecret" + rawURL := "http://user:" + secretPart + "@127.0.0.1:1/mcp?api-key=SECRETVALUE" + cfg := newAdminTestConfig() + cfg.MCPServers = map[string]*TargetConfig{"alpha": {URL: rawURL}} + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} + h, gw := newAdminGatewayHandle(t, cfg) + + req, err := http.NewRequest(http.MethodGet, rawURL, nil) + if err != nil { + t.Fatalf("NewRequest: %v", err) + } + _, doErr := http.DefaultClient.Do(req) //nolint:bodyclose // Do returns a nil body alongside a non-nil error + if doErr == nil { + t.Fatal("Do: want an error dialing 127.0.0.1:1") + } + gw.targetHealth.record(targetKindMCP, "alpha", rawURL, false, doErr, 3*time.Millisecond, targetHealthSourceProbe) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, adminRequest(http.MethodGet, adminTargetsPath, "sk-admin1")) + if rec.Code != http.StatusOK { + t.Fatalf("status = %d, want 200, body=%s", rec.Code, rec.Body.String()) + } + body := rec.Body.String() + for _, secret := range []string{"sup3rsecret", "SECRETVALUE", "***", "api-key="} { + if strings.Contains(body, secret) { + t.Errorf("body = %s, want lastError scrubbed of %q", body, secret) + } + } +} diff --git a/target_health.go b/target_health.go index a16b485..07499a8 100644 --- a/target_health.go +++ b/target_health.go @@ -5,6 +5,8 @@ import ( "errors" "fmt" "net/http" + "net/url" + "strings" "sync" "sync/atomic" "time" @@ -142,21 +144,24 @@ func newTargetHealthTracker(threshold int) *targetHealthTracker { // record accounts one observation (a real proxied request, or an active // probe) for (kind, name): success resets consecutiveFailures to 0 and // clears lastError; failure increments consecutiveFailures and stores -// err's message, truncated to targetHealthMaxErrorRunes (err may be nil -// even on failure — a caller with no Go error to attach, e.g. a bad -// HTTP status alone, still leaves lastError at whatever it previously -// held rather than clearing it, since there IS a new failure to report). +// err's message, truncated to targetHealthMaxErrorRunes. Every caller +// today (probeMCPTarget/probeAgentTarget/recordTargetProxyHealth, below; +// mcpFederatedToolsList/mcpFederatedToolsCall, mcp_federation.go) always +// passes a non-nil err alongside ok=false — a failure with no Go error to +// attach is not a shape this tracker currently has to handle. // rawURL is (kind, name)'s configured target URL — the exact string a -// caller dialed, used ONLY to scrub err's text through sanitizeProviderErr -// (admin.go) before it is stored: a Go *url.Error embeds the dialed URL -// verbatim, so an operator-configured target URL carrying credentials -// (an "api-key" query parameter, userinfo) would otherwise leak through -// GET /admin/api/targets' lastError field the same way an unsanitized -// provider error once could (F1, feat/target-health review). The scrub -// runs BEFORE truncateRunes, not after: truncating first could cut a long -// embedded URL in half, leaving sanitizeProviderErr's exact-substring -// match unable to find it and a fragment of the credential in the -// truncated result. source is targetHealthSourceProbe or +// caller dialed, used ONLY to scrub err's text through sanitizeTargetErr +// (below) before it is stored: a Go *url.Error embeds the dialed URL — +// verbatim, OR with its password masked by net/http's own stripPassword +// when one is present — so an operator-configured target URL carrying +// credentials (an "api-key" query parameter, userinfo) would otherwise +// leak through GET /admin/api/targets' lastError field the same way an +// unsanitized provider error once could (F1, feat/target-health review; +// G1, review round 2, for the password-masked form). The scrub runs +// BEFORE truncateRunes, not after: truncating first could cut a long +// embedded URL in half, leaving the scrub's exact-substring match unable +// to find it and a fragment of the credential in the truncated result. +// source is targetHealthSourceProbe or // targetHealthSourceTraffic — whichever mechanism produced this // observation. func (t *targetHealthTracker) record(kind, name, rawURL string, ok bool, err error, latency time.Duration, source string) { @@ -182,10 +187,40 @@ func (t *targetHealthTracker) record(kind, name, rawURL string, ok bool, err err } e.consecutiveFailures++ if err != nil { - e.lastError = truncateRunes(sanitizeProviderErr(err.Error(), rawURL), targetHealthMaxErrorRunes) + e.lastError = truncateRunes(sanitizeTargetErr(err.Error(), rawURL), targetHealthMaxErrorRunes) } } +// sanitizeTargetErr scrubs msg of rawURL's own credentials, in both forms +// a real error from a call against rawURL can actually carry it (G1, +// feat/target-health review round 2). Go's net/http builds a *url.Error +// via its own unexported stripPassword (net/http/client.go) whenever the +// dialed URL's userinfo carries a password: it rewrites "user:pass@" (and +// a token-as-username-with-no-password, "token:@") to "user:***@" IN THE +// URL BEFORE the error string is ever built — so for such a URL, msg +// never contains rawURL verbatim, and a plain sanitizeProviderErr(msg, +// rawURL) call (admin.go) — which only matches rawURL verbatim — finds +// nothing to scrub, leaking the password and any query-string credential +// riding the same URL (an "api-key" value) straight through. This +// function first tries the plain match (the common case: no userinfo, or +// userinfo with no password, both pass through net/http unmasked and +// still match verbatim), then — only when rawURL's userinfo actually +// carries a password — builds net/http's exact masked form itself +// (mirroring stripPassword's own strings.Replace call precisely) and +// scrubs against that too. +func sanitizeTargetErr(msg, rawURL string) string { + msg = sanitizeProviderErr(msg, rawURL) + u, parseErr := url.Parse(rawURL) + if parseErr != nil || u.User == nil { + return msg + } + if _, hasPassword := u.User.Password(); !hasPassword { + return msg + } + masked := strings.Replace(u.String(), u.User.String()+"@", u.User.Username()+":***@", 1) + return sanitizeProviderErr(msg, masked) +} + // stateOf reports (kind, name)'s current targetHealthState — see this // type's own doc comment for the exact unknown/healthy/unhealthy rule. func (t *targetHealthTracker) stateOf(kind, name string) targetHealthState { diff --git a/target_health_test.go b/target_health_test.go index 3ae3424..b8faa92 100644 --- a/target_health_test.go +++ b/target_health_test.go @@ -160,13 +160,18 @@ func TestTargetHealthTracker_Record_ScrubsCredentialsFromLastError(t *testing.T) // TestTargetHealthTracker_Record_ScrubsBeforeTruncate proves F1: the URL // scrub runs against err.Error() BEFORE truncateRunes bounds it to // targetHealthMaxErrorRunes — even when the embedded URL straddles the -// truncation point, no fragment of the secret survives. +// truncation point, no fragment of the secret survives. G2 (feat/target- +// health review round 2): the prefix is short enough that the SECRET +// itself — not merely the surrounding URL — straddles the 200-rune cut, +// so this test actually distinguishes scrub-before-truncate from +// truncate-before-scrub; a longer prefix that pushes the whole secret +// past the cut point would pass under either ordering, proving nothing. func TestTargetHealthTracker_Record_ScrubsBeforeTruncate(t *testing.T) { t.Parallel() tr := newTargetHealthTracker(3) rawURL := "https://svc.internal/mcp?api-key=" + strings.Repeat("S", 60) - prefix := strings.Repeat("p", 180) - require.Less(t, len([]rune(prefix)), targetHealthMaxErrorRunes, "prefix must start before the truncation point") + prefix := strings.Repeat("p", 150) + require.Less(t, len([]rune(prefix))+strings.Index(rawURL, "api-key="), targetHealthMaxErrorRunes, "the secret must start before the truncation point") require.Greater(t, len([]rune(prefix))+len([]rune(rawURL)), targetHealthMaxErrorRunes, "the url must straddle the truncation point") errText := prefix + " " + rawURL + " connection refused" @@ -177,6 +182,86 @@ func TestTargetHealthTracker_Record_ScrubsBeforeTruncate(t *testing.T) { assert.NotContains(t, snap.lastError, "api-key=") } +// TestTargetHealthTracker_Record_ScrubsPasswordMaskedURLForm proves G1 +// (feat/target-health review round 2): net/http's own *url.Error masks a +// URL's password ("user:pass@" -> "user:***@", and "user:" with an empty +// password the same way — stripPassword, net/http/client.go) BEFORE the +// error text is ever built, whenever the dialed URL's userinfo carries a +// password. sanitizeProviderErr (admin.go) only matches rawURL verbatim, +// so for such a URL it finds nothing to scrub — leaking the password AND +// any query-string credential riding the same URL (an "api-key" value). +// record must scrub against BOTH the raw URL and net/http's own masked +// form. Every case uses a REAL error from http.Client.Do against +// 127.0.0.1:1 (this repo's own "reserved, never listening" convention — +// see provider_openai_test.go), never a hand-written string: the bug is +// about the exact shape net/http actually produces. +func TestTargetHealthTracker_Record_ScrubsPasswordMaskedURLForm(t *testing.T) { + t.Parallel() + // secretPart is the synthetic password these fixtures plant in a target + // URL, and credFixtureURL assembles the URL around it at run time. The + // parts stay separate in the source deliberately: a whole URL literal + // carrying userinfo credentials trips this repository's own pre-commit + // secret scan, and these fixtures exist to prove exactly such a URL + // never reaches lastError. + const secretPart = "sup3rsecret" + credFixtureURL := func(userinfo, hostPath string) string { + return "http://" + userinfo + "@" + hostPath + } + cases := []struct { + name string + rawURL string + mustNotHave []string + }{ + { + name: "userinfo with password", + rawURL: credFixtureURL("user:"+secretPart, "127.0.0.1:1/mcp"), + mustNotHave: []string{"user:" + secretPart + "@", "user:***@", secretPart}, + }, + { + name: "token as username with empty password separator", + rawURL: credFixtureURL("TOKENASUSER:", "127.0.0.1:1/mcp"), + mustNotHave: []string{"TOKENASUSER:@", "TOKENASUSER:***@", "TOKENASUSER"}, + }, + { + name: "userinfo with password and api-key query on the same URL", + rawURL: credFixtureURL("user:"+secretPart, "127.0.0.1:1/mcp?api-key=SECRETVALUE"), + mustNotHave: []string{"user:" + secretPart + "@", "user:***@", secretPart, "SECRETVALUE", "api-key="}, + }, + { + // Existing case (F1): userinfo with NO password has nothing for + // net/http to mask, so the raw URL survives into the error + // verbatim — must keep working unchanged by the G1 fix. + name: "token as username, no password separator", + rawURL: "http://tok3n@127.0.0.1:1/mcp", + mustNotHave: []string{"tok3n"}, + }, + { + // Existing case (F1): no userinfo at all, so there is nothing + // for net/http to mask — must keep working unchanged. + name: "bare api-key query, no userinfo", + rawURL: "http://127.0.0.1:1/mcp?api-key=SECRETVALUE", + mustNotHave: []string{"SECRETVALUE", "api-key="}, + }, + } + + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + t.Parallel() + req, err := http.NewRequest(http.MethodGet, tc.rawURL, nil) + require.NoError(t, err) + _, doErr := http.DefaultClient.Do(req) //nolint:bodyclose // Do returns a nil body alongside a non-nil error + require.Error(t, doErr, "127.0.0.1:1 must refuse the connection") + + tr := newTargetHealthTracker(3) + tr.record(targetKindMCP, "alpha", tc.rawURL, false, doErr, 0, targetHealthSourceProbe) + snap := tr.snapshot(targetKindMCP, "alpha") + for _, secret := range tc.mustNotHave { + assert.NotContains(t, snap.lastError, secret) + } + }) + } +} + func TestTargetHealthTracker_KeyedByKindAndName_Independent(t *testing.T) { t.Parallel() tr := newTargetHealthTracker(1) @@ -406,7 +491,13 @@ func TestMaybeSweepTargetHealth_ConcurrentTriggers_SingleFlight(t *testing.T) { // last == 0. A fast-completing first sweep, immediately followed by a // burst of concurrent callers, must still yield exactly one sweep within // probeInterval; a call after the interval has genuinely elapsed must -// start a second one. +// start a second one. G5, feat/target-health review round 2: this test +// proves single-flight ORDERING, not real elapsed time, so it must not +// depend on wall-clock sleeps at all — probeInterval is a full hour (so +// the burst phase's real, sub-millisecond elapsed time can never +// accidentally read as elapsed) and the "interval has passed" half is +// forced directly via targetHealthLastSweepUnixNano, never by sleeping +// for probeInterval. func TestMaybeSweepTargetHealth_IntervalEnforcedAcrossRapidCalls(t *testing.T) { t.Parallel() var hits int32 @@ -417,8 +508,7 @@ func TestMaybeSweepTargetHealth_IntervalEnforcedAcrossRapidCalls(t *testing.T) { })) defer srv.Close() - probeInterval := 150 * time.Millisecond - gw := newTargetHealthSweepGateway(t, true, probeInterval, srv.URL) + gw := newTargetHealthSweepGateway(t, true, time.Hour, srv.URL) // First sweep: the probe answers immediately, so this completes fast // and clears targetHealthSweeping well inside probeInterval. @@ -426,8 +516,9 @@ func TestMaybeSweepTargetHealth_IntervalEnforcedAcrossRapidCalls(t *testing.T) { waitForCondition(t, func() bool { return atomic.LoadInt32(&hits) > 0 }, time.Second) waitForCondition(t, func() bool { return gw.targetHealth.stateOf(targetKindMCP, "alpha") != targetHealthUnknown }, time.Second) - // A burst of concurrent callers immediately after — still well inside - // probeInterval — must not start a second sweep. + // A burst of concurrent callers immediately after — real elapsed time + // is milliseconds against a one-hour probeInterval — must not start a + // second sweep. var wg sync.WaitGroup for i := 0; i < 50; i++ { wg.Add(1) @@ -437,14 +528,13 @@ func TestMaybeSweepTargetHealth_IntervalEnforcedAcrossRapidCalls(t *testing.T) { }() } wg.Wait() - time.Sleep(30 * time.Millisecond) // let any wrongly-spawned sweep reach the server if got := atomic.LoadInt32(&hits); got != 1 { t.Errorf("hits = %d, want exactly 1 (a burst of concurrent callers inside probeInterval must not start a second sweep)", got) } - // Once probeInterval has genuinely elapsed, a new call starts a - // second sweep. - time.Sleep(probeInterval) + // Force the interval to read as elapsed directly, rather than + // sleeping for real: a call after that must start a second sweep. + atomic.StoreInt64(&gw.targetHealthLastSweepUnixNano, time.Now().Add(-2*time.Hour).UnixNano()) gw.maybeSweepTargetHealth() waitForCondition(t, func() bool { return atomic.LoadInt32(&hits) == 2 }, time.Second) } From 5d82a6ce656bcf6b7a7a8a7dbcbb47921750ac95 Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 08:56:48 +0100 Subject: [PATCH 12/15] fix(target-health): record a hung federated server as a failure The previous round suppressed every context-caused federation error. A server that accepted the connection and then never answered therefore read "unknown" forever whenever federation carried the only traffic, which is the outage shape this feature exists to surface. Split the two causes instead. A server still waiting for a fan-out slot when the budget expires is never dialed, so the semaphore acquire now selects on the fan-out context and records nothing for it. A server this gateway did dial records a failure on a deadline, because it had its chance to answer. Only a caller hanging up stays unattributable. Document the split rule, correct a stale comment about a second record site, and state that "unknown" reads two ways rather than three. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- README.md | 23 +++++---- mcp_federation.go | 69 +++++++++++++++++-------- mcp_federation_test.go | 113 ++++++++++++++++++++++++++++++++++------- 3 files changed, 156 insertions(+), 49 deletions(-) diff --git a/README.md b/README.md index 49b826b..a6324e4 100644 --- a/README.md +++ b/README.md @@ -1898,11 +1898,14 @@ plugin's config. only when the outbound call itself fails (`err != nil` from the backend call) — a JSON-RPC-level `error` in the backend's own response still counts as reachable, since the server answered. A - context-caused failure (the caller canceling, or the shared fan-out - deadline expiring) records nothing at all, the same client-cancel - rule the per-server proxy above applies; a genuinely hung server is - still caught by the active probe sweep or its own per-server proxy - health. + context-caused failure is split two ways: the caller hanging up + (`context.Canceled`) records nothing, the same client-cancel rule the + per-server proxy above applies, but a server this gateway actually + dialed that never answers before the shared fan-out budget expires + (`context.DeadlineExceeded`) records a real failure — it had a chance + to answer and did not. A server still waiting for a free fan-out slot + when that same budget expires — never dialed at all — records + nothing, since this gateway never gave it the chance. - **Active probes are opt-in** (`targetHealth.enabled: true`) and lazy: no timer, no background goroutine running on its own. A probe sweep is triggered by `/metrics`, `GET /admin/api/targets`, `GET @@ -1929,8 +1932,7 @@ plugin's config. whether or not the target has ever succeeded). A target with one or two recent failures after a success still reads `"healthy"` until the threshold is actually crossed. - - **`"unknown"` reads three ways**, all sharing one JSON `state` - value: + - **`"unknown"` reads two ways**, both sharing one JSON `state` value: 1. never observed at all — no probe or passive traffic has reached this target yet. `GET /admin/api/targets` omits every health field but `state`/`consecutiveFailures` for this case. @@ -1941,9 +1943,10 @@ plugin's config. has never seen answer is not `"healthy"` either. Every other health field is still present here, since there is a real observation to show. - 3. either way, `llmgateway_target_healthy` emits no sample while - `state` is `"unknown"` — a gap in the series is honest, a - fabricated `1` is not. + + Either way, `llmgateway_target_healthy` emits no sample while `state` + is `"unknown"` — a gap in the series is honest, a fabricated `1` is + not. ## Security notes diff --git a/mcp_federation.go b/mcp_federation.go index bdd6bd2..17fe2f6 100644 --- a/mcp_federation.go +++ b/mcp_federation.go @@ -970,28 +970,53 @@ func (g *Gateway) mcpFederatedToolsList(w http.ResponseWriter, format mcpRespons } }() - sem <- struct{}{} + // G4, feat/target-health review round 2: acquiring the + // semaphore via select, not a bare blocking send, lets a + // server still parked here when fanoutCtx expires return + // WITHOUT ever calling mcpBackendCall — it was never dialed, + // so it has nothing to say about that server's own health + // (below). Without this, a bare `sem <- struct{}{}` still + // unblocks once fanoutCtx dies (an earlier holder's own call + // fails fast against the already-expired context and frees + // its slot), but by then mcpBackendCall would be called with + // a context that is already done — indistinguishable from a + // server that WAS dialed and genuinely timed out, which is + // exactly the over-suppression this fix removes. + select { + case sem <- struct{}{}: + case <-fanoutCtx.Done(): + mu.Lock() + failed = append(failed, name) + mu.Unlock() + return + } defer func() { <-sem }() targetURL := g.cfg.MCPServers[name].URL // feat/target-health: passive recording (target_health.go) — // err != nil is a failure; a JSON-RPC-level resp.Error is NOT - // (the server answered, it just reported its own error), so - // it is recorded separately, below, once the shape is known. + // (the server answered, it just reported its own error). The + // record call right below already covers both: it reads ok + // from err == nil alone, so a non-nil resp.Error alongside a + // nil err still records success here — the failed-list + // append further down (used only for the merged tools/list + // result and the loud-failure short-circuit) is a separate + // concern and never touches targetHealth itself. probeStart := time.Now() resp, err := g.mcpBackendCall(fanoutCtx, targetURL, "tools/list", struct{}{}, mcpBackendResponseMaxBytes) - // F2: fanoutCtx is derived from r.Context() (above), so a - // client hang-up (context.Canceled) surfaces here as EVERY - // still-in-flight server's own error, and the shared - // toolsListBackendTimeout expiry (context.DeadlineExceeded) - // surfaces identically for a server that was genuinely slow - // AND one still parked on sem, never dialed at all — neither - // says anything about that server's own health, so neither is - // recorded, mirroring recordTargetProxyHealth's identical - // client-cancel rule (target_health.go). A server that is - // really hung is instead caught by the active probe sweep or - // its own per-request proxy health, not by this fan-out. - if err == nil || (!errors.Is(err, context.Canceled) && !errors.Is(err, context.DeadlineExceeded)) { + // G4: this goroutine WON the select above, so it was actually + // dialed — only a client hang-up (context.Canceled, + // propagating from r.Context() into fanoutCtx) says nothing + // about this server's own health, mirroring + // recordTargetProxyHealth's identical client-cancel rule + // (target_health.go). context.DeadlineExceeded here means the + // shared toolsListBackendTimeout fired while THIS dialed + // server was still in flight — it did not answer within the + // fan-out's own budget, which is a real failure worth + // recording, not a client artifact (F2 over-suppressed this + // case; a genuinely hung server used to read "unknown" + // forever under federation-only traffic). + if err == nil || !errors.Is(err, context.Canceled) { g.targetHealth.record(targetKindMCP, name, targetURL, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) } @@ -1116,11 +1141,15 @@ func (g *Gateway) mcpFederatedToolsCall(w http.ResponseWriter, format mcpRespons // not. probeStart := time.Now() resp, err := g.mcpBackendCall(ctx, targetURL, "tools/call", mcpToolCallParams{Name: toolName, Arguments: params.Arguments}, mcpBackendCallResponseMaxBytes) - // F2: same context-caused-error guard as mcpFederatedToolsList's own - // fan-out, above — ctx here derives from r.Context() too, so a client - // cancel or the shared toolsCallBackendTimeout expiry must record - // nothing rather than a false failure. - if err == nil || (!errors.Is(err, context.Canceled) && !errors.Is(err, context.DeadlineExceeded)) { + // G4: same dialed-server rule as mcpFederatedToolsList's own fan-out, + // above — ctx here derives from r.Context() too, so a client cancel + // (context.Canceled) must record nothing. Unlike the fan-out, + // tools/call has no semaphore to wait behind: the call above is + // always actually dialed, so context.DeadlineExceeded here means + // THIS server did not answer within toolsCallBackendTimeout — a real + // failure worth recording, not a client artifact (F2 over-suppressed + // this case). + if err == nil || !errors.Is(err, context.Canceled) { g.targetHealth.record(targetKindMCP, serverName, targetURL, err == nil, err, time.Since(probeStart), targetHealthSourceTraffic) } g.limiter.countTargetRequest(targetKindMCP, serverName) diff --git a/mcp_federation_test.go b/mcp_federation_test.go index a386eb6..9fc1f41 100644 --- a/mcp_federation_test.go +++ b/mcp_federation_test.go @@ -858,10 +858,12 @@ func TestHandleMCPFederated_ToolsCall_SlowBackend_BoundedByRequestContext(t *tes t.Cleanup(func() { close(block) }) cfg := newFederationTestConfig(srv.URL, "http://beta.invalid", true) + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") if err != nil { t.Fatalf("New: %v", err) } + gw := h.(*Gateway) callParams, _ := json.Marshal(mcpToolCallParams{Name: "alpha_lookup"}) req := newFederatedRequest(t, "sk-alice", jsonrpcRequest{JSONRPC: jsonrpcVersion, Method: "tools/call", ID: json.RawMessage("1"), Params: callParams}) @@ -884,6 +886,12 @@ func TestHandleMCPFederated_ToolsCall_SlowBackend_BoundedByRequestContext(t *tes if got.Error == nil || got.Error.Code != jsonrpcInternalError { t.Errorf("error = %+v, want internal error (the resolved server timed out)", got.Error) } + // G4, feat/target-health review round 2: tools/call always actually + // dials its one resolved server (no semaphore to wait behind), so + // this shared-budget expiry must record a failure, not nothing. + if state := gw.targetHealth.stateOf(targetKindMCP, "alpha"); state != targetHealthUnhealthy { + t.Errorf("alpha state = %q, want unhealthy (dialed and never answered within the request's own budget)", state) + } } // --- MF2: non-2xx status and empty-envelope guards --- @@ -2057,28 +2065,72 @@ func TestHandleMCPFederated_ToolsList_ClientCanceled_RecordsNothing(t *testing.T } } -// TestHandleMCPFederated_ToolsList_SharedDeadlineExpiry_RecordsNothing -// proves F2's second case: when the fan-out's own shared context expires -// (toolsListBackendTimeout, or here the incoming request's own shorter -// deadline — see TestHandleMCPFederated_ToolsList_SlowBackend_BoundedByRequestContext's -// own doc comment for why that stands in for the real 20s budget), a -// server still parked behind the fan-out semaphore — never actually -// dialed — must not be recorded as a failure either. mcpBackendCall -// returns the identical context.DeadlineExceeded whether a server was -// slow or never contacted at all, so this case is handled by the same -// guard as the client-cancel case above, not by tracking who was dialed. -func TestHandleMCPFederated_ToolsList_SharedDeadlineExpiry_RecordsNothing(t *testing.T) { +// TestHandleMCPFederated_ToolsList_HungDialedServer_RecordsFailure proves +// G4 (feat/target-health review round 2): a server that WAS actually +// dialed and never answers before the fan-out's own shared budget +// expires (toolsListBackendTimeout, or here the incoming request's own +// shorter deadline — see +// TestHandleMCPFederated_ToolsList_SlowBackend_BoundedByRequestContext's +// own doc comment for why that stands in for the real 20s budget) must +// still record a failure, not nothing. F2's original guard +// blanket-suppressed context.DeadlineExceeded too, which meant a +// genuinely hung server read "unknown" forever under federation-only +// traffic whenever targetHealth.enabled defaults false — the +// over-suppression this fix removes. +func TestHandleMCPFederated_ToolsList_HungDialedServer_RecordsFailure(t *testing.T) { + release := make(chan struct{}) + srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + <-release + })) + t.Cleanup(srv.Close) + t.Cleanup(func() { close(release) }) + + cfg := newFederationTestConfig(srv.URL, "http://beta.invalid", true) + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} + h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") + if err != nil { + t.Fatalf("New: %v", err) + } + gw := h.(*Gateway) + + req := newFederatedRequest(t, "sk-alice", jsonrpcRequest{JSONRPC: jsonrpcVersion, Method: "tools/list", ID: json.RawMessage("1")}) + shortCtx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond) + defer cancel() + req = req.WithContext(shortCtx) + + rec := httptest.NewRecorder() + h.ServeHTTP(rec, req) + + if got := gw.targetHealth.stateOf(targetKindMCP, "alpha"); got != targetHealthUnhealthy { + t.Errorf("alpha state = %q, want unhealthy (dialed and never answered within the fan-out budget)", got) + } +} + +// TestHandleMCPFederated_ToolsList_NeverDialedSemaphoreStarved_RecordsNothing +// proves G4's other half: a server still parked behind the fan-out +// semaphore when the shared deadline fires — never actually dialed — +// must still record nothing, unlike a server that WAS dialed (the test +// above). One more server than the fan-out semaphore has slots for +// (mcpFederatedFanoutConcurrency) guarantees at least one is never +// dialed; draining exactly mcpFederatedFanoutConcurrency sends on +// reached first proves which servers WERE actually dialed before any +// assertion runs, rather than assuming which specific names win the +// race. snapshot's own "observed" field (target_health.go), not stateOf, +// is what actually distinguishes "recorded a failure, still below +// failureThreshold" from "never recorded at all" — both read state +// targetHealthUnknown (F4), so FailureThreshold: 1 below also makes a +// dialed server's single failure visible as targetHealthUnhealthy +// through stateOf too, for a belt-and-suspenders check. +func TestHandleMCPFederated_ToolsList_NeverDialedSemaphoreStarved_RecordsNothing(t *testing.T) { + reached := make(chan struct{}, mcpFederatedFanoutConcurrency) block := make(chan struct{}) srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + reached <- struct{}{} <-block })) t.Cleanup(srv.Close) t.Cleanup(func() { close(block) }) - // One more server than the fan-out semaphore has slots for - // (mcpFederatedFanoutConcurrency) guarantees at least one is still - // parked on the semaphore, never dialed, when the shared deadline - // fires. names := make([]string, 0, mcpFederatedFanoutConcurrency+1) mcpServers := make(map[string]*TargetConfig, mcpFederatedFanoutConcurrency+1) for i := 0; i < mcpFederatedFanoutConcurrency+1; i++ { @@ -2092,6 +2144,7 @@ func TestHandleMCPFederated_ToolsList_SharedDeadlineExpiry_RecordsNothing(t *tes cfg.MCPServers = mcpServers cfg.Groups = map[string]*GroupConfig{"default": {}} cfg.Users = &UsersConfig{Inline: []*UserConfig{{Name: "alice", Group: "default", APIKey: "sk-alice"}}} + cfg.TargetHealth = TargetHealthConfig{FailureThreshold: 1} h, err := New(context.Background(), http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}), cfg, "llmgw") if err != nil { @@ -2100,17 +2153,39 @@ func TestHandleMCPFederated_ToolsList_SharedDeadlineExpiry_RecordsNothing(t *tes gw := h.(*Gateway) req := newFederatedRequest(t, "sk-alice", jsonrpcRequest{JSONRPC: jsonrpcVersion, Method: "tools/list", ID: json.RawMessage("1")}) - shortCtx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond) + shortCtx, cancel := context.WithTimeout(context.Background(), 150*time.Millisecond) defer cancel() req = req.WithContext(shortCtx) rec := httptest.NewRecorder() - h.ServeHTTP(rec, req) + done := make(chan struct{}) + go func() { + h.ServeHTTP(rec, req) + close(done) + }() + for i := 0; i < mcpFederatedFanoutConcurrency; i++ { + <-reached + } + <-done + + dialed, neverDialed := 0, 0 for _, name := range names { - if got := gw.targetHealth.stateOf(targetKindMCP, name); got != targetHealthUnknown { - t.Errorf("mcp/%s state = %q, want unknown (a shared fan-out deadline expiry must record nothing)", name, got) + snap := gw.targetHealth.snapshot(targetKindMCP, name) + if snap.observed { + dialed++ + if snap.state != targetHealthUnhealthy { + t.Errorf("mcp/%s state = %q, want unhealthy (dialed and never answered)", name, snap.state) + } + continue } + neverDialed++ + } + if dialed != mcpFederatedFanoutConcurrency { + t.Errorf("dialed = %d, want %d (exactly one server must never have been dialed)", dialed, mcpFederatedFanoutConcurrency) + } + if neverDialed != 1 { + t.Errorf("neverDialed = %d, want exactly 1", neverDialed) } } From e85acbf6f99059669163102a28131345a71c39ee Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 08:57:00 +0100 Subject: [PATCH 13/15] docs(target-health): correct the field-alignment note The note claimed fieldalignment reports no change from pinning the sweep timestamp first. The analyser is in fact clean before the move and reports 192 against an optimal 184 leading pointer bytes after it. State the measured truth. The struct stays 264 bytes either way, so the exception costs no padding. Moving the sweep flag up to close the pointer-bytes gap was tried and made the report worse. Atomic alignment on 32-bit platforms outranks the linter hint. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- llmgateway.go | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/llmgateway.go b/llmgateway.go index eceff6f..939c566 100644 --- a/llmgateway.go +++ b/llmgateway.go @@ -600,10 +600,18 @@ type Gateway struct { // Every field below is ordered by golangci-lint's fieldalignment // linter (pointer-containing fields grouped first, for GC scan // efficiency, then the rest) — this one field is the sole, deliberate - // exception, verified with `fieldalignment ./...` to add no - // additional padding: an 8-byte int64 transitions cleanly into the - // 8-byte-aligned pointer block that follows on every architecture - // this plugin targets. + // exception. Total struct size stays 264 bytes either way + // (unsafe.Sizeof(Gateway{}), verified before and after this field was + // pinned first), so the exception costs no padding. It does cost + // fieldalignment's separate pointer-bytes hint: `fieldalignment + // ./...` reports "Gateway has 192 leading bytes of pointer data but + // optimal value is 184" with this field first, against a clean + // report at the commit before it moved. Moving targetHealthSweeping + // (below) to sit directly after this field, to try to close that + // gap, was tried and makes the report worse, not better (200 vs + // 184), so targetHealthSweeping stays with the rest of the plain + // scalars. The 8-byte pointer-bytes gap is accepted deliberately: + // the atomic-alignment requirement below wins over the linter hint. targetHealthLastSweepUnixNano int64 next http.Handler // redisClient is the same instance newGateway hands to both the From 44ae4083b4912249b2c87bcae4b90ec20fd267bc Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 08:57:12 +0100 Subject: [PATCH 14/15] test(yaegi-check): wait for every probe before asserting The warmup waited for one target while the same sweep probed the others concurrently. A late probe could overwrite another target's traffic sourced record and fail a later assertion. Wait for every configured MCP target to report the probe source, and correct the comment that claimed a guarantee the code did not give. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- tools/yaegi-check/main.go | 66 +++++++++++++++++++++++++-------------- 1 file changed, 43 insertions(+), 23 deletions(-) diff --git a/tools/yaegi-check/main.go b/tools/yaegi-check/main.go index 3607517..50bb09b 100644 --- a/tools/yaegi-check/main.go +++ b/tools/yaegi-check/main.go @@ -1896,31 +1896,51 @@ func readTargetHealth(handler http.Handler, name string) (targetHealthProbeView, // used to make TARGETHEALTH-2, below, racy under Yaegi's interpreter // overhead). // -// targetHealthProbeOnlyServerName is dedicated to this assertion -// specifically because it is NEVER proxied or federated through by any -// other exercise in this harness — its health entry can only ever be -// written by the probe, so source == "probe" here is not just likely, -// it is the only value possible. Polling (pollTargetHealth) rather than -// asserting on a single read: the sweep itself still runs on its own -// spawned goroutine even though this call triggered it. +// G5, feat/target-health review round 2: that guarantee only holds once +// EVERY configured MCP server's own probe observation has actually +// landed, not merely targetHealthProbeOnlyServerName's. sweepTargetHealth +// probes every configured server CONCURRENTLY, on its own goroutines — +// waiting for one target's record() to land says nothing about whether +// mcpProbeServerName's own probe goroutine has finished yet. A version of +// this function that returned as soon as targetHealthProbeOnlyServerName +// alone changed could return while mcpProbeServerName's probe write was +// still in flight; that write could then land AFTER +// exerciseFederatedTooLarge's later traffic write, silently reverting +// mcpProbeServerName's source back to "probe" and corrupting +// exerciseTargetHealth's own TARGETHEALTH-2 assertion (source == +// "traffic"). Polling every configured MCP server for its own source == +// "probe" closes that gap: this function cannot return until the whole +// sweep — not just the one target it happens to check last — has +// finished writing. +// +// targetHealthProbeOnlyServerName is additionally asserted to the FULL +// "healthy" state, not just source == "probe": it is NEVER proxied or +// federated through by any other exercise in this harness, so its health +// entry can only ever be written by the probe — recover's own swallow +// (sweepTargetHealth's defer, target_health.go) means an interpreted +// panic mid-probe would otherwise degrade to a silently-stuck "unknown" +// rather than a loud failure, and asserting the full success shape here +// is what makes a Yaegi incompatibility in the initialize/close handshake +// path visible instead of passing silently. func exerciseTargetHealthProbeWarmup(handler http.Handler) error { - health, err := pollTargetHealth(handler, targetHealthProbeOnlyServerName, func(h targetHealthProbeView) bool { - return h.State != "unknown" - }) - if err != nil { - return err + warmupServerNames := []string{mcpProbeServerName, targetHealthDownServerName, targetHealthProbeOnlyServerName} + var probeOnlyHealth targetHealthProbeView + for _, name := range warmupServerNames { + health, err := pollTargetHealth(handler, name, func(h targetHealthProbeView) bool { + return h.Source == "probe" + }) + if err != nil { + return err + } + if health.Source != "probe" { + return fmt.Errorf("TARGETHEALTH-PROBE-1: GET /admin/api/targets: %q health.source = %q, want %q (the warmup sweep must probe every configured MCP server before any later exercise runs)", name, health.Source, "probe") + } + if name == targetHealthProbeOnlyServerName { + probeOnlyHealth = health + } } - if health.Source != "probe" { - return fmt.Errorf("TARGETHEALTH-PROBE-1: GET /admin/api/targets: %q health.source = %q, want %q (only the active probe ever touches this target)", targetHealthProbeOnlyServerName, health.Source, "probe") - } - // Recover's own swallow (sweepTargetHealth's defer, target_health.go) - // means an interpreted panic mid-probe would otherwise degrade to a - // silently-stuck "unknown" rather than a loud failure — asserting the - // FULL success shape here (not merely "state != unknown") is what - // makes a Yaegi incompatibility in the initialize/close handshake - // path visible instead of passing silently. - if health.State != "healthy" { - return fmt.Errorf("TARGETHEALTH-PROBE-2: GET /admin/api/targets: %q health.state = %q, want healthy (targetHealthProbeOnlyUpstream always answers initialize successfully)", targetHealthProbeOnlyServerName, health.State) + if probeOnlyHealth.State != "healthy" { + return fmt.Errorf("TARGETHEALTH-PROBE-2: GET /admin/api/targets: %q health.state = %q, want healthy (targetHealthProbeOnlyUpstream always answers initialize successfully)", targetHealthProbeOnlyServerName, probeOnlyHealth.State) } fmt.Println("yaegi-check: target health active probe sweep ran and recorded correctly interpreted") From d8ba90c5d072e634c1b4e3b29b584410d6d404ef Mon Sep 17 00:00:00 2001 From: Lukasz Raczylo Date: Thu, 3 Sep 2026 08:57:25 +0100 Subject: [PATCH 15/15] fix(admin): share the zero-time constant The zero-time sentinel was module private, so the spec redeclared the literal once a third consumer started depending on it. Export it and import it in the spec. Regenerate the baked admin assets. Claude-Session: https://claude.ai/code/session_01EebV5jyWvYocByNQ3oss1w --- admin_assets_gen.go | 12 ++++++------ webui/src/lib/format.spec.ts | 4 +--- webui/src/lib/format.ts | 3 ++- 3 files changed, 9 insertions(+), 10 deletions(-) diff --git a/admin_assets_gen.go b/admin_assets_gen.go index cd15b6e..87f535c 100644 --- a/admin_assets_gen.go +++ b/admin_assets_gen.go @@ -1,6 +1,6 @@ // Code generated by webui/generate.mjs; DO NOT EDIT. // -// Source: webui/dist/ (vite build output), digest 25a21c1cf0995404. +// Source: webui/dist/ (vite build output), digest 0368099ac0e07195. // Regenerate via `make admin-ui` after any webui/ source change. // // Every asset body below is base64-encoded and decoded once at package-var @@ -34,16 +34,16 @@ func decodeAdminAsset(encoded string) []byte { // adminIndexHTML is GET /admin's response body (admin.go's serveAdminPage) — // the built Vue app's HTML shell. var adminIndexHTML = decodeAdminAsset( - "PCFkb2N0eXBlIGh0bWw+CjxodG1sIGxhbmc9ImVuIj4KICA8aGVhZD4KICAgIDxtZXRhIGNoYXJzZXQ9IlVURi04IiAvPgogICAgPCEtLSBJbmxpbmUgZGF0YTogVVJJLCBub3QgYSBmaWxlIHVuZGVyIHB1YmxpYy86IGFkbWluLmdvJ3MgYXNzZXQgbWFwIG9ubHkKICAgICAgICAgZXZlciBob2xkcyBjb250ZW50LWhhc2hlZCBmaWxlcyB1bmRlciAvYWRtaW4vYXNzZXRzLyosIGFuZCB0aGUgYWRtaW4KICAgICAgICAgQ1NQJ3MgaW1nLXNyYyBhbGxvd3MgJ3NlbGYnIHBsdXMgZGF0YTogZm9yIGV4YWN0bHkgdGhpcyByZWFzb24g4oCUIG5vCiAgICAgICAgIGV4dHJhIHVuaGFzaGVkLWFzc2V0IHJvdXRlIGlzIG5lZWRlZCBmb3Igb25lIHNtYWxsIGljb24uIC0tPgogICAgPGxpbmsKICAgICAgcmVsPSJpY29uIgogICAgICB0eXBlPSJpbWFnZS9zdmcreG1sIgogICAgICBocmVmPSJkYXRhOmltYWdlL3N2Zyt4bWwsJTNDc3ZnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zycgdmlld0JveD0nMCAwIDI0IDI0JyUzRSUzQ3JlY3Qgd2lkdGg9JzI0JyBoZWlnaHQ9JzI0JyByeD0nNScgZmlsbD0nJTIzMDA3MmIyJy8lM0UlM0NwYXRoIGQ9J002IDE2LjUgMTAgOGwzIDYgMi0zLjUgMyA2JyBzdHJva2U9JyUyM2ZmZicgc3Ryb2tlLXdpZHRoPScyJyBmaWxsPSdub25lJyBzdHJva2UtbGluZWNhcD0ncm91bmQnIHN0cm9rZS1saW5lam9pbj0ncm91bmQnLyUzRSUzQy9zdmclM0UiCiAgICAvPgogICAgPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwgaW5pdGlhbC1zY2FsZT0xLjAiIC8+CiAgICA8dGl0bGU+TExNIEdhdGV3YXkgLSBBZG1pbjwvdGl0bGU+CiAgICA8c2NyaXB0IHR5cGU9Im1vZHVsZSIgY3Jvc3NvcmlnaW4gc3JjPSIvYWRtaW4vYXNzZXRzL2luZGV4LUN3UF9NYk9iLmpzIj48L3NjcmlwdD4KICAgIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgY3Jvc3NvcmlnaW4gaHJlZj0iL2FkbWluL2Fzc2V0cy9pbmRleC1DU2tJSXRyby5jc3MiPgogIDwvaGVhZD4KICA8Ym9keT4KICAgIDxkaXYgaWQ9ImFwcCI+PC9kaXY+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==", + "PCFkb2N0eXBlIGh0bWw+CjxodG1sIGxhbmc9ImVuIj4KICA8aGVhZD4KICAgIDxtZXRhIGNoYXJzZXQ9IlVURi04IiAvPgogICAgPCEtLSBJbmxpbmUgZGF0YTogVVJJLCBub3QgYSBmaWxlIHVuZGVyIHB1YmxpYy86IGFkbWluLmdvJ3MgYXNzZXQgbWFwIG9ubHkKICAgICAgICAgZXZlciBob2xkcyBjb250ZW50LWhhc2hlZCBmaWxlcyB1bmRlciAvYWRtaW4vYXNzZXRzLyosIGFuZCB0aGUgYWRtaW4KICAgICAgICAgQ1NQJ3MgaW1nLXNyYyBhbGxvd3MgJ3NlbGYnIHBsdXMgZGF0YTogZm9yIGV4YWN0bHkgdGhpcyByZWFzb24g4oCUIG5vCiAgICAgICAgIGV4dHJhIHVuaGFzaGVkLWFzc2V0IHJvdXRlIGlzIG5lZWRlZCBmb3Igb25lIHNtYWxsIGljb24uIC0tPgogICAgPGxpbmsKICAgICAgcmVsPSJpY29uIgogICAgICB0eXBlPSJpbWFnZS9zdmcreG1sIgogICAgICBocmVmPSJkYXRhOmltYWdlL3N2Zyt4bWwsJTNDc3ZnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zycgdmlld0JveD0nMCAwIDI0IDI0JyUzRSUzQ3JlY3Qgd2lkdGg9JzI0JyBoZWlnaHQ9JzI0JyByeD0nNScgZmlsbD0nJTIzMDA3MmIyJy8lM0UlM0NwYXRoIGQ9J002IDE2LjUgMTAgOGwzIDYgMi0zLjUgMyA2JyBzdHJva2U9JyUyM2ZmZicgc3Ryb2tlLXdpZHRoPScyJyBmaWxsPSdub25lJyBzdHJva2UtbGluZWNhcD0ncm91bmQnIHN0cm9rZS1saW5lam9pbj0ncm91bmQnLyUzRSUzQy9zdmclM0UiCiAgICAvPgogICAgPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwgaW5pdGlhbC1zY2FsZT0xLjAiIC8+CiAgICA8dGl0bGU+TExNIEdhdGV3YXkgLSBBZG1pbjwvdGl0bGU+CiAgICA8c2NyaXB0IHR5cGU9Im1vZHVsZSIgY3Jvc3NvcmlnaW4gc3JjPSIvYWRtaW4vYXNzZXRzL2luZGV4LUNuNnZFQWpQLmpzIj48L3NjcmlwdD4KICAgIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgY3Jvc3NvcmlnaW4gaHJlZj0iL2FkbWluL2Fzc2V0cy9pbmRleC1DU2tJSXRyby5jc3MiPgogIDwvaGVhZD4KICA8Ym9keT4KICAgIDxkaXYgaWQ9ImFwcCI+PC9kaXY+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==", ) // adminAssets maps each hashed filename under /admin/assets/ (admin.go's // serveAdminAsset) to its content. var adminAssets = map[string]adminAsset{ - "ChartsView--5PgKbV9.js": { + "ChartsView-DQ1IeOcb.js": { contentType: "text/javascript; charset=utf-8", body: decodeAdminAsset( - "import{$ as e,A as t,At as n,B as r,Bt as i,C as a,Ct as o,D as s,Dt as c,E as l,Et as u,F as d,Ft as f,G as p,H as m,I as h,It as g,J as _,K as v,L as y,Lt as b,M as x,Mt as S,N as C,Nt as w,O as T,Ot as E,P as D,Pt as O,Q as k,R as ee,Rt as te,S as ne,St as re,T as ie,Tt as ae,U as oe,V as se,Vt as ce,W as le,X as ue,Y as de,Z as fe,_ as pe,_t as me,a as he,at as ge,b as A,c as _e,ct as ve,d as ye,dt as j,et as M,f as be,ft as xe,g as Se,gt as N,h as Ce,ht as we,i as Te,it as P,j as Ee,jt as F,k as De,kt as Oe,l as ke,lt as Ae,m as je,mt as Me,n as Ne,nt as I,o as Pe,ot as L,p as Fe,pt as Ie,q as Le,r as Re,rt as ze,s as Be,st as R,t as Ve,tt as He,u as Ue,ut as We,v as Ge,vt as z,w as Ke,wt as B,x as qe,xt as V,y as Je,yt as Ye,z as Xe,zt as Ze}from"./index-CwP_MbOb.js";function Qe(e,t=-1/0,n=1/0){return Math.min(n,Math.max(t,e))}function $e(e,t,n){let r=n.originalEvent.target,i=new CustomEvent(e,{bubbles:!1,cancelable:!0,detail:n});t&&r.addEventListener(e,t,{once:!0}),r.dispatchEvent(i)}var et=n({layersRoot:new Set,layersWithOutsidePointerEventsDisabled:new Set,originalBodyPointerEvents:void 0,branches:new Set});function tt(e){if(typeof e!=`object`||!e)return!1;let t=Object.getPrototypeOf(e);return t!==null&&t!==Object.prototype&&Object.getPrototypeOf(t)!==null||Symbol.iterator in e?!1:Symbol.toStringTag in e?Object.prototype.toString.call(e)===`[object Module]`:!0}function nt(e,t,n=`.`,r){if(!tt(t))return nt(e,{},n,r);let i={...t};for(let t of Object.keys(e)){if(t===`__proto__`||t===`constructor`)continue;let a=e[t];a!=null&&(r&&r(i,t,a,n)||(i[t]=Array.isArray(a)&&Array.isArray(i[t])?[...a,...i[t]]:tt(a)&&tt(i[t])?nt(a,i[t],(n?`${n}.`:``)+t.toString(),r):a))}return i}function rt(e){return(...t)=>t.reduce((t,n)=>nt(t,n,``,e),{})}var it=rt(),at=d(()=>{let e=F(new Map),n=F(),r=M(()=>{for(let t of e.value.values())if(t)return!0;return!1}),i=s({scrollBody:F(!0)}),a=null,o=()=>{document.body.style.paddingRight=``,document.body.style.marginRight=``,et.layersWithOutsidePointerEventsDisabled.size===0&&(document.body.style.pointerEvents=``),document.documentElement.style.removeProperty(`--scrollbar-width`),document.body.style.overflow=n.value??``,y&&a?.(),n.value=void 0};return V(r,(e,s)=>{if(!h)return;if(!e){s&&o();return}n.value===void 0&&(n.value=document.body.style.overflow);let c=window.innerWidth-document.documentElement.clientWidth,l={padding:c,margin:0},u=i.scrollBody?.value?typeof i.scrollBody.value==`object`?it({padding:i.scrollBody.value.padding===!0?c:i.scrollBody.value.padding,margin:i.scrollBody.value.margin===!0?c:i.scrollBody.value.margin},l):l:{padding:0,margin:0};c>0&&(document.body.style.paddingRight=typeof u.padding==`number`?`${u.padding}px`:String(u.padding),document.body.style.marginRight=typeof u.margin==`number`?`${u.margin}px`:String(u.margin),document.documentElement.style.setProperty(`--scrollbar-width`,`${c}px`),document.body.style.overflow=`hidden`),y&&(a=t(document,`touchmove`,e=>ct(e),{passive:!1})),xe(()=>{r.value&&(document.body.style.pointerEvents=`none`,document.body.style.overflow=`hidden`)})},{immediate:!0,flush:`sync`}),e});function ot(e){let t=Math.random().toString(36).substring(2,7),n=at();n.value.set(t,e??!1);let i=M({get:()=>n.value.get(t)??!1,set:e=>n.value.set(t,e)});return r(()=>{n.value.delete(t)}),i}function st(e){let t=window.getComputedStyle(e);if(t.overflowX===`scroll`||t.overflowY===`scroll`||t.overflowX===`auto`&&e.clientWidth<e.scrollWidth||t.overflowY===`auto`&&e.clientHeight<e.scrollHeight)return!0;{let t=e.parentNode;return!(t instanceof Element)||t.tagName===`BODY`?!1:st(t)}}function ct(e){let t=e||window.event,n=t.target;return n instanceof Element&&st(n)?!1:t.touches.length>1||(t.preventDefault&&t.cancelable&&t.preventDefault(),!1)}var lt=0;function ut(){re(e=>{if(!h)return;let t=document.querySelectorAll(`[data-reka-focus-guard]`);document.body.insertAdjacentElement(`afterbegin`,t[0]??dt()),document.body.insertAdjacentElement(`beforeend`,t[1]??dt()),lt++,e(()=>{lt===1&&document.querySelectorAll(`[data-reka-focus-guard]`).forEach(e=>e.remove()),lt--})})}function dt(){let e=document.createElement(`span`);return e.setAttribute(`data-reka-focus-guard`,``),e.tabIndex=0,e.style.outline=`none`,e.style.opacity=`0`,e.style.position=`fixed`,e.style.pointerEvents=`none`,e}function ft(e){return M(()=>!g(e)||!!De(e)?.closest(`form`))}var pt=function(e){return typeof document>`u`?null:(Array.isArray(e)?e[0]:e).ownerDocument.body},mt=new WeakMap,ht=new WeakMap,gt={},_t=0,vt=function(e){return e&&(e.host||vt(e.parentNode))},yt=function(e,t){return t.map(function(t){if(e.contains(t))return t;var n=vt(t);return n&&e.contains(n)?n:(console.error(`aria-hidden`,t,`in not contained inside`,e,`. Doing nothing`),null)}).filter(function(e){return!!e})},bt=function(e,t,n,r){var i=yt(t,Array.isArray(e)?e:[e]);gt[n]||(gt[n]=new WeakMap);var a=gt[n],o=[],s=new Set,c=new Set(i),l=function(e){!e||s.has(e)||(s.add(e),l(e.parentNode))};i.forEach(l);var u=function(e){!e||c.has(e)||Array.prototype.forEach.call(e.children,function(e){if(s.has(e))u(e);else try{var t=e.getAttribute(r),i=t!==null&&t!==`false`,c=(mt.get(e)||0)+1,l=(a.get(e)||0)+1;mt.set(e,c),a.set(e,l),o.push(e),c===1&&i&&ht.set(e,!0),l===1&&e.setAttribute(n,`true`),i||e.setAttribute(r,`true`)}catch(t){console.error(`aria-hidden: cannot operate on `,e,t)}})};return u(t),s.clear(),_t++,function(){o.forEach(function(e){var t=mt.get(e)-1,i=a.get(e)-1;mt.set(e,t),a.set(e,i),t||(ht.has(e)||e.removeAttribute(r),ht.delete(e)),i||e.removeAttribute(n)}),_t--,_t||(mt=new WeakMap,mt=new WeakMap,ht=new WeakMap,gt={})}},xt=function(e,t,n){n===void 0&&(n=`data-aria-hidden`);var r=Array.from(Array.isArray(e)?e:[e]),i=t||pt(e);return i?(r.push.apply(r,Array.from(i.querySelectorAll(`[aria-live], script`))),bt(r,i,n,`aria-hidden`)):function(){return null}};function St(e){let t;V(()=>De(e),e=>{let n=!1;try{n=!!e?.closest(`[popover]:not(:popover-open)`)}catch{}e&&!n?t=xt(e):t&&t()}),we(()=>{t&&t()})}function Ct(e){let t=F(),n=M(()=>t.value?.width??0),r=M(()=>t.value?.height??0),i;return Me(()=>{let n=De(e);n?(t.value={width:n.offsetWidth,height:n.offsetHeight},i=new ResizeObserver(e=>{if(!Array.isArray(e)||!e.length)return;let r=e[0],i,a;if(`borderBoxSize`in r){let e=r.borderBoxSize,t=Array.isArray(e)?e[0]:e;i=t.inlineSize,a=t.blockSize}else i=n.offsetWidth,a=n.offsetHeight;t.value={width:i,height:a}}),i.observe(n,{box:`border-box`})):t.value=void 0}),we(()=>{i?.disconnect(),i=void 0}),{width:n,height:r}}function wt(e){let t=Xe(``,1e3);return{search:t,handleTypeaheadSearch:(n,r)=>{if(t.value+=n,e)e(n);else{let e=m(),n=r.map(e=>({...e,textValue:e.value?.textValue??e.ref.textContent?.trim()??``})),i=n.find(t=>t.ref===e),a=Et(n.map(e=>e.textValue),t.value,i?.textValue),o=n.find(e=>e.textValue===a);return o&&o.ref.focus(),o?.ref}},resetTypeahead:()=>{t.value=``}}}function Tt(e,t){return e.map((n,r)=>e[(t+r)%e.length])}function Et(e,t,n){let r=t.length>1&&Array.from(t).every(e=>e===t[0])?t[0]:t,i=n?e.indexOf(n):-1,a=Tt(e,Math.max(i,0));r.length===1&&(a=a.filter(e=>e!==n));let o=a.find(e=>e.toLowerCase().startsWith(r.toLowerCase()));return o===n?void 0:o}var Dt=`dismissableLayer.pointerDownOutside`,Ot=`dismissableLayer.focusOutside`;function kt(e,t){if(!(t instanceof Element))return!1;let n=t.closest(`[data-dismissable-layer]`),r=e.dataset.dismissableLayer===``?e:e.querySelector(`[data-dismissable-layer]`),i=Array.from(e.ownerDocument.querySelectorAll(`[data-dismissable-layer]`));return!!(n&&(r===n||i.indexOf(r)<i.indexOf(n)))}function At(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=F(!1),a=F(()=>{});return re(o=>{if(!h||!g(n))return;let s=async n=>{let o=n.target;if(!(!t?.value||!o)){if(kt(t.value,o)){i.value=!1;return}if(n.target&&!i.value){let t={originalEvent:n};function i(){$e(Dt,e,t)}n.pointerType===`touch`?(r.removeEventListener(`click`,a.value),a.value=i,r.addEventListener(`click`,a.value,{once:!0})):i()}else r.removeEventListener(`click`,a.value);i.value=!1}},c=window.setTimeout(()=>{r.addEventListener(`pointerdown`,s)},0);o(()=>{window.clearTimeout(c),r.removeEventListener(`pointerdown`,s),r.removeEventListener(`click`,a.value)})}),{onPointerDownCapture:()=>{g(n)&&(i.value=!0)}}}function jt(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=F(!1);return re(a=>{if(!h||!g(n))return;let o=async n=>{if(!t?.value)return;await xe(),await xe();let r=n.target;!t.value||!r||kt(t.value,r)||n.target&&!i.value&&$e(Ot,e,{originalEvent:n})};r.addEventListener(`focusin`,o),a(()=>r.removeEventListener(`focusin`,o))}),{onFocusCapture:()=>{g(n)&&(i.value=!0)},onBlurCapture:()=>{g(n)&&(i.value=!1)}}}var Mt=R({__name:`DismissableLayer`,props:{disableOutsidePointerEvents:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},present:{type:Boolean,required:!1,default:!0}},emits:[`escapeKeyDown`,`pointerDownOutside`,`focusOutside`,`interactOutside`,`dismiss`],setup(e,{emit:t}){let n=e,r=t,{forwardRef:a,currentElement:o}=ie(),s=M(()=>o.value?.ownerDocument??globalThis.document),c=M(()=>et.layersRoot),l=M(()=>o.value?Array.from(c.value).indexOf(o.value):-1),u=M(()=>et.layersWithOutsidePointerEventsDisabled.size>0),d=M(()=>{let e=Array.from(c.value),[t]=[...et.layersWithOutsidePointerEventsDisabled].slice(-1),n=e.indexOf(t);return l.value>=n}),f=At(async e=>{let t=[...et.branches].some(t=>t?.contains(e.target));!n.present||!d.value||t||(r(`pointerDownOutside`,e),r(`interactOutside`,e),await xe(),e.defaultPrevented||r(`dismiss`))},o),p=jt(e=>{let t=[...et.branches].some(t=>t?.contains(e.target));!n.present||t||(r(`focusOutside`,e),r(`interactOutside`,e),e.defaultPrevented||r(`dismiss`))},o);return T(`Escape`,e=>{n.present&&l.value===c.value.size-1&&(r(`escapeKeyDown`,e),e.defaultPrevented||r(`dismiss`))}),V([o,()=>n.disableOutsidePointerEvents,()=>n.present],([e,t,n],r,i)=>{!e||!n||t&&(et.layersWithOutsidePointerEventsDisabled.size===0&&(et.originalBodyPointerEvents=s.value.body.style.pointerEvents,s.value.body.style.pointerEvents=`none`),et.layersWithOutsidePointerEventsDisabled.add(e),i(()=>{et.layersWithOutsidePointerEventsDisabled.delete(e),et.layersWithOutsidePointerEventsDisabled.size===0&&!se(et.originalBodyPointerEvents)&&(s.value.body.style.pointerEvents=et.originalBodyPointerEvents)}))},{immediate:!0}),V([o,()=>n.present],([e,t],n,r)=>{!e||!t||(c.value.add(e),r(()=>{c.value.delete(e)}))},{immediate:!0}),re(e=>{e(()=>{o.value&&(c.value.delete(o.value),et.layersWithOutsidePointerEventsDisabled.delete(o.value))})}),(e,t)=>(N(),I(b(A),{ref:b(a),"as-child":e.asChild,as:e.as,"data-dismissable-layer":``,style:i({pointerEvents:u.value?d.value?`auto`:`none`:void 0}),onFocusCapture:b(p).onFocusCapture,onBlurCapture:b(p).onBlurCapture,onPointerdownCapture:b(f).onPointerDownCapture},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`style`,`onFocusCapture`,`onBlurCapture`,`onPointerdownCapture`]))}}),Nt=D(()=>F([]));function Pt(){let e=Nt();return{add(t){let n=e.value[0];t!==n&&n?.pause(),e.value=Ft(e.value,t),e.value.unshift(t)},remove(t){e.value=Ft(e.value,t),e.value[0]?.resume()}}}function Ft(e,t){let n=[...e],r=n.indexOf(t);return r!==-1&&n.splice(r,1),n}var It=`focusScope.autoFocusOnMount`,Lt=`focusScope.autoFocusOnUnmount`,Rt={bubbles:!1,cancelable:!0};function zt(e,{select:t=!1}={}){let n=m();for(let r of e)if(Gt(r,{select:t}),m()!==n)return!0}function Bt(e){let t=Vt(e);return[Ht(t,e),Ht(t.reverse(),e)]}function Vt(e){let t=[],n=document.createTreeWalker(e,NodeFilter.SHOW_ELEMENT,{acceptNode:e=>{let t=e.tagName===`INPUT`&&e.type===`hidden`;return e.disabled||e.hidden||t?NodeFilter.FILTER_SKIP:e.tabIndex>=0?NodeFilter.FILTER_ACCEPT:NodeFilter.FILTER_SKIP}});for(;n.nextNode();)t.push(n.currentNode);return t}function Ht(e,t){for(let n of e)if(!Ut(n,{upTo:t}))return n}function Ut(e,{upTo:t}){if(getComputedStyle(e).visibility===`hidden`)return!0;for(;e;){if(t!==void 0&&e===t)return!1;if(getComputedStyle(e).display===`none`)return!0;e=e.parentElement}return!1}function Wt(e){return e instanceof HTMLInputElement&&`select`in e}function Gt(e,{select:t=!1}={}){if(e&&e.focus){let n=m();e.focus({preventScroll:!0}),e!==n&&Wt(e)&&t&&e.select()}}var Kt=R({__name:`FocusScope`,props:{loop:{type:Boolean,required:!1,default:!1},trapped:{type:Boolean,required:!1,default:!1},present:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`mountAutoFocus`,`unmountAutoFocus`],setup(e,{emit:t}){let r=e,i=t,{currentRef:a,currentElement:o}=ie(),s=F(null),c=Pt(),l=n({paused:!1,pause(){this.paused=!0},resume(){this.paused=!1}});re(e=>{if(!h)return;let t=o.value;if(!r.trapped)return;function n(e){if(l.paused||!t)return;let n=e.target;t.contains(n)?s.value=n:Gt(s.value,{select:!0})}function i(e){if(l.paused||!t)return;let n=e.relatedTarget;n!==null&&(t.contains(n)||Gt(s.value,{select:!0}))}function a(e){let n=s.value;n!==null&&e.some(e=>e.removedNodes.length>0)&&(t.contains(n)||Gt(t))}document.addEventListener(`focusin`,n),document.addEventListener(`focusout`,i);let c=new MutationObserver(a);t&&c.observe(t,{childList:!0,subtree:!0}),e(()=>{document.removeEventListener(`focusin`,n),document.removeEventListener(`focusout`,i),c.disconnect()})});function u(e,t){let n=new CustomEvent(It,Rt),r=e=>i(`mountAutoFocus`,e);e.addEventListener(It,r),e.dispatchEvent(n),e.removeEventListener(It,r),n.defaultPrevented||(zt(Vt(e),{select:!0}),m()===t&&Gt(e))}re(async e=>{let t=o.value;if(await xe(),!t)return;r.present!==!1&&c.add(l);let n=m();!t.contains(n)&&r.present!==!1&&u(t,n),e(()=>{let e=new CustomEvent(Lt,Rt),r=e=>{i(`unmountAutoFocus`,e)};t.addEventListener(Lt,r),t.dispatchEvent(e),t.setAttribute(`data-focus-scope-unmounting`,``),setTimeout(()=>{e.defaultPrevented||Gt(n??document.body,{select:!0}),t.removeEventListener(Lt,r),c.remove(l),t.removeAttribute(`data-focus-scope-unmounting`)},0)})}),V(()=>r.present,async(e,t)=>{if(!h)return;if(e===!1&&t===!0){c.remove(l);return}if(e!==!0||t!==!1)return;c.add(l),await xe();let n=o.value;if(!n)return;let r=m();n.contains(r)||u(n,r)});function d(e){if(!r.loop&&!r.trapped||l.paused)return;let t=e.key===`Tab`&&!e.altKey&&!e.ctrlKey&&!e.metaKey,n=m();if(t&&n){let t=e.currentTarget,[i,a]=Bt(t);i&&a?!e.shiftKey&&n===a?(e.preventDefault(),r.loop&&Gt(i,{select:!0})):e.shiftKey&&n===i&&(e.preventDefault(),r.loop&&Gt(a,{select:!0})):n===t&&e.preventDefault()}}return(e,t)=>(N(),I(b(A),{ref_key:`currentRef`,ref:a,tabindex:`-1`,"as-child":e.asChild,as:e.as,onKeydown:d},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as-child`,`as`]))}}),qt=[`Enter`,` `],Jt=[`ArrowDown`,`PageUp`,`Home`],Yt=[`ArrowUp`,`PageDown`,`End`];[...Jt,...Yt],[...qt],[...qt];function Xt(e){let t=m();for(let n of e)if(n===t||(n.focus(),m()!==t))return}var Zt=R({__name:`Teleport`,props:{to:{type:null,required:!1},disabled:{type:Boolean,required:!1},defer:{type:Boolean,required:!1},forceMount:{type:Boolean,required:!1}},setup(t){let n=t,r=s({}),i=M(()=>n.to??r.teleportTo?.value??`body`),a=Ee();return(t,n)=>b(a)||t.forceMount?(N(),I(e,{key:0,to:i.value,disabled:t.disabled,defer:t.defer},[z(t.$slots,`default`)],8,[`to`,`disabled`,`defer`])):ze(`v-if`,!0)}}),Qt=R({__name:`VisuallyHidden`,props:{feature:{type:String,required:!1,default:`focusable`},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(N(),I(b(A),{as:e.as,"as-child":e.asChild,"aria-hidden":e.feature===`focusable`||e.feature===`fully-hidden`?`true`:void 0,"data-hidden":e.feature===`fully-hidden`?``:void 0,tabindex:e.feature===`fully-hidden`?`-1`:void 0,style:{position:`absolute`,border:0,width:`1px`,height:`1px`,padding:0,margin:`-1px`,overflow:`hidden`,clip:`rect(0, 0, 0, 0)`,clipPath:`inset(50%)`,whiteSpace:`nowrap`,wordWrap:`normal`,top:`-1px`,left:`-1px`}},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`aria-hidden`,`data-hidden`,`tabindex`]))}}),[$t,en]=oe(`PopperRoot`),tn=R({inheritAttrs:!1,__name:`PopperRoot`,setup(e){let t=F();return en({anchor:t,onAnchorChange:e=>t.value=e}),(e,t)=>z(e.$slots,`default`)}}),nn=R({__name:`PopperAnchor`,props:{reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{forwardRef:n,currentElement:r}=ie(),i=$t();return o(()=>{i.onAnchorChange(t.reference??r.value)}),(e,t)=>(N(),I(b(A),{ref:b(n),as:e.as,"as-child":e.asChild},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as`,`as-child`]))}});function rn(e){return e!==null}function an(e){return{name:`transformOrigin`,options:e,fn(t){let{placement:n,rects:r,middlewareData:i}=t,a=i.arrow?.centerOffset!==0,o=a?0:e.arrowWidth,s=a?0:e.arrowHeight,[c,l]=on(n),u={start:e.dir===`rtl`?`100%`:`0%`,center:`50%`,end:e.dir===`rtl`?`0%`:`100%`}[l],d={start:`0%`,center:`50%`,end:`100%`}[l],f=(i.arrow?.x??0)+o/2,p=(i.arrow?.y??0)+s/2,m=``,h=``;return c===`bottom`?(m=a?u:`${f}px`,h=`${-s}px`):c===`top`?(m=a?u:`${f}px`,h=`${r.floating.height+s}px`):c===`right`?(m=`${-s}px`,h=a?d:`${p}px`):c===`left`&&(m=`${r.floating.width+s}px`,h=a?d:`${p}px`),{data:{x:m,y:h}}}}}function on(e){let[t,n=`center`]=e.split(`-`);return[t,n]}var sn=[`top`,`right`,`bottom`,`left`],cn=Math.min,ln=Math.max,un=Math.round,dn=Math.floor,fn=e=>({x:e,y:e}),pn={left:`right`,right:`left`,bottom:`top`,top:`bottom`};function mn(e,t,n){return ln(e,cn(t,n))}function hn(e,t){return typeof e==`function`?e(t):e}function gn(e){return e.split(`-`)[0]}function _n(e){return e.split(`-`)[1]}function vn(e){return e===`x`?`y`:`x`}function yn(e){return e===`y`?`height`:`width`}function bn(e){let t=e[0];return t===`t`||t===`b`?`y`:`x`}function xn(e){return vn(bn(e))}function Sn(e,t,n){n===void 0&&(n=!1);let r=_n(e),i=xn(e),a=yn(i),o=i===`x`?r===(n?`end`:`start`)?`right`:`left`:r===`start`?`bottom`:`top`;return t.reference[a]>t.floating[a]&&(o=jn(o)),[o,jn(o)]}function Cn(e){let t=jn(e);return[wn(e),t,wn(t)]}function wn(e){return e.includes(`start`)?e.replace(`start`,`end`):e.replace(`end`,`start`)}var Tn=[`left`,`right`],En=[`right`,`left`],Dn=[`top`,`bottom`],On=[`bottom`,`top`];function kn(e,t,n){switch(e){case`top`:case`bottom`:return n?t?En:Tn:t?Tn:En;case`left`:case`right`:return t?Dn:On;default:return[]}}function An(e,t,n,r){let i=_n(e),a=kn(gn(e),n===`start`,r);return i&&(a=a.map(e=>e+`-`+i),t&&(a=a.concat(a.map(wn)))),a}function jn(e){let t=gn(e);return pn[t]+e.slice(t.length)}function Mn(e){return{top:e.top??0,right:e.right??0,bottom:e.bottom??0,left:e.left??0}}function Nn(e){return typeof e==`number`?{top:e,right:e,bottom:e,left:e}:Mn(e)}function Pn(e){let{x:t,y:n,width:r,height:i}=e;return{width:r,height:i,top:n,left:t,right:t+r,bottom:n+i,x:t,y:n}}function Fn(e,t,n){let{reference:r,floating:i}=e,a=bn(t),o=xn(t),s=yn(o),c=gn(t),l=a===`y`,u=r.x+r.width/2-i.width/2,d=r.y+r.height/2-i.height/2,f=r[s]/2-i[s]/2,p;switch(c){case`top`:p={x:u,y:r.y-i.height};break;case`bottom`:p={x:u,y:r.y+r.height};break;case`right`:p={x:r.x+r.width,y:d};break;case`left`:p={x:r.x-i.width,y:d};break;default:p={x:r.x,y:r.y}}let m=_n(t);return m&&(p[o]+=f*(m===`end`?1:-1)*(n&&l?-1:1)),p}async function In(e,t){t===void 0&&(t={});let{x:n,y:r,platform:i,rects:a,elements:o,strategy:s}=e,{boundary:c=`clippingAncestors`,rootBoundary:l=`viewport`,elementContext:u=`floating`,altBoundary:d=!1,padding:f=0}=hn(t,e),p=Nn(f),m=o[d?u===`floating`?`reference`:`floating`:u],h=Pn(await i.getClippingRect({element:await(i.isElement==null?void 0:i.isElement(m))??!0?m:m.contextElement||await(i.getDocumentElement==null?void 0:i.getDocumentElement(o.floating)),boundary:c,rootBoundary:l,strategy:s})),g=u===`floating`?{x:n,y:r,width:a.floating.width,height:a.floating.height}:a.reference,_=await(i.getOffsetParent==null?void 0:i.getOffsetParent(o.floating)),v=await(i.isElement==null?void 0:i.isElement(_))&&await(i.getScale==null?void 0:i.getScale(_))||{x:1,y:1},y=Pn(i.convertOffsetParentRelativeRectToViewportRelativeRect?await i.convertOffsetParentRelativeRectToViewportRelativeRect({elements:o,rect:g,offsetParent:_,strategy:s}):g);return{top:(h.top-y.top+p.top)/v.y,bottom:(y.bottom-h.bottom+p.bottom)/v.y,left:(h.left-y.left+p.left)/v.x,right:(y.right-h.right+p.right)/v.x}}var Ln=50,Rn=async(e,t,n)=>{let{placement:r=`bottom`,strategy:i=`absolute`,middleware:a=[],platform:o}=n,s=o.detectOverflow?o:{...o,detectOverflow:In},c=await(o.isRTL==null?void 0:o.isRTL(t)),l=await o.getElementRects({reference:e,floating:t,strategy:i}),{x:u,y:d}=Fn(l,r,c),f=r,p=0,m={};for(let n=0;n<a.length;n++){let h=a[n];if(!h)continue;let{name:g,fn:_}=h,{x:v,y,data:b,reset:x}=await _({x:u,y:d,initialPlacement:r,placement:f,strategy:i,middlewareData:m,rects:l,platform:s,elements:{reference:e,floating:t}});u=v??u,d=y??d,m[g]={...m[g],...b},x&&p<Ln&&(p++,typeof x==`object`&&(x.placement&&(f=x.placement),x.rects&&(l=x.rects===!0?await o.getElementRects({reference:e,floating:t,strategy:i}):x.rects),{x:u,y:d}=Fn(l,f,c)),n=-1)}return{x:u,y:d,placement:f,strategy:i,middlewareData:m}},zn=e=>({name:`arrow`,options:e,async fn(t){let{x:n,y:r,placement:i,rects:a,platform:o,elements:s,middlewareData:c}=t,{element:l,padding:u=0}=hn(e,t)||{};if(l==null)return{};let d=Nn(u),f={x:n,y:r},p=xn(i),m=yn(p),h=await o.getDimensions(l),g=p===`y`,_=g?`top`:`left`,v=g?`bottom`:`right`,y=g?`clientHeight`:`clientWidth`,b=a.reference[m]+a.reference[p]-f[p]-a.floating[m],x=f[p]-a.reference[p],S=await(o.getOffsetParent==null?void 0:o.getOffsetParent(l)),C=S?S[y]:0;(!C||!await(o.isElement==null?void 0:o.isElement(S)))&&(C=s.floating[y]||a.floating[m]);let w=b/2-x/2,T=C/2-h[m]/2-1,E=cn(d[_],T),D=cn(d[v],T),O=C-h[m]-D,k=C/2-h[m]/2+w,ee=mn(E,k,O),te=!c.arrow&&_n(i)!=null&&k!==ee&&a.reference[m]/2-(k<E?E:D)-h[m]/2<0,ne=te?k<E?k-E:k-O:0;return{[p]:f[p]+ne,data:{[p]:ee,centerOffset:k-ee-ne,...te&&{alignmentOffset:ne}},reset:te}}}),Bn=function(e){return e===void 0&&(e={}),{name:`flip`,options:e,async fn(t){var n;let{placement:r,middlewareData:i,rects:a,initialPlacement:o,platform:s,elements:c}=t,{mainAxis:l=!0,crossAxis:u=!0,fallbackPlacements:d,fallbackStrategy:f=`bestFit`,fallbackAxisSideDirection:p=`none`,flipAlignment:m=!0,...h}=hn(e,t);if((n=i.arrow)!=null&&n.alignmentOffset)return{};let g=gn(r),_=bn(o),v=gn(o)===o,y=await(s.isRTL==null?void 0:s.isRTL(c.floating)),b=d||(v||!m?[jn(o)]:Cn(o)),x=p!==`none`;!d&&x&&b.push(...An(o,m,p,y));let S=[o,...b],C=await s.detectOverflow(t,h),w=[],T=i.flip?.overflows||[];if(l&&w.push(C[g]),u){let e=Sn(r,a,y);w.push(C[e[0]],C[e[1]])}if(T=[...T,{placement:r,overflows:w}],!w.every(e=>e<=0)){let e=(i.flip?.index||0)+1,t=S[e];if(t&&(u!==`alignment`||_===bn(t)||T.every(e=>bn(e.placement)!==_||e.overflows[0]>0)))return{data:{index:e,overflows:T},reset:{placement:t}};let n=T.filter(e=>e.overflows[0]<=0).sort((e,t)=>e.overflows[1]-t.overflows[1])[0]?.placement;if(!n)switch(f){case`bestFit`:{let e=T.filter(e=>{if(x){let t=bn(e.placement);return t===_||t===`y`}return!0}).map(e=>[e.placement,e.overflows.filter(e=>e>0).reduce((e,t)=>e+t,0)]).sort((e,t)=>e[1]-t[1])[0]?.[0];e&&(n=e);break}case`initialPlacement`:n=o}if(r!==n)return{reset:{placement:n}}}return{}}}};function Vn(e,t){return{top:e.top-t.height,right:e.right-t.width,bottom:e.bottom-t.height,left:e.left-t.width}}function Hn(e){return sn.some(t=>e[t]>=0)}var Un=function(e){return e===void 0&&(e={}),{name:`hide`,options:e,async fn(t){let{rects:n,platform:r}=t,{strategy:i=`referenceHidden`,...a}=hn(e,t);switch(i){case`referenceHidden`:{let e=Vn(await r.detectOverflow(t,{...a,elementContext:`reference`}),n.reference);return{data:{referenceHiddenOffsets:e,referenceHidden:Hn(e)}}}case`escaped`:{let e=Vn(await r.detectOverflow(t,{...a,altBoundary:!0}),n.floating);return{data:{escapedOffsets:e,escaped:Hn(e)}}}default:return{}}}}},Wn=new Set([`left`,`top`]);async function Gn(e,t){let{placement:n,platform:r,elements:i}=e,a=await(r.isRTL==null?void 0:r.isRTL(i.floating)),o=gn(n),s=_n(n),c=bn(n)===`y`,l=Wn.has(o)?-1:1,u=a&&c?-1:1,d=hn(t,e),{mainAxis:f,crossAxis:p,alignmentAxis:m}=typeof d==`number`?{mainAxis:d,crossAxis:0,alignmentAxis:null}:{mainAxis:d.mainAxis||0,crossAxis:d.crossAxis||0,alignmentAxis:d.alignmentAxis};return s&&typeof m==`number`&&(p=s===`end`?m*-1:m),c?{x:p*u,y:f*l}:{x:f*l,y:p*u}}var Kn=function(e){return e===void 0&&(e=0),{name:`offset`,options:e,async fn(t){var n;let{x:r,y:i,placement:a,middlewareData:o}=t,s=await Gn(t,e);return a===o.offset?.placement&&(n=o.arrow)!=null&&n.alignmentOffset?{}:{x:r+s.x,y:i+s.y,data:{...s,placement:a}}}}},qn=function(e){return e===void 0&&(e={}),{name:`shift`,options:e,async fn(t){let{x:n,y:r,placement:i,platform:a}=t,{mainAxis:o=!0,crossAxis:s=!1,limiter:c={fn:e=>{let{x:t,y:n}=e;return{x:t,y:n}}},...l}=hn(e,t),u={x:n,y:r},d=await a.detectOverflow(t,l),f=bn(i),p=vn(f),m=u[p],h=u[f],g=(e,t)=>mn(t+d[e===`y`?`top`:`left`],t,t-d[e===`y`?`bottom`:`right`]);o&&(m=g(p,m)),s&&(h=g(f,h));let _=c.fn({...t,[p]:m,[f]:h});return{..._,data:{x:_.x-n,y:_.y-r,enabled:{[p]:o,[f]:s}}}}}},Jn=function(e){return e===void 0&&(e={}),{options:e,fn(t){let{x:n,y:r,placement:i,rects:a,middlewareData:o}=t,{offset:s=0,mainAxis:c=!0,crossAxis:l=!0}=hn(e,t),u={x:n,y:r},d=bn(i),f=vn(d),p=u[f],m=u[d],h=hn(s,t),g=typeof h==`number`?{mainAxis:h,crossAxis:0}:{mainAxis:h.mainAxis??0,crossAxis:h.crossAxis??0};if(c){let e=f===`y`?`height`:`width`,t=a.reference[f]-a.floating[e]+g.mainAxis,n=a.reference[f]+a.reference[e]-g.mainAxis;p<t?p=t:p>n&&(p=n)}if(l){let e=f===`y`?`width`:`height`,t=Wn.has(gn(i)),n=a.reference[d]-a.floating[e]+(t&&o.offset?.[d]||0)+(t?0:g.crossAxis),r=a.reference[d]+a.reference[e]+(t?0:o.offset?.[d]||0)-(t?g.crossAxis:0);m<n?m=n:m>r&&(m=r)}return{[f]:p,[d]:m}}}},Yn=function(e){return e===void 0&&(e={}),{name:`size`,options:e,async fn(t){let{placement:n,rects:r,platform:i,elements:a}=t,{apply:o=()=>{},...s}=hn(e,t),c=await i.detectOverflow(t,s),l=gn(n),u=_n(n),d=bn(n)===`y`,{width:f,height:p}=r.floating,m,h;l===`top`||l===`bottom`?(m=l,h=u===(await(i.isRTL==null?void 0:i.isRTL(a.floating))?`start`:`end`)?`left`:`right`):(h=l,m=u===`end`?`top`:`bottom`);let g=p-c.top-c.bottom,_=f-c.left-c.right,v=cn(p-c[m],g),y=cn(f-c[h],_),b=t.middlewareData.shift,x=!b,S=v,C=y;b!=null&&b.enabled.x&&(C=_),b!=null&&b.enabled.y&&(S=g),x&&!u&&(d?C=f-2*ln(c.left,c.right):S=p-2*ln(c.top,c.bottom)),await o({...t,availableWidth:C,availableHeight:S});let w=await i.getDimensions(a.floating);return f!==w.width||p!==w.height?{reset:{rects:!0}}:{}}}};function Xn(){return typeof window<`u`}function Zn(e){return $n(e)?(e.nodeName||``).toLowerCase():`#document`}function H(e){var t;return(e==null||(t=e.ownerDocument)==null?void 0:t.defaultView)||window}function Qn(e){return(($n(e)?e.ownerDocument:e.document)||window.document)?.documentElement}function $n(e){return Xn()?e instanceof Node||e instanceof H(e).Node:!1}function er(e){return Xn()?e instanceof Element||e instanceof H(e).Element:!1}function tr(e){return Xn()?e instanceof HTMLElement||e instanceof H(e).HTMLElement:!1}function nr(e){return!Xn()||typeof ShadowRoot>`u`?!1:e instanceof ShadowRoot||e instanceof H(e).ShadowRoot}function rr(e){let{overflow:t,overflowX:n,overflowY:r,display:i}=mr(e);return/auto|scroll|overlay|hidden|clip/.test(t+r+n)&&i!==`inline`&&i!==`contents`}function ir(e){return/^(table|td|th)$/.test(Zn(e))}function ar(e){try{if(e.matches(`:popover-open`))return!0}catch{}try{return e.matches(`:modal`)}catch{return!1}}var or=/transform|translate|scale|rotate|perspective|filter/,sr=/paint|layout|strict|content/,cr=e=>!!e&&e!==`none`,lr;function ur(e){let t=er(e)?mr(e):e;return cr(t.transform)||cr(t.translate)||cr(t.scale)||cr(t.rotate)||cr(t.perspective)||!fr()&&(cr(t.backdropFilter)||cr(t.filter))||or.test(t.willChange||``)||sr.test(t.contain||``)}function dr(e){let t=gr(e);for(;tr(t)&&!pr(t);){if(ur(t))return t;if(ar(t))return null;t=gr(t)}return null}function fr(){return lr??=typeof CSS<`u`&&CSS.supports&&CSS.supports(`-webkit-backdrop-filter`,`none`),lr}function pr(e){return/^(html|body|#document)$/.test(Zn(e))}function mr(e){return H(e).getComputedStyle(e)}function hr(e){return er(e)?{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}:{scrollLeft:e.scrollX,scrollTop:e.scrollY}}function gr(e){if(Zn(e)===`html`)return e;let t=e.assignedSlot||e.parentNode||nr(e)&&e.host||Qn(e);return nr(t)?t.host:t}function _r(e){let t=gr(e);return pr(t)?(e.ownerDocument||e).body:tr(t)&&rr(t)?t:_r(t)}function vr(e,t,n){t===void 0&&(t=[]),n===void 0&&(n=!0);let r=_r(e),i=r===e.ownerDocument?.body,a=H(r);if(i){let e=yr(a);return t.concat(a,a.visualViewport||[],rr(r)?r:[],e&&n?vr(e):[])}return t.concat(r,vr(r,[],n))}function yr(e){return e.parent&&Object.getPrototypeOf(e.parent)?e.frameElement:null}function br(e){let t=mr(e),n=parseFloat(t.width)||0,r=parseFloat(t.height)||0,i=tr(e),a=i?e.offsetWidth:n,o=i?e.offsetHeight:r,s=un(n)!==a||un(r)!==o;return s&&(n=a,r=o),{width:n,height:r,$:s}}function xr(e){return er(e)?e:e.contextElement}function Sr(e){let t=xr(e);if(!tr(t))return fn(1);let n=t.getBoundingClientRect(),{width:r,height:i,$:a}=br(t),o=(a?un(n.width):n.width)/r,s=(a?un(n.height):n.height)/i;return(!o||!Number.isFinite(o))&&(o=1),(!s||!Number.isFinite(s))&&(s=1),{x:o,y:s}}var Cr=fn(0);function wr(e){let t=H(e);return!fr()||!t.visualViewport?Cr:{x:t.visualViewport.offsetLeft,y:t.visualViewport.offsetTop}}function Tr(e,t,n){return t===void 0&&(t=!1),!!n&&t&&n===H(e)}function Er(e,t,n,r){t===void 0&&(t=!1),n===void 0&&(n=!1);let i=e.getBoundingClientRect(),a=xr(e),o=fn(1);t&&(r?er(r)&&(o=Sr(r)):o=Sr(e));let s=Tr(a,n,r)?wr(a):fn(0),c=(i.left+s.x)/o.x,l=(i.top+s.y)/o.y,u=i.width/o.x,d=i.height/o.y;if(a&&r){let e=H(a),t=er(r)?H(r):r,n=e,i=yr(n);for(;i&&t!==n;){let e=Sr(i),t=i.getBoundingClientRect(),r=mr(i),a=t.left+(i.clientLeft+parseFloat(r.paddingLeft))*e.x,o=t.top+(i.clientTop+parseFloat(r.paddingTop))*e.y;c*=e.x,l*=e.y,u*=e.x,d*=e.y,c+=a,l+=o,n=H(i),i=yr(n)}}return Pn({width:u,height:d,x:c,y:l})}function Dr(e,t){let n=hr(e).scrollLeft;return t?t.left+n:Er(Qn(e)).left+n}function Or(e,t){let n=e.getBoundingClientRect();return{x:n.left+t.scrollLeft-Dr(e,n),y:n.top+t.scrollTop}}function kr(e){let{elements:t,rect:n,offsetParent:r,strategy:i}=e,a=i===`fixed`,o=Qn(r),s=t?ar(t.floating):!1;if(r===o||s&&a)return n;let c={scrollLeft:0,scrollTop:0},l=fn(1),u=fn(0),d=tr(r);if((d||!a)&&((Zn(r)!==`body`||rr(o))&&(c=hr(r)),d)){let e=Er(r);l=Sr(r),u.x=e.x+r.clientLeft,u.y=e.y+r.clientTop}let f=o&&!d&&!a?Or(o,c):fn(0);return{width:n.width*l.x,height:n.height*l.y,x:n.x*l.x-c.scrollLeft*l.x+u.x+f.x,y:n.y*l.y-c.scrollTop*l.y+u.y+f.y}}function Ar(e){return e.getClientRects?Array.from(e.getClientRects()):[]}function jr(e){let t=hr(e),n=e.ownerDocument.body,r=ln(e.scrollWidth,e.clientWidth,n.scrollWidth,n.clientWidth),i=ln(e.scrollHeight,e.clientHeight,n.scrollHeight,n.clientHeight),a=-t.scrollLeft+Dr(e),o=-t.scrollTop;return mr(n).direction===`rtl`&&(a+=ln(e.clientWidth,n.clientWidth)-r),{width:r,height:i,x:a,y:o}}var Mr=25;function Nr(e,t,n){n===void 0&&(n=`viewport`);let r=n===`layoutViewport`,i=H(e),a=Qn(e),o=i.visualViewport,s=a.clientWidth,c=a.clientHeight,l=0,u=0;if(o){let e=!fr()||t===`fixed`;r?e||(l=-o.offsetLeft,u=-o.offsetTop):(s=o.width,c=o.height,e&&(l=o.offsetLeft,u=o.offsetTop))}if(Dr(a)<=0){let e=a.ownerDocument,t=e.body,n=getComputedStyle(t),r=e.compatMode===`CSS1Compat`&&parseFloat(n.marginLeft)+parseFloat(n.marginRight)||0,i=Math.abs(a.clientWidth-t.clientWidth-r),o=getComputedStyle(a).scrollbarGutter===`stable both-edges`?i/2:i;o<=Mr&&(s-=o)}return{width:s,height:c,x:l,y:u}}function Pr(e,t){let n=Er(e,!0,t===`fixed`),r=n.top+e.clientTop,i=n.left+e.clientLeft,a=Sr(e);return{width:e.clientWidth*a.x,height:e.clientHeight*a.y,x:i*a.x,y:r*a.y}}function Fr(e,t,n){let r;if(t===`viewport`||t===`layoutViewport`)r=Nr(e,n,t);else if(t===`document`)r=jr(Qn(e));else if(er(t))r=Pr(t,n);else{let n=wr(e);r={x:t.x-n.x,y:t.y-n.y,width:t.width,height:t.height}}return Pn(r)}function Ir(e,t){let n=t.get(e);if(n)return n;let r=vr(e,[],!1).filter(e=>er(e)&&Zn(e)!==`body`),i=null,a=mr(e).position===`fixed`,o=a?gr(e):e;for(;er(o)&&!pr(o);){let e=mr(o),t=ur(o),n=i?i.position:a?`fixed`:``;!t&&(n===`fixed`||n===`absolute`&&e.position===`static`)?r=r.filter(e=>e!==o):i=e,o=gr(o)}return t.set(e,r),r}function Lr(e){let{element:t,boundary:n,rootBoundary:r,strategy:i}=e,a=[...n===`clippingAncestors`?ar(t)?[]:Ir(t,this._c):[].concat(n),r],o=Fr(t,a[0],i),s=o.top,c=o.right,l=o.bottom,u=o.left;for(let e=1;e<a.length;e++){let n=Fr(t,a[e],i);s=ln(n.top,s),c=cn(n.right,c),l=cn(n.bottom,l),u=ln(n.left,u)}return{width:c-u,height:l-s,x:u,y:s}}function Rr(e){let{width:t,height:n}=br(e);return{width:t,height:n}}function zr(e,t,n){let r=tr(t),i=Qn(t),a=n===`fixed`,o=Er(e,!0,a,t),s={scrollLeft:0,scrollTop:0},c=fn(0);if((r||!a)&&((Zn(t)!==`body`||rr(i))&&(s=hr(t)),r)){let e=Er(t,!0,a,t);c.x=e.x+t.clientLeft,c.y=e.y+t.clientTop}!r&&i&&(c.x=Dr(i));let l=i&&!r&&!a?Or(i,s):fn(0);return{x:o.left+s.scrollLeft-c.x-l.x,y:o.top+s.scrollTop-c.y-l.y,width:o.width,height:o.height}}function Br(e){return mr(e).position===`static`}function Vr(e,t){if(!tr(e)||mr(e).position===`fixed`)return null;if(t)return t(e);let n=e.offsetParent;return Qn(e)===n&&(n=n.ownerDocument.body),n}function Hr(e,t){let n=H(e);if(ar(e))return n;if(!tr(e)){let t=gr(e);for(;t&&!pr(t);){if(er(t)&&!Br(t))return t;t=gr(t)}return n}let r=Vr(e,t);for(;r&&ir(r)&&Br(r);)r=Vr(r,t);return r&&pr(r)&&Br(r)&&!ur(r)?n:r||dr(e)||n}var Ur=async function(e){let t=this.getOffsetParent||Hr,n=this.getDimensions,r=await n(e.floating);return{reference:zr(e.reference,await t(e.floating),e.strategy),floating:{x:0,y:0,width:r.width,height:r.height}}};function Wr(e){return mr(e).direction===`rtl`}var Gr={convertOffsetParentRelativeRectToViewportRelativeRect:kr,getDocumentElement:Qn,getClippingRect:Lr,getOffsetParent:Hr,getElementRects:Ur,getClientRects:Ar,getDimensions:Rr,getScale:Sr,isElement:er,isRTL:Wr};function Kr(e,t){return e.x===t.x&&e.y===t.y&&e.width===t.width&&e.height===t.height}function qr(e,t,n){let r=null,i,a=Qn(e);function o(){var e;clearTimeout(i),(e=r)==null||e.disconnect(),r=null}function s(n,c){n===void 0&&(n=!1),c===void 0&&(c=1),o();let l=e.getBoundingClientRect(),{left:u,top:d,width:f,height:p}=l;if(n||t(),!f||!p)return;let m=dn(d),h=dn(a.clientWidth-(u+f)),g=dn(a.clientHeight-(d+p)),_=dn(u),v={rootMargin:-m+`px `+-h+`px `+-g+`px `+-_+`px`,threshold:ln(0,cn(1,c))||1},y=!0;function b(t){let n=t[0].intersectionRatio;if(!Kr(l,e.getBoundingClientRect()))return s();if(n!==c){if(!y)return s();n?s(!1,n):i=setTimeout(()=>{s(!1,1e-7)},1e3)}y=!1}try{r=new IntersectionObserver(b,{...v,root:a.ownerDocument})}catch{r=new IntersectionObserver(b,v)}r.observe(e)}let c=H(e),l=()=>s(n);return c.addEventListener(`resize`,l),s(!0),()=>{c.removeEventListener(`resize`,l),o()}}function Jr(e,t,n,r){r===void 0&&(r={});let{ancestorScroll:i=!0,ancestorResize:a=!0,elementResize:o=typeof ResizeObserver==`function`,layoutShift:s=typeof IntersectionObserver==`function`,animationFrame:c=!1}=r,l=xr(e),u=i||a?[...l?vr(l):[],...t?vr(t):[]]:[];u.forEach(e=>{i&&e.addEventListener(`scroll`,n),a&&e.addEventListener(`resize`,n)});let d=l&&s?qr(l,n,a):null,f=-1,p=null;o&&(p=new ResizeObserver(e=>{let[r]=e;r&&r.target===l&&p&&t&&(p.unobserve(t),cancelAnimationFrame(f),f=requestAnimationFrame(()=>{var e;(e=p)==null||e.observe(t)})),n()}),l&&!c&&p.observe(l),t&&p.observe(t));let m,h=c?Er(e):null;c&&g();function g(){let t=Er(e);h&&!Kr(h,t)&&n(),h=t,m=requestAnimationFrame(g)}return n(),()=>{var e;u.forEach(e=>{i&&e.removeEventListener(`scroll`,n),a&&e.removeEventListener(`resize`,n)}),d?.(),(e=p)==null||e.disconnect(),p=null,c&&cancelAnimationFrame(m)}}var Yr=Kn,Xr=qn,Zr=Bn,Qr=Yn,$r=Un,ei=zn,ti=Jn,ni=(e,t,n)=>{let r=new Map,i=n??{},a={...Gr,...i.platform,_c:r};return Rn(e,t,{...i,platform:a})};function ri(e){return typeof e==`object`&&!!e&&`$el`in e}function ii(e){if(ri(e)){let t=e.$el;return $n(t)&&Zn(t)===`#comment`?null:t}return e}function ai(e){return typeof e==`function`?e():b(e)}function oi(e){return{name:`arrow`,options:e,fn(t){let n=ii(ai(e.element));return n==null?{}:ei({element:n,padding:e.padding}).fn(t)}}}function si(e){return typeof window>`u`?1:(e.ownerDocument.defaultView||window).devicePixelRatio||1}function ci(e,t){let n=si(e);return Math.round(t*n)/n}function li(e,t,n){n===void 0&&(n={});let r=n.whileElementsMounted,i=M(()=>ai(n.open)??!0),a=M(()=>ai(n.middleware)),o=M(()=>ai(n.placement)??`bottom`),s=M(()=>ai(n.strategy)??`absolute`),c=M(()=>ai(n.transform)??!0),l=M(()=>ii(e.value)),d=M(()=>ii(t.value)),f=F(0),p=F(0),m=F(s.value),h=F(o.value),g=w({}),_=F(!1),v=M(()=>{let e={position:m.value,left:`0`,top:`0`};if(!d.value)return e;let t=ci(d.value,f.value),n=ci(d.value,p.value);return c.value?{...e,transform:`translate(`+t+`px, `+n+`px)`,...si(d.value)>=1.5&&{willChange:`transform`}}:{position:m.value,left:t+`px`,top:n+`px`}}),y;function b(){if(l.value==null||d.value==null)return;let e=i.value;ni(l.value,d.value,{middleware:a.value,placement:o.value,strategy:s.value}).then(t=>{f.value=t.x,p.value=t.y,m.value=t.strategy,h.value=t.placement,g.value=t.middlewareData,_.value=e!==!1})}function x(){typeof y==`function`&&(y(),y=void 0)}function C(){if(x(),r===void 0){b();return}if(l.value!=null&&d.value!=null){y=r(l.value,d.value,b);return}}function T(){i.value||(_.value=!1)}return V([a,o,s,i],b,{flush:`sync`}),V([l,d],C,{flush:`sync`}),V(i,T,{flush:`sync`}),u()&&Oe(x),{x:S(f),y:S(p),strategy:S(m),placement:S(h),middlewareData:S(g),isPositioned:S(_),floatingStyles:v,update:b}}var ui=[`dir`],di={side:`bottom`,sideOffset:0,sideFlip:!0,align:`center`,alignOffset:0,alignFlip:!0,arrowPadding:0,hideShiftedArrow:!0,avoidCollisions:!0,collisionBoundary:()=>[],collisionPadding:0,sticky:`partial`,hideWhenDetached:!1,positionStrategy:`fixed`,updatePositionStrategy:`optimized`,prioritizePosition:!1},[fi,pi]=oe(`PopperContent`),mi=R({inheritAttrs:!1,__name:`PopperContent`,props:We({memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},{...di}),emits:[`placed`],setup(e,{emit:t}){let n=e,r=t,a=$t(),{forwardRef:s,currentElement:c}=ie(),u=l(M(()=>n.dir)),d=F(),f=F(),{width:p,height:m}=Ct(f),h=M(()=>n.side+(n.align===`center`?``:`-${n.align}`)),g=M(()=>typeof n.collisionPadding==`number`?n.collisionPadding:{top:0,right:0,bottom:0,left:0,...n.collisionPadding}),_=M(()=>Array.isArray(n.collisionBoundary)?n.collisionBoundary:[n.collisionBoundary]),v=M(()=>({padding:g.value,boundary:_.value.filter(rn),altBoundary:_.value.length>0})),y=M(()=>({mainAxis:n.sideFlip,crossAxis:n.alignFlip})),x=M(()=>[Yr({mainAxis:n.sideOffset+m.value,alignmentAxis:n.alignOffset}),n.prioritizePosition&&n.avoidCollisions&&Zr({...v.value,...y.value}),n.avoidCollisions&&Xr({mainAxis:!0,crossAxis:!!n.prioritizePosition,limiter:n.sticky===`partial`?ti():void 0,...v.value}),!n.prioritizePosition&&n.avoidCollisions&&Zr({...v.value,...y.value}),Qr({...v.value,apply:({elements:e,rects:t,availableWidth:n,availableHeight:r})=>{let{width:i,height:a}=t.reference,o=e.floating.style;o.setProperty(`--reka-popper-available-width`,`${n}px`),o.setProperty(`--reka-popper-available-height`,`${r}px`),o.setProperty(`--reka-popper-anchor-width`,`${i}px`),o.setProperty(`--reka-popper-anchor-height`,`${a}px`)}}),f.value&&oi({element:f.value,padding:n.arrowPadding}),an({arrowWidth:p.value,arrowHeight:m.value,dir:u.value}),n.hideWhenDetached&&$r({strategy:`referenceHidden`,...v.value})]),{floatingStyles:S,placement:C,isPositioned:w,middlewareData:T,update:E}=li(M(()=>n.reference??a.anchor.value),d,{strategy:n.positionStrategy,placement:h,whileElementsMounted:(...e)=>Jr(...e,{layoutShift:!n.disableUpdateOnLayoutShift,animationFrame:n.updatePositionStrategy===`always`}),middleware:x}),D=M(()=>on(C.value)[0]),O=M(()=>on(C.value)[1]);o(()=>{w.value&&r(`placed`)});let k=M(()=>{let e=T.value.arrow?.centerOffset!==0;return n.hideShiftedArrow&&e}),ee=F(``);return re(()=>{c.value&&(ee.value=window.getComputedStyle(c.value).zIndex)}),pi({placedSide:D,onArrowChange:e=>f.value=e,arrowX:M(()=>T.value.arrow?.x??0),arrowY:M(()=>T.value.arrow?.y??0),shouldHideArrow:k}),(e,t)=>(N(),P(`div`,{ref_key:`floatingRef`,ref:d,"data-reka-popper-content-wrapper":``,dir:b(u),style:i({...b(S),transform:b(w)?b(S).transform:`translate(0, -200%)`,minWidth:`max-content`,zIndex:ee.value,"--reka-popper-transform-origin":[b(T).transformOrigin?.x,b(T).transformOrigin?.y].join(` `),...b(T).hide?.referenceHidden&&{visibility:`hidden`,pointerEvents:`none`}})},[n.memoDependencies?ae([n.asChild,n.as,D.value,O.value,b(w),...Object.values(e.$attrs),...n.memoDependencies],()=>(N(),I(b(A),j({key:0,ref:b(s)},e.$attrs,{"as-child":n.asChild,as:n.as,"data-side":D.value,"data-align":O.value,style:{animation:b(w)?void 0:`none`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`style`])),t,0):(N(),I(b(A),j({key:1,ref:b(s)},e.$attrs,{"as-child":n.asChild,as:n.as,"data-side":D.value,"data-align":O.value,dir:b(u),style:{animation:b(w)?void 0:`none`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`dir`,`style`]))],12,ui))}});function hi(e){let t=s({nonce:F()});return M(()=>e?.value||t.nonce?.value)}var gi=[` `,`Enter`,`ArrowUp`,`ArrowDown`],_i=[` `,`Enter`];function vi(e,t,n){return e===void 0?!1:Array.isArray(e)?e.some(e=>yi(e,t,n)):yi(e,t,n)}function yi(e,t,n){return e===void 0||t===void 0?!1:typeof e==`string`?e===t:typeof n==`function`?n(e,t):typeof n==`string`?e?.[n]===t?.[n]:le(e,t)}function bi(e){return e==null||e===``||Array.isArray(e)&&e.length===0}var xi=[`value`],[Si,Ci]=oe(`SelectRoot`),wi=R({inheritAttrs:!1,__name:`SelectRoot`,props:{open:{type:Boolean,required:!1,default:void 0},defaultOpen:{type:Boolean,required:!1},defaultValue:{type:null,required:!1},modelValue:{type:null,required:!1,default:void 0},nullableValue:{type:String,required:!1,default:``},by:{type:[String,Function],required:!1},dir:{type:String,required:!1},multiple:{type:Boolean,required:!1},autocomplete:{type:String,required:!1},disabled:{type:Boolean,required:!1},name:{type:String,required:!1},required:{type:Boolean,required:!1}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=e,r=t,{required:i,disabled:a,multiple:o,dir:s}=f(n),c=C(n,`modelValue`,r,{defaultValue:n.defaultValue??(o.value?[]:void 0),passive:n.modelValue===void 0,deep:!0}),u=C(n,`open`,r,{defaultValue:n.defaultOpen,passive:n.open===void 0}),d=F(),p=F(),m=F({x:0,y:0}),h=M(()=>o.value&&Array.isArray(c.value)?c.value?.length===0:se(c.value));Je({isProvider:!0});let g=l(s),_=ft(d),v=F(new Set),y=M(()=>Array.from(v.value).map(e=>e.value).join(`;`));function x(e){if(o.value){let t=Array.isArray(c.value)?[...c.value]:[],r=t.findIndex(t=>yi(t,e,n.by));r===-1?t.push(e):t.splice(r,1),c.value=[...t]}else c.value=e}function S(e){return Array.from(v.value).find(t=>vi(e,t.value,n.by))}return Ci({triggerElement:d,onTriggerChange:e=>{d.value=e},valueElement:p,onValueElementChange:e=>{p.value=e},contentId:``,modelValue:c,onValueChange:x,by:n.by,open:u,multiple:o,required:i,onOpenChange:e=>{u.value=e},dir:g,triggerPointerDownPosRef:m,disabled:a,isEmptyModelValue:h,optionsSet:v,onOptionAdd:e=>{let t=S(e.value);t&&v.value.delete(t),v.value.add(e)},onOptionRemove:e=>{let t=S(e.value);t&&v.value.delete(t)}}),(e,t)=>(N(),I(b(tn),null,{default:B(()=>[z(e.$slots,`default`,{modelValue:b(c),open:b(u)}),b(_)&&e.name?(N(),I(Ti,{key:y.value,"aria-hidden":`true`,tabindex:`-1`,multiple:b(o),required:b(i),name:e.name,autocomplete:e.autocomplete,disabled:b(a),value:b(c)},{default:B(()=>[b(se)(b(c))?(N(),P(`option`,{key:0,value:e.nullableValue},null,8,xi)):ze(`v-if`,!0),(N(!0),P(k,null,me(Array.from(v.value),e=>(N(),P(`option`,j({key:e.value??``},{ref_for:!0},e),null,16))),128))]),_:1},8,[`multiple`,`required`,`name`,`autocomplete`,`disabled`,`value`])):ze(`v-if`,!0)]),_:3}))}}),Ti=R({__name:`BubbleSelect`,props:{autocomplete:{type:String,required:!1},autofocus:{type:Boolean,required:!1},disabled:{type:Boolean,required:!1},form:{type:String,required:!1},multiple:{type:Boolean,required:!1},name:{type:String,required:!1},required:{type:Boolean,required:!1},size:{type:Number,required:!1},value:{type:null,required:!1}},setup(e){let t=e,n=F(),r=Si();V(()=>t.value,(e,t)=>{let r=window.HTMLSelectElement.prototype,i=Object.getOwnPropertyDescriptor(r,`value`).set;if(e!==t&&i&&n.value){let t=new Event(`change`,{bubbles:!0});i.call(n.value,e),n.value.dispatchEvent(t)}});function i(e){r.onValueChange(e.target.value)}return(e,r)=>(N(),I(b(Qt),{"as-child":``},{default:B(()=>[He(`select`,j({ref_key:`selectElement`,ref:n},t,{onInput:i}),[z(e.$slots,`default`)],16)]),_:3}))}}),Ei=R({__name:`SelectPopperPosition`,props:{memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1,default:`start`},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1,default:10},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Ke(e);return(e,n)=>(N(),I(b(mi),j(b(t),{style:{boxSizing:`border-box`,"--reka-select-content-transform-origin":`var(--reka-popper-transform-origin)`,"--reka-select-content-available-width":`var(--reka-popper-available-width)`,"--reka-select-content-available-height":`var(--reka-popper-available-height)`,"--reka-select-trigger-width":`var(--reka-popper-anchor-width)`,"--reka-select-trigger-height":`var(--reka-popper-anchor-height)`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Di={onViewportChange:()=>{},itemTextRefCallback:()=>{},itemRefCallback:()=>{}},[Oi,ki]=oe(`SelectContent`),Ai=R({__name:`SelectContentImpl`,props:{position:{type:String,required:!1,default:`item-aligned`},bodyLock:{type:Boolean,required:!1,default:!0},memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1,default:`start`},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},disableOutsidePointerEvents:{type:Boolean,required:!1,default:!0}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=Si();ut(),ot(n.bodyLock);let{CollectionSlot:a,getItems:o}=Je(),s=F();St(s);let{search:c,handleTypeaheadSearch:l}=wt(),u=F(),d=F(),f=F(),p=F(!1),m=F(!1),h=F(!1);function g(){d.value&&s.value&&Xt([d.value,s.value])}V(p,()=>{g()});let{onOpenChange:_,triggerPointerDownPosRef:v}=i;re(e=>{if(!s.value)return;let t={x:0,y:0},n=e=>{t={x:Math.abs(Math.round(e.pageX)-(v.value?.x??0)),y:Math.abs(Math.round(e.pageY)-(v.value?.y??0))}},r=e=>{e.pointerType!==`touch`&&(t.x<=10&&t.y<=10?e.preventDefault():s.value?.contains(e.target)||_(!1),document.removeEventListener(`pointermove`,n),v.value=null)};v.value!==null&&(document.addEventListener(`pointermove`,n),document.addEventListener(`pointerup`,r,{capture:!0,once:!0})),e(()=>{document.removeEventListener(`pointermove`,n),document.removeEventListener(`pointerup`,r,{capture:!0})})});function y(e){let t=e.ctrlKey||e.altKey||e.metaKey;if(e.key===`Tab`&&e.preventDefault(),!t&&e.key.length===1&&l(e.key,o()),[`ArrowUp`,`ArrowDown`,`Home`,`End`].includes(e.key)){let t=[...o().map(e=>e.ref)];if([`ArrowUp`,`End`].includes(e.key)&&(t=t.slice().reverse()),[`ArrowUp`,`ArrowDown`].includes(e.key)){let n=e.target,r=t.indexOf(n);t=t.slice(r+1)}setTimeout(()=>Xt(t)),e.preventDefault()}}let x=M(()=>n.position===`popper`?n:{}),S=Ke(x.value);return ki({content:s,viewport:u,onViewportChange:e=>{u.value=e},itemRefCallback:(e,t,n)=>{let r=!m.value&&!n,a=vi(i.modelValue.value,t,i.by);if(i.multiple.value){if(h.value)return;(a||r)&&(d.value=e,a&&(h.value=!0))}else(a||r)&&(d.value=e);r&&(m.value=!0)},selectedItem:d,selectedItemText:f,onItemLeave:()=>{s.value?.focus()},itemTextRefCallback:(e,t,n)=>{let r=!m.value&&!n;(vi(i.modelValue.value,t,i.by)||r)&&(f.value=e)},focusSelectedItem:g,position:n.position,isPositioned:p,searchRef:c}),(e,t)=>(N(),I(b(a),null,{default:B(()=>[L(b(Kt),{"as-child":``,onMountAutoFocus:t[6]||=fe(()=>{},[`prevent`]),onUnmountAutoFocus:t[7]||=e=>{r(`closeAutoFocus`,e),!e.defaultPrevented&&(b(i).triggerElement.value?.focus({preventScroll:!0}),e.preventDefault())}},{default:B(()=>[L(b(Mt),{"as-child":``,"disable-outside-pointer-events":e.disableOutsidePointerEvents,onFocusOutside:t[2]||=fe(()=>{},[`prevent`]),onDismiss:t[3]||=e=>b(i).onOpenChange(!1),onEscapeKeyDown:t[4]||=e=>r(`escapeKeyDown`,e),onPointerDownOutside:t[5]||=e=>r(`pointerDownOutside`,e)},{default:B(()=>[(N(),I(Ye(e.position===`popper`?Ei:Ni),j({...e.$attrs,...b(S)},{id:b(i).contentId,ref:e=>{if(!e)return;let t=b(De)(e);t?.hasAttribute(`data-reka-popper-content-wrapper`)?s.value=t.firstElementChild:s.value=t},role:`listbox`,"data-state":b(i).open.value?`open`:`closed`,dir:b(i).dir.value,style:{display:`flex`,flexDirection:`column`,outline:`none`},onContextmenu:t[0]||=fe(()=>{},[`prevent`]),onPlaced:t[1]||=e=>p.value=!0,onKeydown:y}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`id`,`data-state`,`dir`,`onKeydown`]))]),_:3},8,[`disable-outside-pointer-events`])]),_:3})]),_:3}))}}),[ji,Mi]=oe(`SelectItemAlignedPosition`),Ni=R({inheritAttrs:!1,__name:`SelectItemAlignedPosition`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`placed`],setup(e,{emit:t}){let n=e,r=t,{getItems:a}=Je(),o=Si(),s=Oi(),c=F(!1),l=F(!0),u=F(),{forwardRef:d,currentElement:f}=ie(),{viewport:p,selectedItem:m,selectedItemText:h,focusSelectedItem:g}=s;function _(){if(o.triggerElement.value&&o.valueElement.value&&u.value&&f.value&&p?.value&&m?.value&&h?.value){let e=o.triggerElement.value.getBoundingClientRect(),t=f.value.getBoundingClientRect(),n=o.valueElement.value.getBoundingClientRect(),i=h.value.getBoundingClientRect();if(o.dir.value!==`rtl`){let r=i.left-t.left,a=n.left-r,o=e.left-a,s=e.width+o,c=Math.max(s,t.width),l=window.innerWidth-10,d=Qe(a,10,Math.max(10,l-c));u.value.style.minWidth=`${s}px`,u.value.style.left=`${d}px`}else{let r=t.right-i.right,a=window.innerWidth-n.right-r,o=window.innerWidth-e.right-a,s=e.width+o,c=Math.max(s,t.width),l=window.innerWidth-10,d=Qe(a,10,Math.max(10,l-c));u.value.style.minWidth=`${s}px`,u.value.style.right=`${d}px`}let s=a().map(e=>e.ref),l=window.innerHeight-20,d=p.value.scrollHeight,g=window.getComputedStyle(f.value),_=Number.parseInt(g.borderTopWidth,10),v=Number.parseInt(g.paddingTop,10),y=Number.parseInt(g.borderBottomWidth,10),b=Number.parseInt(g.paddingBottom,10),x=_+v+d+b+y,S=Math.min(m.value.offsetHeight*5,x),C=window.getComputedStyle(p.value),w=Number.parseInt(C.paddingTop,10),T=Number.parseInt(C.paddingBottom,10),E=e.top+e.height/2-10,D=l-E,O=m.value.offsetHeight/2,k=m.value.offsetTop+O,ee=_+v+k,te=x-ee;if(ee<=E){let e=m.value===s.at(-1);u.value.style.bottom=`0px`;let t=f.value.clientHeight-p.value.offsetTop-p.value.offsetHeight,n=ee+Math.max(D,O+(e?T:0)+t+y);u.value.style.height=`${n}px`}else{let e=m.value===s[0];u.value.style.top=`0px`;let t=Math.max(E,_+p.value.offsetTop+(e?w:0)+O)+te;u.value.style.height=`${t}px`,p.value.scrollTop=ee-E+p.value.offsetTop}u.value.style.margin=`10px 0`,u.value.style.minHeight=`${S}px`,u.value.style.maxHeight=`${l}px`,r(`placed`),requestAnimationFrame(()=>c.value=!0)}}let v=F(``);Me(async()=>{await xe(),_(),f.value&&(v.value=window.getComputedStyle(f.value).zIndex)});function y(e){e&&l.value===!0&&(_(),g?.(),l.value=!1)}return x(o.triggerElement,()=>{_()}),Mi({contentWrapper:u,shouldExpandOnScrollRef:c,onScrollButtonChange:y}),(e,t)=>(N(),P(`div`,{ref_key:`contentWrapperElement`,ref:u,style:i({display:`flex`,flexDirection:`column`,position:`fixed`,zIndex:v.value})},[L(b(A),j({ref:b(d),style:{boxSizing:`border-box`,maxHeight:`100%`}},{...e.$attrs,...n}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16)],4))}}),Pi=R({inheritAttrs:!1,__name:`SelectProvider`,props:{context:{type:Object,required:!0}},setup(e){return Ci(e.context),ki(Di),(e,t)=>z(e.$slots,`default`)}}),Fi={key:1},Ii=R({inheritAttrs:!1,__name:`SelectContent`,props:{forceMount:{type:Boolean,required:!1},position:{type:String,required:!1},bodyLock:{type:Boolean,required:!1},memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},disableOutsidePointerEvents:{type:Boolean,required:!1}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(t,{emit:n}){let r=t,i=a(r,n),o=Si(),s=F();Me(()=>{s.value=new DocumentFragment});let c=F(),l=M(()=>r.forceMount||o.open.value),u=F(l.value),d;function f(){d&&=(clearTimeout(d),void 0)}return V(l,(e,t,n)=>{f(),d=setTimeout(()=>{u.value=l.value,d=void 0}),n(f)}),we(f),(t,n)=>l.value||u.value||c.value?.present?(N(),I(b(qe),{key:0,ref_key:`presenceRef`,ref:c,present:l.value},{default:B(()=>[L(Ai,Ze(ve({...b(i),...t.$attrs})),{default:B(()=>[z(t.$slots,`default`)]),_:3},16)]),_:3},8,[`present`])):s.value?(N(),P(`div`,Fi,[(N(),I(e,{to:s.value},[L(Pi,{context:b(o)},{default:B(()=>[z(t.$slots,`default`)]),_:3},8,[`context`])],8,[`to`]))])):ze(`v-if`,!0)}}),Li=R({__name:`SelectIcon`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(N(),I(b(A),{"aria-hidden":`true`,as:e.as,"as-child":e.asChild},{default:B(()=>[z(e.$slots,`default`,{},()=>[t[0]||=ge(`▼`)])]),_:3},8,[`as`,`as-child`]))}}),[Ri,zi]=oe(`SelectItem`),Bi=R({__name:`SelectItem`,props:{value:{type:null,required:!0},disabled:{type:Boolean,required:!1},textValue:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`select`],setup(e,{emit:t}){let n=e,r=t,{disabled:i}=f(n),a=Si(),o=Oi(),{forwardRef:s,currentElement:c}=ie(),{CollectionItem:l}=Je(),u=M(()=>vi(a.modelValue?.value,n.value,a.by)),d=F(!1),p=F(n.textValue??``),h=ne(void 0,`reka-select-item-text`);async function g(e){e.defaultPrevented||$e(`select.select`,_,{originalEvent:e,value:n.value})}async function _(e){await xe(),r(`select`,e),!e.defaultPrevented&&(i.value||(a.onValueChange(n.value),a.multiple.value||a.onOpenChange(!1)))}async function v(e){await xe(),!e.defaultPrevented&&(i.value?o.onItemLeave?.():e.currentTarget?.focus({preventScroll:!0}))}async function y(e){await xe(),!e.defaultPrevented&&e.currentTarget===m()&&o.onItemLeave?.()}async function x(e){await xe(),!e.defaultPrevented&&(o.searchRef?.value===``||e.key!==` `)&&(_i.includes(e.key)&&g(e),e.key===` `&&e.preventDefault())}if(n.value===``)throw Error(`A <SelectItem /> must have a value prop that is not an empty string. This is because the Select value can be set to an empty string to clear the selection and show the placeholder.`);return Me(()=>{c.value&&o.itemRefCallback(c.value,n.value,n.disabled)}),zi({value:n.value,disabled:i,textId:h,isSelected:u,onItemTextChange:e=>{p.value=((p.value||e?.textContent)??``).trim()}}),(e,t)=>(N(),I(b(l),{value:{textValue:p.value}},{default:B(()=>[L(b(A),{ref:b(s),role:`option`,"aria-labelledby":b(h),"data-highlighted":d.value?``:void 0,"aria-selected":u.value,"data-state":u.value?`checked`:`unchecked`,"aria-disabled":b(i)||void 0,"data-disabled":b(i)?``:void 0,tabindex:b(i)?void 0:-1,as:e.as,"as-child":e.asChild,onFocus:t[0]||=e=>d.value=!0,onBlur:t[1]||=e=>d.value=!1,onPointerup:g,onPointerdown:t[2]||=e=>{e.currentTarget.focus({preventScroll:!0})},onTouchend:t[3]||=fe(()=>{},[`prevent`,`stop`]),onPointermove:v,onPointerleave:y,onKeydown:x},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`aria-labelledby`,`data-highlighted`,`aria-selected`,`data-state`,`aria-disabled`,`data-disabled`,`tabindex`,`as`,`as-child`])]),_:3},8,[`value`]))}}),Vi=R({__name:`SelectItemIndicator`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Ri();return(e,r)=>b(n).isSelected.value?(N(),I(b(A),j({key:0,"aria-hidden":`true`},t),{default:B(()=>[z(e.$slots,`default`)]),_:3},16)):ze(`v-if`,!0)}}),Hi=R({inheritAttrs:!1,__name:`SelectItemText`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Si(),r=Oi(),i=Ri(),{forwardRef:a,currentElement:o}=ie(),s=M(()=>({value:i.value,disabled:i.disabled.value,textContent:o.value?.textContent??i.value?.toString()??``}));return Me(()=>{o.value&&(i.onItemTextChange(o.value),r.itemTextRefCallback(o.value,i.value,i.disabled.value),n.onOptionAdd(s.value))}),we(()=>{n.onOptionRemove(s.value)}),(e,n)=>(N(),I(b(A),j({id:b(i).textId,ref:b(a)},{...t,...e.$attrs}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`id`]))}}),Ui=R({__name:`SelectPortal`,props:{to:{type:null,required:!1},disabled:{type:Boolean,required:!1},defer:{type:Boolean,required:!1},forceMount:{type:Boolean,required:!1}},setup(e){let t=e;return(e,n)=>(N(),I(b(Zt),Ze(ve(t)),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Wi=R({__name:`SelectScrollButtonImpl`,emits:[`autoScroll`],setup(e,{emit:t}){let n=t,{getItems:r}=Je(),i=Oi(),a=F(null);function o(){a.value!==null&&(window.clearInterval(a.value),a.value=null)}re(()=>{r().map(e=>e.ref).find(e=>e===m())?.scrollIntoView({block:`nearest`})});function s(){a.value===null&&(a.value=window.setInterval(()=>{n(`autoScroll`)},50))}function c(){i.onItemLeave?.(),a.value===null&&(a.value=window.setInterval(()=>{n(`autoScroll`)},50))}return Ie(()=>o()),(e,t)=>(N(),I(b(A),j({"aria-hidden":`true`,style:{flexShrink:0}},e.$parent?.$props,{onPointerdown:s,onPointermove:c,onPointerleave:t[0]||=()=>{o()}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Gi=R({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Oi(),n=t.position===`item-aligned`?ji():void 0,{forwardRef:r,currentElement:i}=ie(),a=F(!1);return re(e=>{if(t.viewport?.value&&t.isPositioned?.value){let n=t.viewport.value;function r(){let e=n.scrollHeight-n.clientHeight;a.value=Math.ceil(n.scrollTop)<e}r(),n.addEventListener(`scroll`,r),e(()=>n.removeEventListener(`scroll`,r))}}),V(i,()=>{i.value&&n?.onScrollButtonChange(i.value)}),(e,n)=>a.value?(N(),I(Wi,{key:0,ref:b(r),onAutoScroll:n[0]||=()=>{let{viewport:e,selectedItem:n}=b(t);e?.value&&n?.value&&(e.value.scrollTop=e.value.scrollTop+n.value.offsetHeight)}},{default:B(()=>[z(e.$slots,`default`)]),_:3},512)):ze(`v-if`,!0)}}),Ki=R({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Oi(),n=t.position===`item-aligned`?ji():void 0,{forwardRef:r,currentElement:i}=ie(),a=F(!1);return re(e=>{if(t.viewport?.value&&t.isPositioned?.value){let n=t.viewport.value;function r(){a.value=n.scrollTop>0}r(),n.addEventListener(`scroll`,r),e(()=>n.removeEventListener(`scroll`,r))}}),V(i,()=>{i.value&&n?.onScrollButtonChange(i.value)}),(e,n)=>a.value?(N(),I(Wi,{key:0,ref:b(r),onAutoScroll:n[0]||=()=>{let{viewport:e,selectedItem:n}=b(t);e?.value&&n?.value&&(e.value.scrollTop=e.value.scrollTop-n.value.offsetHeight)}},{default:B(()=>[z(e.$slots,`default`)]),_:3},512)):ze(`v-if`,!0)}}),qi=R({__name:`SelectTrigger`,props:{disabled:{type:Boolean,required:!1},reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e,n=Si(),{forwardRef:r,currentElement:i}=ie(),a=M(()=>n.disabled?.value||t.disabled);n.contentId||=ne(void 0,`reka-select-content`),Me(()=>{n.onTriggerChange(i.value)});let{getItems:o}=Je(),{search:s,handleTypeaheadSearch:c,resetTypeahead:l}=wt();function u(){a.value||(n.onOpenChange(!0),l())}function d(e){u(),n.triggerPointerDownPosRef.value={x:Math.round(e.pageX),y:Math.round(e.pageY)}}function f(e){return e.button===0&&e.ctrlKey===!1}let p=!1;function m(e){if(e.pointerType===`touch`)return e.preventDefault();let t=e.target;t.hasPointerCapture(e.pointerId)&&t.releasePointerCapture(e.pointerId),f(e)&&(d(e),p=!0)}function h(e){f(e)&&e.preventDefault()}function g(e){p||e.currentTarget?.focus(),p=!1}return(e,t)=>(N(),I(b(nn),{"as-child":``,reference:e.reference},{default:B(()=>[L(b(A),{ref:b(r),role:`combobox`,type:e.as===`button`?`button`:void 0,"aria-controls":b(n).contentId,"aria-expanded":b(n).open.value||!1,"aria-required":b(n).required?.value,"aria-autocomplete":`none`,disabled:a.value,dir:b(n)?.dir.value,"data-state":b(n)?.open.value?`open`:`closed`,"data-disabled":a.value?``:void 0,"data-placeholder":b(bi)(b(n).modelValue?.value)?``:void 0,"as-child":e.asChild,as:e.as,onClick:g,onPointerdown:m,onMousedown:h,onPointerup:t[0]||=fe(e=>{e.pointerType===`touch`&&d(e)},[`prevent`]),onKeydown:t[1]||=e=>{let t=b(s)!==``;!(e.ctrlKey||e.altKey||e.metaKey)&&e.key.length===1&&t&&e.key===` `||(b(c)(e.key,b(o)()),b(gi).includes(e.key)&&(u(),e.preventDefault()))}},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`type`,`aria-controls`,`aria-expanded`,`aria-required`,`disabled`,`dir`,`data-state`,`data-disabled`,`data-placeholder`,`as-child`,`as`])]),_:3},8,[`reference`]))}}),Ji=R({__name:`SelectValue`,props:{placeholder:{type:String,required:!1,default:``},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,{forwardRef:n,currentElement:r}=ie(),i=Si();Me(()=>{i.valueElement=r});let a=M(()=>{let e=[],t=Array.from(i.optionsSet.value),n=e=>t.find(t=>vi(e,t.value,i.by));return e=Array.isArray(i.modelValue.value)?i.modelValue.value.map(e=>n(e)?.textContent??``):[n(i.modelValue.value)?.textContent??``],e.filter(Boolean)}),o=M(()=>a.value.length?a.value.join(`, `):t.placeholder);return(e,r)=>(N(),I(b(A),{ref:b(n),as:e.as,"as-child":e.asChild,style:{pointerEvents:`none`},"data-placeholder":a.value.length?void 0:t.placeholder},{default:B(()=>[z(e.$slots,`default`,{selectedLabel:a.value,modelValue:b(i).modelValue.value},()=>[ge(ce(o.value),1)])]),_:3},8,[`as`,`as-child`,`data-placeholder`]))}}),Yi=R({__name:`SelectViewport`,props:{nonce:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{nonce:n}=f(t),r=hi(n),i=Oi(),a=i.position===`item-aligned`?ji():void 0,{forwardRef:o,currentElement:s}=ie();Me(()=>{i?.onViewportChange(s.value)});let c=F(0);function l(e){let t=e.currentTarget,{shouldExpandOnScrollRef:n,contentWrapper:r}=a??{};if(n?.value&&r?.value){let e=Math.abs(c.value-t.scrollTop);if(e>0){let n=window.innerHeight-20,i=Number.parseFloat(r.value.style.minHeight),a=Number.parseFloat(r.value.style.height),o=Math.max(i,a);if(o<n){let i=o+e,a=Math.min(n,i),s=i-a;r.value.style.height=`${a}px`,r.value.style.bottom===`0px`&&(t.scrollTop=s>0?s:0,r.value.style.justifyContent=`flex-end`)}}}c.value=t.scrollTop}return(e,n)=>(N(),P(k,null,[L(b(A),j({ref:b(o),"data-reka-select-viewport":``,role:`presentation`},{...e.$attrs,...t},{style:{position:`relative`,flex:1,overflow:`hidden auto`},onScroll:l}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16),L(b(A),{as:`style`,nonce:b(r)},{default:B(()=>n[0]||=[ge(` /* Hide scrollbars cross-browser and enable momentum scroll for touch devices */ [data-reka-select-viewport] { scrollbar-width:none; -ms-overflow-style: none; -webkit-overflow-scrolling: touch; } [data-reka-select-viewport]::-webkit-scrollbar { display: none; } `)]),_:1,__:[0]},8,[`nonce`])],64))}}),Xi=R({__name:`Select`,props:{open:{type:Boolean},defaultOpen:{type:Boolean},defaultValue:{},modelValue:{},nullableValue:{},by:{type:[String,Function]},dir:{},multiple:{type:Boolean},autocomplete:{},disabled:{type:Boolean},name:{},required:{type:Boolean}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=a(e,t);return(e,t)=>(N(),I(b(wi),j({"data-slot":`select`},b(n)),{default:B(t=>[z(e.$slots,`default`,Ze(ve(t)))]),_:3},16))}}),Zi=R({inheritAttrs:!1,__name:`SelectContent`,props:{forceMount:{type:Boolean},position:{default:`item-aligned`},bodyLock:{type:Boolean},memoDependencies:{},side:{},sideOffset:{},sideFlip:{type:Boolean},align:{default:`center`},alignOffset:{},alignFlip:{type:Boolean},avoidCollisions:{type:Boolean},collisionBoundary:{},collisionPadding:{},arrowPadding:{},hideShiftedArrow:{type:Boolean},sticky:{},hideWhenDetached:{type:Boolean},positionStrategy:{},updatePositionStrategy:{},disableUpdateOnLayoutShift:{type:Boolean},prioritizePosition:{type:Boolean},reference:{},dir:{},asChild:{type:Boolean},as:{},disableOutsidePointerEvents:{type:Boolean},class:{type:[Boolean,null,String,Object,Array]}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=ee(n,`class`),o=a(i,r);return(t,r)=>(N(),I(b(Ui),null,{default:B(()=>[L(b(Ii),j({"data-slot":`select-content`,"data-align-trigger":e.position===`item-aligned`},{...t.$attrs,...b(o)},{class:b(p)(`bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 min-w-36 rounded-lg shadow-md ring-1 duration-100 data-[side=inline-start]:slide-in-from-right-2 data-[side=inline-end]:slide-in-from-left-2 cn-menu-translucent relative z-50 max-h-(--reka-select-content-available-height) origin-(--reka-select-content-transform-origin) overflow-x-hidden overflow-y-auto data-[align-trigger=true]:animate-none`,e.position===`popper`&&`data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1`,n.class)}),{default:B(()=>[L(b(ta)),L(b(Yi),{"data-position":e.position,class:te(b(p)(`data-[position=popper]:h-(--reka-select-trigger-height) data-[position=popper]:w-full data-[position=popper]:min-w-(--reka-select-trigger-width)`))},{default:B(()=>[z(t.$slots,`default`)]),_:3},8,[`data-position`,`class`]),L(b(ea))]),_:3},16,[`data-align-trigger`,`class`])]),_:3}))}}),Qi={class:`pointer-events-none absolute right-2 flex size-4 items-center justify-center`},$i=R({__name:`SelectItem`,props:{value:{},disabled:{type:Boolean},textValue:{},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Bi),j({"data-slot":`select-item`},b(r),{class:b(p)(`focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*=size-])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2 relative flex w-full cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0`,t.class)}),{default:B(()=>[He(`span`,Qi,[L(b(Vi),null,{default:B(()=>[z(e.$slots,`indicator-icon`,{},()=>[L(b(ue),{icon:b(v),class:`pointer-events-none size-3.5`},null,8,[`icon`])])]),_:3})]),L(b(Hi),null,{default:B(()=>[z(e.$slots,`default`)]),_:3})]),_:3},16,[`class`]))}}),ea=R({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Gi),j({"data-slot":`select-scroll-down-button`},b(r),{class:b(p)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:B(()=>[z(e.$slots,`default`,{},()=>[L(b(ue),{icon:b(Le),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),ta=R({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Ki),j({"data-slot":`select-scroll-up-button`},b(r),{class:b(p)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:B(()=>[z(e.$slots,`default`,{},()=>[L(b(ue),{icon:b(_),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),na=R({__name:`SelectTrigger`,props:{disabled:{type:Boolean},reference:{},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e,n=ee(t,`class`,`size`),r=Ke(n);return(n,i)=>(N(),I(b(qi),j({"data-slot":`select-trigger`,"data-size":e.size},b(r),{class:b(p)(`border-input data-placeholder:text-muted-foreground dark:bg-input/30 dark:hover:bg-input/50 focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 gap-1.5 rounded-lg border bg-transparent py-2 pr-2 pl-2.5 text-sm transition-colors select-none focus-visible:ring-3 aria-invalid:ring-3 data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:gap-1.5 [&_svg:not([class*=size-])]:size-4 flex w-fit items-center justify-between whitespace-nowrap outline-none disabled:cursor-not-allowed disabled:opacity-50 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center [&_svg]:pointer-events-none [&_svg]:shrink-0`,t.class)}),{default:B(()=>[z(n.$slots,`default`),L(b(Li),{"as-child":``},{default:B(()=>[L(b(ue),{icon:b(Le),class:`text-muted-foreground size-4 pointer-events-none`},null,8,[`icon`])]),_:1})]),_:3},16,[`data-size`,`class`]))}}),ra=R({__name:`SelectValue`,props:{placeholder:{},asChild:{type:Boolean},as:{}},setup(e){let t=e;return(e,n)=>(N(),I(b(Ji),j({"data-slot":`select-value`},t),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}});function ia(e){return e+.5|0}var aa=(e,t,n)=>Math.max(Math.min(e,n),t);function oa(e){return aa(ia(e*2.55),0,255)}function sa(e){return aa(ia(e*255),0,255)}function ca(e){return aa(ia(e/2.55)/100,0,1)}function la(e){return aa(ia(e*100),0,100)}var ua={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,A:10,B:11,C:12,D:13,E:14,F:15,a:10,b:11,c:12,d:13,e:14,f:15},da=[...`0123456789ABCDEF`],fa=e=>da[e&15],pa=e=>da[(e&240)>>4]+da[e&15],ma=e=>(e&240)>>4==(e&15),ha=e=>ma(e.r)&&ma(e.g)&&ma(e.b)&&ma(e.a);function ga(e){var t=e.length,n;return e[0]===`#`&&(t===4||t===5?n={r:255&ua[e[1]]*17,g:255&ua[e[2]]*17,b:255&ua[e[3]]*17,a:t===5?ua[e[4]]*17:255}:(t===7||t===9)&&(n={r:ua[e[1]]<<4|ua[e[2]],g:ua[e[3]]<<4|ua[e[4]],b:ua[e[5]]<<4|ua[e[6]],a:t===9?ua[e[7]]<<4|ua[e[8]]:255})),n}var _a=(e,t)=>e<255?t(e):``;function va(e){var t=ha(e)?fa:pa;return e?`#`+t(e.r)+t(e.g)+t(e.b)+_a(e.a,t):void 0}var ya=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function ba(e,t,n){let r=t*Math.min(n,1-n),i=(t,i=(t+e/30)%12)=>n-r*Math.max(Math.min(i-3,9-i,1),-1);return[i(0),i(8),i(4)]}function xa(e,t,n){let r=(r,i=(r+e/60)%6)=>n-n*t*Math.max(Math.min(i,4-i,1),0);return[r(5),r(3),r(1)]}function Sa(e,t,n){let r=ba(e,1,.5),i;for(t+n>1&&(i=1/(t+n),t*=i,n*=i),i=0;i<3;i++)r[i]*=1-t-n,r[i]+=t;return r}function Ca(e,t,n,r,i){return e===i?(t-n)/r+(t<n?6:0):t===i?(n-e)/r+2:(e-t)/r+4}function wa(e){let t=e.r/255,n=e.g/255,r=e.b/255,i=Math.max(t,n,r),a=Math.min(t,n,r),o=(i+a)/2,s,c,l;return i!==a&&(l=i-a,c=o>.5?l/(2-i-a):l/(i+a),s=Ca(t,n,r,l,i),s=s*60+.5),[s|0,c||0,o]}function Ta(e,t,n,r){return(Array.isArray(t)?e(t[0],t[1],t[2]):e(t,n,r)).map(sa)}function Ea(e,t,n){return Ta(ba,e,t,n)}function Da(e,t,n){return Ta(Sa,e,t,n)}function Oa(e,t,n){return Ta(xa,e,t,n)}function ka(e){return(e%360+360)%360}function Aa(e){let t=ya.exec(e),n=255,r;if(!t)return;t[5]!==r&&(n=t[6]?oa(+t[5]):sa(+t[5]));let i=ka(+t[2]),a=t[3]/100,o=t[4]/100;return r=t[1]===`hwb`?Da(i,a,o):t[1]===`hsv`?Oa(i,a,o):Ea(i,a,o),{r:r[0],g:r[1],b:r[2],a:n}}function ja(e,t){var n=wa(e);n[0]=ka(n[0]+t),n=Ea(n),e.r=n[0],e.g=n[1],e.b=n[2]}function Ma(e){if(!e)return;let t=wa(e),n=t[0],r=la(t[1]),i=la(t[2]);return e.a<255?`hsla(${n}, ${r}%, ${i}%, ${ca(e.a)})`:`hsl(${n}, ${r}%, ${i}%)`}var Na={x:`dark`,Z:`light`,Y:`re`,X:`blu`,W:`gr`,V:`medium`,U:`slate`,A:`ee`,T:`ol`,S:`or`,B:`ra`,C:`lateg`,D:`ights`,R:`in`,Q:`turquois`,E:`hi`,P:`ro`,O:`al`,N:`le`,M:`de`,L:`yello`,F:`en`,K:`ch`,G:`arks`,H:`ea`,I:`ightg`,J:`wh`},Pa={OiceXe:`f0f8ff`,antiquewEte:`faebd7`,aqua:`ffff`,aquamarRe:`7fffd4`,azuY:`f0ffff`,beige:`f5f5dc`,bisque:`ffe4c4`,black:`0`,blanKedOmond:`ffebcd`,Xe:`ff`,XeviTet:`8a2be2`,bPwn:`a52a2a`,burlywood:`deb887`,caMtXe:`5f9ea0`,KartYuse:`7fff00`,KocTate:`d2691e`,cSO:`ff7f50`,cSnflowerXe:`6495ed`,cSnsilk:`fff8dc`,crimson:`dc143c`,cyan:`ffff`,xXe:`8b`,xcyan:`8b8b`,xgTMnPd:`b8860b`,xWay:`a9a9a9`,xgYF:`6400`,xgYy:`a9a9a9`,xkhaki:`bdb76b`,xmagFta:`8b008b`,xTivegYF:`556b2f`,xSange:`ff8c00`,xScEd:`9932cc`,xYd:`8b0000`,xsOmon:`e9967a`,xsHgYF:`8fbc8f`,xUXe:`483d8b`,xUWay:`2f4f4f`,xUgYy:`2f4f4f`,xQe:`ced1`,xviTet:`9400d3`,dAppRk:`ff1493`,dApskyXe:`bfff`,dimWay:`696969`,dimgYy:`696969`,dodgerXe:`1e90ff`,fiYbrick:`b22222`,flSOwEte:`fffaf0`,foYstWAn:`228b22`,fuKsia:`ff00ff`,gaRsbSo:`dcdcdc`,ghostwEte:`f8f8ff`,gTd:`ffd700`,gTMnPd:`daa520`,Way:`808080`,gYF:`8000`,gYFLw:`adff2f`,gYy:`808080`,honeyMw:`f0fff0`,hotpRk:`ff69b4`,RdianYd:`cd5c5c`,Rdigo:`4b0082`,ivSy:`fffff0`,khaki:`f0e68c`,lavFMr:`e6e6fa`,lavFMrXsh:`fff0f5`,lawngYF:`7cfc00`,NmoncEffon:`fffacd`,ZXe:`add8e6`,ZcSO:`f08080`,Zcyan:`e0ffff`,ZgTMnPdLw:`fafad2`,ZWay:`d3d3d3`,ZgYF:`90ee90`,ZgYy:`d3d3d3`,ZpRk:`ffb6c1`,ZsOmon:`ffa07a`,ZsHgYF:`20b2aa`,ZskyXe:`87cefa`,ZUWay:`778899`,ZUgYy:`778899`,ZstAlXe:`b0c4de`,ZLw:`ffffe0`,lime:`ff00`,limegYF:`32cd32`,lRF:`faf0e6`,magFta:`ff00ff`,maPon:`800000`,VaquamarRe:`66cdaa`,VXe:`cd`,VScEd:`ba55d3`,VpurpN:`9370db`,VsHgYF:`3cb371`,VUXe:`7b68ee`,VsprRggYF:`fa9a`,VQe:`48d1cc`,VviTetYd:`c71585`,midnightXe:`191970`,mRtcYam:`f5fffa`,mistyPse:`ffe4e1`,moccasR:`ffe4b5`,navajowEte:`ffdead`,navy:`80`,Tdlace:`fdf5e6`,Tive:`808000`,TivedBb:`6b8e23`,Sange:`ffa500`,SangeYd:`ff4500`,ScEd:`da70d6`,pOegTMnPd:`eee8aa`,pOegYF:`98fb98`,pOeQe:`afeeee`,pOeviTetYd:`db7093`,papayawEp:`ffefd5`,pHKpuff:`ffdab9`,peru:`cd853f`,pRk:`ffc0cb`,plum:`dda0dd`,powMrXe:`b0e0e6`,purpN:`800080`,YbeccapurpN:`663399`,Yd:`ff0000`,Psybrown:`bc8f8f`,PyOXe:`4169e1`,saddNbPwn:`8b4513`,sOmon:`fa8072`,sandybPwn:`f4a460`,sHgYF:`2e8b57`,sHshell:`fff5ee`,siFna:`a0522d`,silver:`c0c0c0`,skyXe:`87ceeb`,UXe:`6a5acd`,UWay:`708090`,UgYy:`708090`,snow:`fffafa`,sprRggYF:`ff7f`,stAlXe:`4682b4`,tan:`d2b48c`,teO:`8080`,tEstN:`d8bfd8`,tomato:`ff6347`,Qe:`40e0d0`,viTet:`ee82ee`,JHt:`f5deb3`,wEte:`ffffff`,wEtesmoke:`f5f5f5`,Lw:`ffff00`,LwgYF:`9acd32`};function Fa(){let e={},t=Object.keys(Pa),n=Object.keys(Na),r,i,a,o,s;for(r=0;r<t.length;r++){for(o=s=t[r],i=0;i<n.length;i++)a=n[i],s=s.replace(a,Na[a]);a=parseInt(Pa[o],16),e[s]=[a>>16&255,a>>8&255,a&255]}return e}var Ia;function La(e){Ia||(Ia=Fa(),Ia.transparent=[0,0,0,0]);let t=Ia[e.toLowerCase()];return t&&{r:t[0],g:t[1],b:t[2],a:t.length===4?t[3]:255}}var Ra=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;function za(e){let t=Ra.exec(e),n=255,r,i,a;if(t){if(t[7]!==r){let e=+t[7];n=t[8]?oa(e):aa(e*255,0,255)}return r=+t[1],i=+t[3],a=+t[5],r=255&(t[2]?oa(r):aa(r,0,255)),i=255&(t[4]?oa(i):aa(i,0,255)),a=255&(t[6]?oa(a):aa(a,0,255)),{r,g:i,b:a,a:n}}}function Ba(e){return e&&(e.a<255?`rgba(${e.r}, ${e.g}, ${e.b}, ${ca(e.a)})`:`rgb(${e.r}, ${e.g}, ${e.b})`)}var Va=e=>e<=.0031308?e*12.92:e**(1/2.4)*1.055-.055,Ha=e=>e<=.04045?e/12.92:((e+.055)/1.055)**2.4;function Ua(e,t,n){let r=Ha(ca(e.r)),i=Ha(ca(e.g)),a=Ha(ca(e.b));return{r:sa(Va(r+n*(Ha(ca(t.r))-r))),g:sa(Va(i+n*(Ha(ca(t.g))-i))),b:sa(Va(a+n*(Ha(ca(t.b))-a))),a:e.a+n*(t.a-e.a)}}function Wa(e,t,n){if(e){let r=wa(e);r[t]=Math.max(0,Math.min(r[t]+r[t]*n,t===0?360:1)),r=Ea(r),e.r=r[0],e.g=r[1],e.b=r[2]}}function Ga(e,t){return e&&Object.assign(t||{},e)}function Ka(e){var t={r:0,g:0,b:0,a:255};return Array.isArray(e)?e.length>=3&&(t={r:e[0],g:e[1],b:e[2],a:255},e.length>3&&(t.a=sa(e[3]))):(t=Ga(e,{r:0,g:0,b:0,a:1}),t.a=sa(t.a)),t}function qa(e){return e.charAt(0)===`r`?za(e):Aa(e)}var Ja=class e{constructor(t){if(t instanceof e)return t;let n=typeof t,r;n===`object`?r=Ka(t):n===`string`&&(r=ga(t)||La(t)||qa(t)),this._rgb=r,this._valid=!!r}get valid(){return this._valid}get rgb(){var e=Ga(this._rgb);return e&&(e.a=ca(e.a)),e}set rgb(e){this._rgb=Ka(e)}rgbString(){return this._valid?Ba(this._rgb):void 0}hexString(){return this._valid?va(this._rgb):void 0}hslString(){return this._valid?Ma(this._rgb):void 0}mix(e,t){if(e){let n=this.rgb,r=e.rgb,i,a=t===i?.5:t,o=2*a-1,s=n.a-r.a,c=((o*s===-1?o:(o+s)/(1+o*s))+1)/2;i=1-c,n.r=255&c*n.r+i*r.r+.5,n.g=255&c*n.g+i*r.g+.5,n.b=255&c*n.b+i*r.b+.5,n.a=a*n.a+(1-a)*r.a,this.rgb=n}return this}interpolate(e,t){return e&&(this._rgb=Ua(this._rgb,e._rgb,t)),this}clone(){return new e(this.rgb)}alpha(e){return this._rgb.a=sa(e),this}clearer(e){let t=this._rgb;return t.a*=1-e,this}greyscale(){let e=this._rgb;return e.r=e.g=e.b=ia(e.r*.3+e.g*.59+e.b*.11),this}opaquer(e){let t=this._rgb;return t.a*=1+e,this}negate(){let e=this._rgb;return e.r=255-e.r,e.g=255-e.g,e.b=255-e.b,this}lighten(e){return Wa(this._rgb,2,e),this}darken(e){return Wa(this._rgb,2,-e),this}saturate(e){return Wa(this._rgb,1,e),this}desaturate(e){return Wa(this._rgb,1,-e),this}rotate(e){return ja(this._rgb,e),this}};function Ya(){}var Xa=(()=>{let e=0;return()=>e++})();function U(e){return e==null}function W(e){if(Array.isArray&&Array.isArray(e))return!0;let t=Object.prototype.toString.call(e);return t.slice(0,7)===`[object`&&t.slice(-6)===`Array]`}function G(e){return e!==null&&Object.prototype.toString.call(e)===`[object Object]`}function K(e){return(typeof e==`number`||e instanceof Number)&&isFinite(+e)}function Za(e,t){return K(e)?e:t}function q(e,t){return e===void 0?t:e}var Qa=(e,t)=>typeof e==`string`&&e.endsWith(`%`)?parseFloat(e)/100*t:+e;function J(e,t,n){if(e&&typeof e.call==`function`)return e.apply(n,t)}function Y(e,t,n,r){let i,a,o;if(W(e)){if(a=e.length,r)for(i=a-1;i>=0;i--)t.call(n,e[i],i);else for(i=0;i<a;i++)t.call(n,e[i],i)}else if(G(e))for(o=Object.keys(e),a=o.length,i=0;i<a;i++)t.call(n,e[o[i]],o[i])}function $a(e,t){let n,r,i,a;if(!e||!t||e.length!==t.length)return!1;for(n=0,r=e.length;n<r;++n)if(i=e[n],a=t[n],i.datasetIndex!==a.datasetIndex||i.index!==a.index)return!1;return!0}function eo(e){if(W(e))return e.map(eo);if(G(e)){let t=Object.create(null),n=Object.keys(e),r=n.length,i=0;for(;i<r;++i)t[n[i]]=eo(e[n[i]]);return t}return e}function to(e){return[`__proto__`,`prototype`,`constructor`].indexOf(e)===-1}function no(e,t,n,r){if(!to(e))return;let i=t[e],a=n[e];G(i)&&G(a)?ro(i,a,r):t[e]=eo(a)}function ro(e,t,n){let r=W(t)?t:[t],i=r.length;if(!G(e))return e;n||={};let a=n.merger||no,o;for(let t=0;t<i;++t){if(o=r[t],!G(o))continue;let i=Object.keys(o);for(let t=0,r=i.length;t<r;++t)a(i[t],e,o,n)}return e}function io(e,t){return ro(e,t,{merger:ao})}function ao(e,t,n){if(!to(e))return;let r=t[e],i=n[e];G(r)&&G(i)?io(r,i):Object.prototype.hasOwnProperty.call(t,e)||(t[e]=eo(i))}var oo={"":e=>e,x:e=>e.x,y:e=>e.y};function so(e){let t=e.split(`.`),n=[],r=``;for(let e of t)r+=e,r.endsWith(`\\`)?r=r.slice(0,-1)+`.`:(n.push(r),r=``);return n}function co(e){let t=so(e);return e=>{for(let n of t){if(n===``)break;e&&=e[n]}return e}}function lo(e,t){return(oo[t]||(oo[t]=co(t)))(e)}function uo(e){return e.charAt(0).toUpperCase()+e.slice(1)}var fo=e=>e!==void 0,po=e=>typeof e==`function`,mo=(e,t)=>{if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0};function ho(e){return e.type===`mouseup`||e.type===`click`||e.type===`contextmenu`}var X=Math.PI,go=2*X;go+X;var _o=1/0,vo=X/180,yo=X/2,bo=X/4,xo=X*2/3,So=Math.log10,Co=Math.sign;function wo(e,t,n){return Math.abs(e-t)<n}function To(e){let t=Math.round(e);e=wo(e,t,e/1e3)?t:e;let n=10**Math.floor(So(e)),r=e/n;return(r<=1?1:r<=2?2:r<=5?5:10)*n}function Eo(e){let t=[],n=Math.sqrt(e),r;for(r=1;r<n;r++)e%r===0&&(t.push(r),t.push(e/r));return n===(n|0)&&t.push(n),t.sort((e,t)=>e-t).pop(),t}function Do(e){return typeof e==`symbol`||typeof e==`object`&&!!e&&!(Symbol.toPrimitive in e||`toString`in e||`valueOf`in e)}function Oo(e){return!Do(e)&&!isNaN(parseFloat(e))&&isFinite(e)}function ko(e,t){let n=Math.round(e);return n-t<=e&&n+t>=e}function Ao(e,t,n){let r,i,a;for(r=0,i=e.length;r<i;r++)a=e[r][n],isNaN(a)||(t.min=Math.min(t.min,a),t.max=Math.max(t.max,a))}function jo(e){return X/180*e}function Mo(e){return 180/X*e}function No(e){if(!K(e))return;let t=1,n=0;for(;Math.round(e*t)/t!==e;)t*=10,n++;return n}function Po(e,t){let n=t.x-e.x,r=t.y-e.y,i=Math.sqrt(n*n+r*r),a=Math.atan2(r,n);return a<-.5*X&&(a+=go),{angle:a,distance:i}}function Fo(e,t){return Math.sqrt((t.x-e.x)**2+(t.y-e.y)**2)}function Io(e){return(e%go+go)%go}function Lo(e,t,n,r){let i=Io(e),a=Io(t),o=Io(n),s=Io(a-i),c=Io(o-i),l=Io(i-a),u=Io(i-o);return i===a||i===o||r&&a===o||s>c&&l<u}function Ro(e,t,n){return Math.max(t,Math.min(n,e))}function zo(e){return Ro(e,-32768,32767)}function Bo(e,t,n,r=1e-6){return e>=Math.min(t,n)-r&&e<=Math.max(t,n)+r}function Vo(e,t,n){n||=(n=>e[n]<t);let r=e.length-1,i=0,a;for(;r-i>1;)a=i+r>>1,n(a)?i=a:r=a;return{lo:i,hi:r}}var Ho=(e,t,n,r)=>Vo(e,n,r?r=>{let i=e[r][t];return i<n||i===n&&e[r+1][t]===n}:r=>e[r][t]<n),Uo=(e,t,n)=>Vo(e,n,r=>e[r][t]>=n);function Wo(e,t,n){let r=0,i=e.length;for(;r<i&&e[r]<t;)r++;for(;i>r&&e[i-1]>n;)i--;return r>0||i<e.length?e.slice(r,i):e}var Go=[`push`,`pop`,`shift`,`splice`,`unshift`];function Ko(e,t){if(e._chartjs){e._chartjs.listeners.push(t);return}Object.defineProperty(e,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[t]}}),Go.forEach(t=>{let n=`_onData`+uo(t),r=e[t];Object.defineProperty(e,t,{configurable:!0,enumerable:!1,value(...t){let i=r.apply(this,t);return e._chartjs.listeners.forEach(e=>{typeof e[n]==`function`&&e[n](...t)}),i}})})}function qo(e,t){let n=e._chartjs;if(!n)return;let r=n.listeners,i=r.indexOf(t);i!==-1&&r.splice(i,1),!(r.length>0)&&(Go.forEach(t=>{delete e[t]}),delete e._chartjs)}function Jo(e){let t=new Set(e);return t.size===e.length?e:Array.from(t)}var Yo=function(){return typeof window>`u`?function(e){return e()}:window.requestAnimationFrame}();function Xo(e,t){let n=[],r=!1;return function(...i){n=i,r||(r=!0,Yo.call(window,()=>{r=!1,e.apply(t,n)}))}}function Zo(e,t){let n;return function(...r){return t?(clearTimeout(n),n=setTimeout(e,t,r)):e.apply(this,r),t}}var Qo=e=>e===`start`?`left`:e===`end`?`right`:`center`,$o=(e,t,n)=>e===`start`?t:e===`end`?n:(t+n)/2,es=(e,t,n,r)=>e===(r?`left`:`right`)?n:e===`center`?(t+n)/2:t,ts=e=>e===0||e===1,ns=(e,t,n)=>-(2**(10*--e)*Math.sin((e-t)*go/n)),rs=(e,t,n)=>2**(-10*e)*Math.sin((e-t)*go/n)+1,is={linear:e=>e,easeInQuad:e=>e*e,easeOutQuad:e=>-e*(e-2),easeInOutQuad:e=>(e/=.5)<1?.5*e*e:-.5*(--e*(e-2)-1),easeInCubic:e=>e*e*e,easeOutCubic:e=>--e*e*e+1,easeInOutCubic:e=>(e/=.5)<1?.5*e*e*e:.5*((e-=2)*e*e+2),easeInQuart:e=>e*e*e*e,easeOutQuart:e=>-(--e*e*e*e-1),easeInOutQuart:e=>(e/=.5)<1?.5*e*e*e*e:-.5*((e-=2)*e*e*e-2),easeInQuint:e=>e*e*e*e*e,easeOutQuint:e=>--e*e*e*e*e+1,easeInOutQuint:e=>(e/=.5)<1?.5*e*e*e*e*e:.5*((e-=2)*e*e*e*e+2),easeInSine:e=>-Math.cos(e*yo)+1,easeOutSine:e=>Math.sin(e*yo),easeInOutSine:e=>-.5*(Math.cos(X*e)-1),easeInExpo:e=>e===0?0:2**(10*(e-1)),easeOutExpo:e=>e===1?1:-(2**(-10*e))+1,easeInOutExpo:e=>ts(e)?e:e<.5?.5*2**(10*(e*2-1)):.5*(-(2**(-10*(e*2-1)))+2),easeInCirc:e=>e>=1?e:-(Math.sqrt(1-e*e)-1),easeOutCirc:e=>Math.sqrt(1- --e*e),easeInOutCirc:e=>(e/=.5)<1?-.5*(Math.sqrt(1-e*e)-1):.5*(Math.sqrt(1-(e-=2)*e)+1),easeInElastic:e=>ts(e)?e:ns(e,.075,.3),easeOutElastic:e=>ts(e)?e:rs(e,.075,.3),easeInOutElastic(e){let t=.1125,n=.45;return ts(e)?e:e<.5?.5*ns(e*2,t,n):.5+.5*rs(e*2-1,t,n)},easeInBack(e){return e*e*(2.70158*e-1.70158)},easeOutBack(e){return--e*e*(2.70158*e+1.70158)+1},easeInOutBack(e){let t=1.70158;return(e/=.5)<1?.5*(e*e*(((t*=1.525)+1)*e-t)):.5*((e-=2)*e*(((t*=1.525)+1)*e+t)+2)},easeInBounce:e=>1-is.easeOutBounce(1-e),easeOutBounce(e){let t=7.5625,n=2.75;return e<1/n?t*e*e:e<2/n?t*(e-=1.5/n)*e+.75:e<2.5/n?t*(e-=2.25/n)*e+.9375:t*(e-=2.625/n)*e+.984375},easeInOutBounce:e=>e<.5?is.easeInBounce(e*2)*.5:is.easeOutBounce(e*2-1)*.5+.5};function as(e){if(e&&typeof e==`object`){let t=e.toString();return t===`[object CanvasPattern]`||t===`[object CanvasGradient]`}return!1}function os(e){return as(e)?e:new Ja(e)}function ss(e){return as(e)?e:new Ja(e).saturate(.5).darken(.1).hexString()}var cs=[`x`,`y`,`borderWidth`,`radius`,`tension`],ls=[`color`,`borderColor`,`backgroundColor`];function us(e){e.set(`animation`,{delay:void 0,duration:1e3,easing:`easeOutQuart`,fn:void 0,from:void 0,loop:void 0,to:void 0,type:void 0}),e.describe(`animation`,{_fallback:!1,_indexable:!1,_scriptable:e=>e!==`onProgress`&&e!==`onComplete`&&e!==`fn`}),e.set(`animations`,{colors:{type:`color`,properties:ls},numbers:{type:`number`,properties:cs}}),e.describe(`animations`,{_fallback:`animation`}),e.set(`transitions`,{active:{animation:{duration:400}},resize:{animation:{duration:0}},show:{animations:{colors:{from:`transparent`},visible:{type:`boolean`,duration:0}}},hide:{animations:{colors:{to:`transparent`},visible:{type:`boolean`,easing:`linear`,fn:e=>e|0}}}})}function ds(e){e.set(`layout`,{autoPadding:!0,padding:{top:0,right:0,bottom:0,left:0}})}var fs=new Map;function ps(e,t){t||={};let n=e+JSON.stringify(t),r=fs.get(n);return r||(r=new Intl.NumberFormat(e,t),fs.set(n,r)),r}function ms(e,t,n){return ps(t,n).format(e)}var hs={values(e){return W(e)?e:``+e},numeric(e,t,n){if(e===0)return`0`;let r=this.chart.options.locale,i,a=e;if(n.length>1){let t=Math.max(Math.abs(n[0].value),Math.abs(n[n.length-1].value));(t<1e-4||t>0x38d7ea4c68000)&&(i=`scientific`),a=gs(e,n)}let o=So(Math.abs(a)),s=isNaN(o)?1:Math.max(Math.min(-1*Math.floor(o),20),0),c={notation:i,minimumFractionDigits:s,maximumFractionDigits:s};return Object.assign(c,this.options.ticks.format),ms(e,r,c)},logarithmic(e,t,n){if(e===0)return`0`;let r=n[t].significand||e/10**Math.floor(So(e));return[1,2,3,5,10,15].includes(r)||t>.8*n.length?hs.numeric.call(this,e,t,n):``}};function gs(e,t){let n=t.length>3?t[2].value-t[1].value:t[1].value-t[0].value;return Math.abs(n)>=1&&e!==Math.floor(e)&&(n=e-Math.floor(e)),n}var _s={formatters:hs};function vs(e){e.set(`scale`,{display:!0,offset:!1,reverse:!1,beginAtZero:!1,bounds:`ticks`,clip:!0,grace:0,grid:{display:!0,lineWidth:1,drawOnChartArea:!0,drawTicks:!0,tickLength:8,tickWidth:(e,t)=>t.lineWidth,tickColor:(e,t)=>t.color,offset:!1},border:{display:!0,dash:[],dashOffset:0,width:1},title:{display:!1,text:``,padding:{top:4,bottom:4}},ticks:{minRotation:0,maxRotation:50,mirror:!1,textStrokeWidth:0,textStrokeColor:``,padding:3,display:!0,autoSkip:!0,autoSkipPadding:3,labelOffset:0,callback:_s.formatters.values,minor:{},major:{},align:`center`,crossAlign:`near`,showLabelBackdrop:!1,backdropColor:`rgba(255, 255, 255, 0.75)`,backdropPadding:2}}),e.route(`scale.ticks`,`color`,``,`color`),e.route(`scale.grid`,`color`,``,`borderColor`),e.route(`scale.border`,`color`,``,`borderColor`),e.route(`scale.title`,`color`,``,`color`),e.describe(`scale`,{_fallback:!1,_scriptable:e=>!e.startsWith(`before`)&&!e.startsWith(`after`)&&e!==`callback`&&e!==`parser`,_indexable:e=>e!==`borderDash`&&e!==`tickBorderDash`&&e!==`dash`}),e.describe(`scales`,{_fallback:`scale`}),e.describe(`scale.ticks`,{_scriptable:e=>e!==`backdropPadding`&&e!==`callback`,_indexable:e=>e!==`backdropPadding`})}var ys=Object.create(null),bs=Object.create(null);function xs(e,t){if(!t)return e;let n=t.split(`.`);for(let t=0,r=n.length;t<r;++t){let r=n[t];e=e[r]||(e[r]=Object.create(null))}return e}function Ss(e,t,n){return typeof t==`string`?ro(xs(e,t),n):ro(xs(e,``),t)}var Z=new class{constructor(e,t){this.animation=void 0,this.backgroundColor=`rgba(0,0,0,0.1)`,this.borderColor=`rgba(0,0,0,0.1)`,this.color=`#666`,this.datasets={},this.devicePixelRatio=e=>e.chart.platform.getDevicePixelRatio(),this.elements={},this.events=[`mousemove`,`mouseout`,`click`,`touchstart`,`touchmove`],this.font={family:`'Helvetica Neue', 'Helvetica', 'Arial', sans-serif`,size:12,style:`normal`,lineHeight:1.2,weight:null},this.hover={},this.hoverBackgroundColor=(e,t)=>ss(t.backgroundColor),this.hoverBorderColor=(e,t)=>ss(t.borderColor),this.hoverColor=(e,t)=>ss(t.color),this.indexAxis=`x`,this.interaction={mode:`nearest`,intersect:!0,includeInvisible:!1},this.maintainAspectRatio=!0,this.onHover=null,this.onClick=null,this.parsing=!0,this.plugins={},this.responsive=!0,this.scale=void 0,this.scales={},this.showLine=!0,this.drawActiveElementsOnTop=!0,this.describe(e),this.apply(t)}set(e,t){return Ss(this,e,t)}get(e){return xs(this,e)}describe(e,t){return Ss(bs,e,t)}override(e,t){return Ss(ys,e,t)}route(e,t,n,r){let i=xs(this,e),a=xs(this,n),o=`_`+t;Object.defineProperties(i,{[o]:{value:i[t],writable:!0},[t]:{enumerable:!0,get(){let e=this[o],t=a[r];return G(e)?Object.assign({},t,e):q(e,t)},set(e){this[o]=e}}})}apply(e){e.forEach(e=>e(this))}}({_scriptable:e=>!e.startsWith(`on`),_indexable:e=>e!==`events`,hover:{_fallback:`interaction`},interaction:{_scriptable:!1,_indexable:!1}},[us,ds,vs]);function Cs(e){return!e||U(e.size)||U(e.family)?null:(e.style?e.style+` `:``)+(e.weight?e.weight+` `:``)+e.size+`px `+e.family}function ws(e,t,n,r,i){let a=t[i];return a||(a=t[i]=e.measureText(i).width,n.push(i)),a>r&&(r=a),r}function Ts(e,t,n,r){r||={};let i=r.data=r.data||{},a=r.garbageCollect=r.garbageCollect||[];r.font!==t&&(i=r.data={},a=r.garbageCollect=[],r.font=t),e.save(),e.font=t;let o=0,s=n.length,c,l,u,d,f;for(c=0;c<s;c++)if(d=n[c],d!=null&&!W(d))o=ws(e,i,a,o,d);else if(W(d))for(l=0,u=d.length;l<u;l++)f=d[l],f!=null&&!W(f)&&(o=ws(e,i,a,o,f));e.restore();let p=a.length/2;if(p>n.length){for(c=0;c<p;c++)delete i[a[c]];a.splice(0,p)}return o}function Es(e,t,n){let r=e.currentDevicePixelRatio,i=n===0?0:Math.max(n/2,.5);return Math.round((t-i)*r)/r+i}function Ds(e,t){!t&&!e||(t||=e.getContext(`2d`),t.save(),t.resetTransform(),t.clearRect(0,0,e.width,e.height),t.restore())}function Os(e,t,n,r){ks(e,t,n,r,null)}function ks(e,t,n,r,i){let a,o,s,c,l,u,d,f,p=t.pointStyle,m=t.rotation,h=t.radius,g=(m||0)*vo;if(p&&typeof p==`object`&&(a=p.toString(),a===`[object HTMLImageElement]`||a===`[object HTMLCanvasElement]`)){e.save(),e.translate(n,r),e.rotate(g),e.drawImage(p,-p.width/2,-p.height/2,p.width,p.height),e.restore();return}if(!(isNaN(h)||h<=0)){switch(e.beginPath(),p){default:i?e.ellipse(n,r,i/2,h,0,0,go):e.arc(n,r,h,0,go),e.closePath();break;case`triangle`:u=i?i/2:h,e.moveTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=xo,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=xo,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),e.closePath();break;case`rectRounded`:l=h*.516,c=h-l,o=Math.cos(g+bo)*c,d=Math.cos(g+bo)*(i?i/2-l:c),s=Math.sin(g+bo)*c,f=Math.sin(g+bo)*(i?i/2-l:c),e.arc(n-d,r-s,l,g-X,g-yo),e.arc(n+f,r-o,l,g-yo,g),e.arc(n+d,r+s,l,g,g+yo),e.arc(n-f,r+o,l,g+yo,g+X),e.closePath();break;case`rect`:if(!m){c=Math.SQRT1_2*h,u=i?i/2:c,e.rect(n-u,r-c,2*u,2*c);break}g+=bo;case`rectRot`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+f,r-o),e.lineTo(n+d,r+s),e.lineTo(n-f,r+o),e.closePath();break;case`crossRot`:g+=bo;case`cross`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o);break;case`star`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o),g+=bo,d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o);break;case`line`:o=i?i/2:Math.cos(g)*h,s=Math.sin(g)*h,e.moveTo(n-o,r-s),e.lineTo(n+o,r+s);break;case`dash`:e.moveTo(n,r),e.lineTo(n+Math.cos(g)*(i?i/2:h),r+Math.sin(g)*h);break;case!1:e.closePath()}e.fill(),t.borderWidth>0&&e.stroke()}}function As(e,t,n){return n||=.5,!t||e&&e.x>t.left-n&&e.x<t.right+n&&e.y>t.top-n&&e.y<t.bottom+n}function js(e,t){e.save(),e.beginPath(),e.rect(t.left,t.top,t.right-t.left,t.bottom-t.top),e.clip()}function Ms(e){e.restore()}function Ns(e,t){t.translation&&e.translate(t.translation[0],t.translation[1]),U(t.rotation)||e.rotate(t.rotation),t.color&&(e.fillStyle=t.color),t.textAlign&&(e.textAlign=t.textAlign),t.textBaseline&&(e.textBaseline=t.textBaseline)}function Ps(e,t,n,r,i){if(i.strikethrough||i.underline){let a=e.measureText(r),o=t-a.actualBoundingBoxLeft,s=t+a.actualBoundingBoxRight,c=n-a.actualBoundingBoxAscent,l=n+a.actualBoundingBoxDescent,u=i.strikethrough?(c+l)/2:l;e.strokeStyle=e.fillStyle,e.beginPath(),e.lineWidth=i.decorationWidth||2,e.moveTo(o,u),e.lineTo(s,u),e.stroke()}}function Fs(e,t){let n=e.fillStyle;e.fillStyle=t.color,e.fillRect(t.left,t.top,t.width,t.height),e.fillStyle=n}function Is(e,t,n,r,i,a={}){let o=W(t)?t:[t],s=a.strokeWidth>0&&a.strokeColor!==``,c,l;for(e.save(),e.font=i.string,Ns(e,a),c=0;c<o.length;++c)l=o[c],a.backdrop&&Fs(e,a.backdrop),s&&(a.strokeColor&&(e.strokeStyle=a.strokeColor),U(a.strokeWidth)||(e.lineWidth=a.strokeWidth),e.strokeText(l,n,r,a.maxWidth)),e.fillText(l,n,r,a.maxWidth),Ps(e,n,r,l,a),r+=Number(i.lineHeight);e.restore()}function Ls(e,t){let{x:n,y:r,w:i,h:a,radius:o}=t;e.arc(n+o.topLeft,r+o.topLeft,o.topLeft,1.5*X,X,!0),e.lineTo(n,r+a-o.bottomLeft),e.arc(n+o.bottomLeft,r+a-o.bottomLeft,o.bottomLeft,X,yo,!0),e.lineTo(n+i-o.bottomRight,r+a),e.arc(n+i-o.bottomRight,r+a-o.bottomRight,o.bottomRight,yo,0,!0),e.lineTo(n+i,r+o.topRight),e.arc(n+i-o.topRight,r+o.topRight,o.topRight,0,-yo,!0),e.lineTo(n+o.topLeft,r)}var Rs=/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/,zs=/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;function Bs(e,t){let n=(``+e).match(Rs);if(!n||n[1]===`normal`)return t*1.2;switch(e=+n[2],n[3]){case`px`:return e;case`%`:e/=100}return t*e}var Vs=e=>+e||0;function Hs(e,t){let n={},r=G(t),i=r?Object.keys(t):t,a=G(e)?r?n=>q(e[n],e[t[n]]):t=>e[t]:()=>e;for(let e of i)n[e]=Vs(a(e));return n}function Us(e){return Hs(e,{top:`y`,right:`x`,bottom:`y`,left:`x`})}function Ws(e){return Hs(e,[`topLeft`,`topRight`,`bottomLeft`,`bottomRight`])}function Q(e){let t=Us(e);return t.width=t.left+t.right,t.height=t.top+t.bottom,t}function $(e,t){e||={},t||=Z.font;let n=q(e.size,t.size);typeof n==`string`&&(n=parseInt(n,10));let r=q(e.style,t.style);r&&!(``+r).match(zs)&&(console.warn(`Invalid font style specified: "`+r+`"`),r=void 0);let i={family:q(e.family,t.family),lineHeight:Bs(q(e.lineHeight,t.lineHeight),n),size:n,style:r,weight:q(e.weight,t.weight),string:``};return i.string=Cs(i),i}function Gs(e,t,n,r){let i=!0,a,o,s;for(a=0,o=e.length;a<o;++a)if(s=e[a],s!==void 0&&(t!==void 0&&typeof s==`function`&&(s=s(t),i=!1),n!==void 0&&W(s)&&(s=s[n%s.length],i=!1),s!==void 0))return r&&!i&&(r.cacheable=!1),s}function Ks(e,t,n){let{min:r,max:i}=e,a=Qa(t,(i-r)/2),o=(e,t)=>n&&e===0?0:e+t;return{min:o(r,-Math.abs(a)),max:o(i,a)}}function qs(e,t){return Object.assign(Object.create(e),t)}function Js(e,t=[``],n,r,i=()=>e[0]){let a=n||e;return r===void 0&&(r=uc(`_fallback`,e)),new Proxy({[Symbol.toStringTag]:`Object`,_cacheable:!0,_scopes:e,_rootScopes:a,_fallback:r,_getTarget:i,override:n=>Js([n,...e],t,a,r)},{deleteProperty(t,n){return delete t[n],delete t._keys,delete e[0][n],!0},get(n,r){return $s(n,r,()=>lc(r,t,e,n))},getOwnPropertyDescriptor(e,t){return Reflect.getOwnPropertyDescriptor(e._scopes[0],t)},getPrototypeOf(){return Reflect.getPrototypeOf(e[0])},has(e,t){return dc(e).includes(t)},ownKeys(e){return dc(e)},set(e,t,n){let r=e._storage||=i();return e[t]=r[t]=n,delete e._keys,!0}})}function Ys(e,t,n,r){let i={_cacheable:!1,_proxy:e,_context:t,_subProxy:n,_stack:new Set,_descriptors:Xs(e,r),setContext:t=>Ys(e,t,n,r),override:i=>Ys(e.override(i),t,n,r)};return new Proxy(i,{deleteProperty(t,n){return delete t[n],delete e[n],!0},get(e,t,n){return $s(e,t,()=>ec(e,t,n))},getOwnPropertyDescriptor(t,n){return t._descriptors.allKeys?Reflect.has(e,n)?{enumerable:!0,configurable:!0}:void 0:Reflect.getOwnPropertyDescriptor(e,n)},getPrototypeOf(){return Reflect.getPrototypeOf(e)},has(t,n){return Reflect.has(e,n)},ownKeys(){return Reflect.ownKeys(e)},set(t,n,r){return e[n]=r,delete t[n],!0}})}function Xs(e,t={scriptable:!0,indexable:!0}){let{_scriptable:n=t.scriptable,_indexable:r=t.indexable,_allKeys:i=t.allKeys}=e;return{allKeys:i,scriptable:n,indexable:r,isScriptable:po(n)?n:()=>n,isIndexable:po(r)?r:()=>r}}var Zs=(e,t)=>e?e+uo(t):t,Qs=(e,t)=>G(t)&&e!==`adapters`&&(Object.getPrototypeOf(t)===null||t.constructor===Object);function $s(e,t,n){if(Object.prototype.hasOwnProperty.call(e,t)||t===`constructor`)return e[t];let r=n();return e[t]=r,r}function ec(e,t,n){let{_proxy:r,_context:i,_subProxy:a,_descriptors:o}=e,s=r[t];return po(s)&&o.isScriptable(t)&&(s=tc(t,s,e,n)),W(s)&&s.length&&(s=nc(t,s,e,o.isIndexable)),Qs(t,s)&&(s=Ys(s,i,a&&a[t],o)),s}function tc(e,t,n,r){let{_proxy:i,_context:a,_subProxy:o,_stack:s}=n;if(s.has(e))throw Error(`Recursion detected: `+Array.from(s).join(`->`)+`->`+e);s.add(e);let c=t(a,o||r);return s.delete(e),Qs(e,c)&&(c=oc(i._scopes,i,e,c)),c}function nc(e,t,n,r){let{_proxy:i,_context:a,_subProxy:o,_descriptors:s}=n;if(a.index!==void 0&&r(e))return t[a.index%t.length];if(G(t[0])){let n=t,r=i._scopes.filter(e=>e!==n);t=[];for(let c of n){let n=oc(r,i,e,c);t.push(Ys(n,a,o&&o[e],s))}}return t}function rc(e,t,n){return po(e)?e(t,n):e}var ic=(e,t)=>e===!0?t:typeof e==`string`?lo(t,e):void 0;function ac(e,t,n,r,i){for(let a of t){let t=ic(n,a);if(t){e.add(t);let a=rc(t._fallback,n,i);if(a!==void 0&&a!==n&&a!==r)return a}else if(t===!1&&r!==void 0&&n!==r)return null}return!1}function oc(e,t,n,r){let i=t._rootScopes,a=rc(t._fallback,n,r),o=[...e,...i],s=new Set;s.add(r);let c=sc(s,o,n,a||n,r);return c===null||a!==void 0&&a!==n&&(c=sc(s,o,a,c,r),c===null)?!1:Js(Array.from(s),[``],i,a,()=>cc(t,n,r))}function sc(e,t,n,r,i){for(;n;)n=ac(e,t,n,r,i);return n}function cc(e,t,n){let r=e._getTarget();t in r||(r[t]={});let i=r[t];return W(i)&&G(n)?n:i||{}}function lc(e,t,n,r){let i;for(let a of t)if(i=uc(Zs(a,e),n),i!==void 0)return Qs(e,i)?oc(n,r,e,i):i}function uc(e,t){for(let n of t){if(!n)continue;let t=n[e];if(t!==void 0)return t}}function dc(e){let t=e._keys;return t||=e._keys=fc(e._scopes),t}function fc(e){let t=new Set;for(let n of e)for(let e of Object.keys(n).filter(e=>!e.startsWith(`_`)))t.add(e);return Array.from(t)}function pc(){return typeof window<`u`&&typeof document<`u`}function mc(e){let t=e.parentNode;return t&&t.toString()===`[object ShadowRoot]`&&(t=t.host),t}function hc(e,t,n){let r;return typeof e==`string`?(r=parseInt(e,10),e.indexOf(`%`)!==-1&&(r=r/100*t.parentNode[n])):r=e,r}var gc=e=>e.ownerDocument.defaultView.getComputedStyle(e,null);function _c(e,t){return gc(e).getPropertyValue(t)}var vc=[`top`,`right`,`bottom`,`left`];function yc(e,t,n){let r={};n=n?`-`+n:``;for(let i=0;i<4;i++){let a=vc[i];r[a]=parseFloat(e[t+`-`+a+n])||0}return r.width=r.left+r.right,r.height=r.top+r.bottom,r}var bc=(e,t,n)=>(e>0||t>0)&&(!n||!n.shadowRoot);function xc(e,t){let n=e.touches,r=n&&n.length?n[0]:e,{offsetX:i,offsetY:a}=r,o=!1,s,c;if(bc(i,a,e.target))s=i,c=a;else{let e=t.getBoundingClientRect();s=r.clientX-e.left,c=r.clientY-e.top,o=!0}return{x:s,y:c,box:o}}function Sc(e,t){if(`native`in e)return e;let{canvas:n,currentDevicePixelRatio:r}=t,i=gc(n),a=i.boxSizing===`border-box`,o=yc(i,`padding`),s=yc(i,`border`,`width`),{x:c,y:l,box:u}=xc(e,n),d=o.left+(u&&s.left),f=o.top+(u&&s.top),{width:p,height:m}=t;return a&&(p-=o.width+s.width,m-=o.height+s.height),{x:Math.round((c-d)/p*n.width/r),y:Math.round((l-f)/m*n.height/r)}}function Cc(e,t,n){let r,i;if(t===void 0||n===void 0){let a=e&&mc(e);if(!a)t=e.clientWidth,n=e.clientHeight;else{let e=a.getBoundingClientRect(),o=gc(a),s=yc(o,`border`,`width`),c=yc(o,`padding`);t=e.width-c.width-s.width,n=e.height-c.height-s.height,r=hc(o.maxWidth,a,`clientWidth`),i=hc(o.maxHeight,a,`clientHeight`)}}return{width:t,height:n,maxWidth:r||_o,maxHeight:i||_o}}var wc=e=>Math.round(e*10)/10;function Tc(e,t,n,r){let i=gc(e),a=yc(i,`margin`),o=hc(i.maxWidth,e,`clientWidth`)||_o,s=hc(i.maxHeight,e,`clientHeight`)||_o,c=Cc(e,t,n),{width:l,height:u}=c;if(i.boxSizing===`content-box`){let e=yc(i,`border`,`width`),t=yc(i,`padding`);l-=t.width+e.width,u-=t.height+e.height}return l=Math.max(0,l-a.width),u=Math.max(0,r?l/r:u-a.height),l=wc(Math.min(l,o,c.maxWidth)),u=wc(Math.min(u,s,c.maxHeight)),l&&!u&&(u=wc(l/2)),(t!==void 0||n!==void 0)&&r&&c.height&&u>c.height&&(u=c.height,l=wc(Math.floor(u*r))),{width:l,height:u}}function Ec(e,t,n){let r=t||1,i=wc(e.height*r),a=wc(e.width*r);e.height=wc(e.height),e.width=wc(e.width);let o=e.canvas;return o.style&&(n||!o.style.height&&!o.style.width)&&(o.style.height=`${e.height}px`,o.style.width=`${e.width}px`),e.currentDevicePixelRatio!==r||o.height!==i||o.width!==a?(e.currentDevicePixelRatio=r,o.height=i,o.width=a,e.ctx.setTransform(r,0,0,r,0,0),!0):!1}var Dc=function(){let e=!1;try{let t={get passive(){return e=!0,!1}};pc()&&(window.addEventListener(`test`,null,t),window.removeEventListener(`test`,null,t))}catch{}return e}();function Oc(e,t){let n=_c(e,t),r=n&&n.match(/^(\d+)(\.\d+)?px$/);return r?+r[1]:void 0}var kc=function(e,t){return{x(n){return e+e+t-n},setWidth(e){t=e},textAlign(e){return e===`center`?e:e===`right`?`left`:`right`},xPlus(e,t){return e-t},leftForLtr(e,t){return e-t}}},Ac=function(){return{x(e){return e},setWidth(e){},textAlign(e){return e},xPlus(e,t){return e+t},leftForLtr(e,t){return e}}};function jc(e,t,n){return e?kc(t,n):Ac()}function Mc(e,t){let n,r;(t===`ltr`||t===`rtl`)&&(n=e.canvas.style,r=[n.getPropertyValue(`direction`),n.getPropertyPriority(`direction`)],n.setProperty(`direction`,t,`important`),e.prevTextDirection=r)}function Nc(e,t){t!==void 0&&(delete e.prevTextDirection,e.canvas.style.setProperty(`direction`,t[0],t[1]))}function Pc(e,t,n){return e.options.clip?e[n]:t[n]}function Fc(e,t){let{xScale:n,yScale:r}=e;return n&&r?{left:Pc(n,t,`left`),right:Pc(n,t,`right`),top:Pc(r,t,`top`),bottom:Pc(r,t,`bottom`)}:t}function Ic(e,t){let n=t._clip;if(n.disabled)return!1;let r=Fc(t,e.chartArea);return{left:n.left===!1?0:r.left-(n.left===!0?0:n.left),right:n.right===!1?e.width:r.right+(n.right===!0?0:n.right),top:n.top===!1?0:r.top-(n.top===!0?0:n.top),bottom:n.bottom===!1?e.height:r.bottom+(n.bottom===!0?0:n.bottom)}}var Lc=new class{constructor(){this._request=null,this._charts=new Map,this._running=!1,this._lastDate=void 0}_notify(e,t,n,r){let i=t.listeners[r],a=t.duration;i.forEach(r=>r({chart:e,initial:t.initial,numSteps:a,currentStep:Math.min(n-t.start,a)}))}_refresh(){this._request||=(this._running=!0,Yo.call(window,()=>{this._update(),this._request=null,this._running&&this._refresh()}))}_update(e=Date.now()){let t=0;this._charts.forEach((n,r)=>{if(!n.running||!n.items.length)return;let i=n.items,a=i.length-1,o=!1,s;for(;a>=0;--a)s=i[a],s._active?(s._total>n.duration&&(n.duration=s._total),s.tick(e),o=!0):(i[a]=i[i.length-1],i.pop());o&&(r.draw(),this._notify(r,n,e,`progress`)),i.length||(n.running=!1,this._notify(r,n,e,`complete`),n.initial=!1),t+=i.length}),this._lastDate=e,t===0&&(this._running=!1)}_getAnims(e){let t=this._charts,n=t.get(e);return n||(n={running:!1,initial:!0,items:[],listeners:{complete:[],progress:[]}},t.set(e,n)),n}listen(e,t,n){this._getAnims(e).listeners[t].push(n)}add(e,t){!t||!t.length||this._getAnims(e).items.push(...t)}has(e){return this._getAnims(e).items.length>0}start(e){let t=this._charts.get(e);t&&(t.running=!0,t.start=Date.now(),t.duration=t.items.reduce((e,t)=>Math.max(e,t._duration),0),this._refresh())}running(e){if(!this._running)return!1;let t=this._charts.get(e);return!(!t||!t.running||!t.items.length)}stop(e){let t=this._charts.get(e);if(!t||!t.items.length)return;let n=t.items,r=n.length-1;for(;r>=0;--r)n[r].cancel();t.items=[],this._notify(e,t,Date.now(),`complete`)}remove(e){return this._charts.delete(e)}},Rc=`transparent`,zc={boolean(e,t,n){return n>.5?t:e},color(e,t,n){let r=os(e||Rc),i=r.valid&&os(t||Rc);return i&&i.valid?i.mix(r,n).hexString():t},number(e,t,n){return e+(t-e)*n}},Bc=class{constructor(e,t,n,r){let i=t[n];r=Gs([e.to,r,i,e.from]);let a=Gs([e.from,i,r]);this._active=!0,this._fn=e.fn||zc[e.type||typeof a],this._easing=is[e.easing]||is.linear,this._start=Math.floor(Date.now()+(e.delay||0)),this._duration=this._total=Math.floor(e.duration),this._loop=!!e.loop,this._target=t,this._prop=n,this._from=a,this._to=r,this._promises=void 0}active(){return this._active}update(e,t,n){if(this._active){this._notify(!1);let r=this._target[this._prop],i=n-this._start,a=this._duration-i;this._start=n,this._duration=Math.floor(Math.max(a,e.duration)),this._total+=i,this._loop=!!e.loop,this._to=Gs([e.to,t,r,e.from]),this._from=Gs([e.from,r,t])}}cancel(){this._active&&(this.tick(Date.now()),this._active=!1,this._notify(!1))}tick(e){let t=e-this._start,n=this._duration,r=this._prop,i=this._from,a=this._loop,o=this._to,s;if(this._active=i!==o&&(a||t<n),!this._active){this._target[r]=o,this._notify(!0);return}if(t<0){this._target[r]=i;return}s=t/n%2,s=a&&s>1?2-s:s,s=this._easing(Math.min(1,Math.max(0,s))),this._target[r]=this._fn(i,o,s)}wait(){let e=this._promises||=[];return new Promise((t,n)=>{e.push({res:t,rej:n})})}_notify(e){let t=e?`res`:`rej`,n=this._promises||[];for(let e=0;e<n.length;e++)n[e][t]()}},Vc=class{constructor(e,t){this._chart=e,this._properties=new Map,this.configure(t)}configure(e){if(!G(e))return;let t=Object.keys(Z.animation),n=this._properties;Object.getOwnPropertyNames(e).forEach(r=>{let i=e[r];if(!G(i))return;let a={};for(let e of t)a[e]=i[e];(W(i.properties)&&i.properties||[r]).forEach(e=>{(e===r||!n.has(e))&&n.set(e,a)})})}_animateOptions(e,t){let n=t.options,r=Uc(e,n);if(!r)return[];let i=this._createAnimations(r,n);return n.$shared&&Hc(e.options.$animations,n).then(()=>{e.options=n},()=>{}),i}_createAnimations(e,t){let n=this._properties,r=[],i=e.$animations||={},a=Object.keys(t),o=Date.now(),s;for(s=a.length-1;s>=0;--s){let c=a[s];if(c.charAt(0)===`$`)continue;if(c===`options`){r.push(...this._animateOptions(e,t));continue}let l=t[c],u=i[c],d=n.get(c);if(u){if(d&&u.active()){u.update(d,l,o);continue}u.cancel()}if(!d||!d.duration){e[c]=l;continue}i[c]=u=new Bc(d,e,c,l),r.push(u)}return r}update(e,t){if(this._properties.size===0){Object.assign(e,t);return}let n=this._createAnimations(e,t);if(n.length)return Lc.add(this._chart,n),!0}};function Hc(e,t){let n=[],r=Object.keys(t);for(let t=0;t<r.length;t++){let i=e[r[t]];i&&i.active()&&n.push(i.wait())}return Promise.all(n)}function Uc(e,t){if(!t)return;let n=e.options;if(!n){e.options=t;return}return n.$shared&&(e.options=n=Object.assign({},n,{$shared:!1,$animations:{}})),n}function Wc(e,t){let n=e&&e.options||{},r=n.reverse,i=n.min===void 0?t:0,a=n.max===void 0?t:0;return{start:r?a:i,end:r?i:a}}function Gc(e,t,n){if(n===!1)return!1;let r=Wc(e,n),i=Wc(t,n);return{top:i.end,right:r.end,bottom:i.start,left:r.start}}function Kc(e){let t,n,r,i;return G(e)?(t=e.top,n=e.right,r=e.bottom,i=e.left):t=n=r=i=e,{top:t,right:n,bottom:r,left:i,disabled:e===!1}}function qc(e,t){let n=[],r=e._getSortedDatasetMetas(t),i,a;for(i=0,a=r.length;i<a;++i)n.push(r[i].index);return n}function Jc(e,t,n,r={}){let i=e.keys,a=r.mode===`single`,o,s,c,l;if(t===null)return;let u=!1;for(o=0,s=i.length;o<s;++o){if(c=+i[o],c===n){if(u=!0,r.all)continue;break}l=e.values[c],K(l)&&(a||t===0||Co(t)===Co(l))&&(t+=l)}return!u&&!r.all?0:t}function Yc(e,t){let{iScale:n,vScale:r}=t,i=n.axis===`x`?`x`:`y`,a=r.axis===`x`?`x`:`y`,o=Object.keys(e),s=Array(o.length),c,l,u;for(c=0,l=o.length;c<l;++c)u=o[c],s[c]={[i]:u,[a]:e[u]};return s}function Xc(e,t){let n=e&&e.options.stacked;return n||n===void 0&&t.stack!==void 0}function Zc(e,t,n){return`${e.id}.${t.id}.${n.stack||n.type}`}function Qc(e){let{min:t,max:n,minDefined:r,maxDefined:i}=e.getUserBounds();return{min:r?t:-1/0,max:i?n:1/0}}function $c(e,t,n){let r=e[t]||(e[t]={});return r[n]||(r[n]={})}function el(e,t,n,r){for(let i of t.getMatchingVisibleMetas(r).reverse()){let t=e[i.index];if(n&&t>0||!n&&t<0)return i.index}return null}function tl(e,t){let{chart:n,_cachedMeta:r}=e,i=n._stacks||={},{iScale:a,vScale:o,index:s}=r,c=a.axis,l=o.axis,u=Zc(a,o,r),d=t.length,f;for(let e=0;e<d;++e){let n=t[e],{[c]:a,[l]:d}=n,p=n._stacks||={};f=p[l]=$c(i,u,a),f[s]=d,f._top=el(f,o,!0,r.type),f._bottom=el(f,o,!1,r.type);let m=f._visualValues||(f._visualValues={});m[s]=d}}function nl(e,t){let n=e.scales;return Object.keys(n).filter(e=>n[e].axis===t).shift()}function rl(e,t){return qs(e,{active:!1,dataset:void 0,datasetIndex:t,index:t,mode:`default`,type:`dataset`})}function il(e,t,n){return qs(e,{active:!1,dataIndex:t,parsed:void 0,raw:void 0,element:n,index:t,mode:`default`,type:`data`})}function al(e,t){let n=e.controller.index,r=e.vScale&&e.vScale.axis;if(r){t||=e._parsed;for(let e of t){let t=e._stacks;if(!t||t[r]===void 0||t[r][n]===void 0)return;delete t[r][n],t[r]._visualValues!==void 0&&t[r]._visualValues[n]!==void 0&&delete t[r]._visualValues[n]}}}var ol=e=>e===`reset`||e===`none`,sl=(e,t)=>t?e:Object.assign({},e),cl=(e,t,n)=>e&&!t.hidden&&t._stacked&&{keys:qc(n,!0),values:null},ll=class{static defaults={};static datasetElementType=null;static dataElementType=null;constructor(e,t){this.chart=e,this._ctx=e.ctx,this.index=t,this._cachedDataOpts={},this._cachedMeta=this.getMeta(),this._type=this._cachedMeta.type,this.options=void 0,this._parsing=!1,this._data=void 0,this._objectData=void 0,this._sharedOptions=void 0,this._drawStart=void 0,this._drawCount=void 0,this.enableOptionSharing=!1,this.supportsDecimation=!1,this.$context=void 0,this._syncList=[],this.datasetElementType=new.target.datasetElementType,this.dataElementType=new.target.dataElementType,this.initialize()}initialize(){let e=this._cachedMeta;this.configure(),this.linkScales(),e._stacked=Xc(e.vScale,e),this.addElements(),this.options.fill&&!this.chart.isPluginEnabled(`filler`)&&console.warn(`Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options`)}updateIndex(e){this.index!==e&&al(this._cachedMeta),this.index=e}linkScales(){let e=this.chart,t=this._cachedMeta,n=this.getDataset(),r=(e,t,n,r)=>e===`x`?t:e===`r`?r:n,i=t.xAxisID=q(n.xAxisID,nl(e,`x`)),a=t.yAxisID=q(n.yAxisID,nl(e,`y`)),o=t.rAxisID=q(n.rAxisID,nl(e,`r`)),s=t.indexAxis,c=t.iAxisID=r(s,i,a,o),l=t.vAxisID=r(s,a,i,o);t.xScale=this.getScaleForId(i),t.yScale=this.getScaleForId(a),t.rScale=this.getScaleForId(o),t.iScale=this.getScaleForId(c),t.vScale=this.getScaleForId(l)}getDataset(){return this.chart.data.datasets[this.index]}getMeta(){return this.chart.getDatasetMeta(this.index)}getScaleForId(e){return this.chart.scales[e]}_getOtherScale(e){let t=this._cachedMeta;return e===t.iScale?t.vScale:t.iScale}reset(){this._update(`reset`)}_destroy(){let e=this._cachedMeta;this._data&&qo(this._data,this),e._stacked&&al(e)}_dataCheck(){let e=this.getDataset(),t=e.data||=[],n=this._data;if(G(t)){let e=this._cachedMeta;this._data=Yc(t,e)}else if(n!==t){if(n){qo(n,this);let e=this._cachedMeta;al(e),e._parsed=[]}t&&Object.isExtensible(t)&&Ko(t,this),this._syncList=[],this._data=t}}addElements(){let e=this._cachedMeta;this._dataCheck(),this.datasetElementType&&(e.dataset=new this.datasetElementType)}buildOrUpdateElements(e){let t=this._cachedMeta,n=this.getDataset(),r=!1;this._dataCheck();let i=t._stacked;t._stacked=Xc(t.vScale,t),t.stack!==n.stack&&(r=!0,al(t),t.stack=n.stack),this._resyncElements(e),(r||i!==t._stacked)&&(tl(this,t._parsed),t._stacked=Xc(t.vScale,t))}configure(){let e=this.chart.config,t=e.datasetScopeKeys(this._type),n=e.getOptionScopes(this.getDataset(),t,!0);this.options=e.createResolver(n,this.getContext()),this._parsing=this.options.parsing,this._cachedDataOpts={}}parse(e,t){let{_cachedMeta:n,_data:r}=this,{iScale:i,_stacked:a}=n,o=i.axis,s=e===0&&t===r.length||n._sorted,c=e>0&&n._parsed[e-1],l,u,d;if(this._parsing===!1)n._parsed=r,n._sorted=!0,d=r;else{d=W(r[e])?this.parseArrayData(n,r,e,t):G(r[e])?this.parseObjectData(n,r,e,t):this.parsePrimitiveData(n,r,e,t);let i=()=>u[o]===null||c&&u[o]<c[o];for(l=0;l<t;++l)n._parsed[l+e]=u=d[l],s&&(i()&&(s=!1),c=u);n._sorted=s}a&&tl(this,d)}parsePrimitiveData(e,t,n,r){let{iScale:i,vScale:a}=e,o=i.axis,s=a.axis,c=i.getLabels(),l=i===a,u=Array(r),d,f,p;for(d=0,f=r;d<f;++d)p=d+n,u[d]={[o]:l||i.parse(c[p],p),[s]:a.parse(t[p],p)};return u}parseArrayData(e,t,n,r){let{xScale:i,yScale:a}=e,o=Array(r),s,c,l,u;for(s=0,c=r;s<c;++s)l=s+n,u=t[l],o[s]={x:i.parse(u[0],l),y:a.parse(u[1],l)};return o}parseObjectData(e,t,n,r){let{xScale:i,yScale:a}=e,{xAxisKey:o=`x`,yAxisKey:s=`y`}=this._parsing,c=Array(r),l,u,d,f;for(l=0,u=r;l<u;++l)d=l+n,f=t[d],c[l]={x:i.parse(lo(f,o),d),y:a.parse(lo(f,s),d)};return c}getParsed(e){return this._cachedMeta._parsed[e]}getDataElement(e){return this._cachedMeta.data[e]}applyStack(e,t,n){let r=this.chart,i=this._cachedMeta,a=t[e.axis];return Jc({keys:qc(r,!0),values:t._stacks[e.axis]._visualValues},a,i.index,{mode:n})}updateRangeFromParsed(e,t,n,r){let i=n[t.axis],a=i===null?NaN:i,o=r&&n._stacks[t.axis];r&&o&&(r.values=o,a=Jc(r,i,this._cachedMeta.index)),e.min=Math.min(e.min,a),e.max=Math.max(e.max,a)}getMinMax(e,t){let n=this._cachedMeta,r=n._parsed,i=n._sorted&&e===n.iScale,a=r.length,o=this._getOtherScale(e),s=cl(t,n,this.chart),c={min:1/0,max:-1/0},{min:l,max:u}=Qc(o),d,f;function p(){f=r[d];let t=f[o.axis];return!K(f[e.axis])||l>t||u<t}for(d=0;d<a&&!(!p()&&(this.updateRangeFromParsed(c,e,f,s),i));++d);if(i){for(d=a-1;d>=0;--d)if(!p()){this.updateRangeFromParsed(c,e,f,s);break}}return c}getAllParsedValues(e){let t=this._cachedMeta._parsed,n=[],r,i,a;for(r=0,i=t.length;r<i;++r)a=t[r][e.axis],K(a)&&n.push(a);return n}getMaxOverflow(){return!1}getLabelAndValue(e){let t=this._cachedMeta,n=t.iScale,r=t.vScale,i=this.getParsed(e);return{label:n?``+n.getLabelForValue(i[n.axis]):``,value:r?``+r.getLabelForValue(i[r.axis]):``}}_update(e){let t=this._cachedMeta;this.update(e||`default`),t._clip=Kc(q(this.options.clip,Gc(t.xScale,t.yScale,this.getMaxOverflow())))}update(e){}draw(){let e=this._ctx,t=this.chart,n=this._cachedMeta,r=n.data||[],i=t.chartArea,a=[],o=this._drawStart||0,s=this._drawCount||r.length-o,c=this.options.drawActiveElementsOnTop,l;for(n.dataset&&n.dataset.draw(e,i,o,s),l=o;l<o+s;++l){let t=r[l];t.hidden||(t.active&&c?a.push(t):t.draw(e,i))}for(l=0;l<a.length;++l)a[l].draw(e,i)}getStyle(e,t){let n=t?`active`:`default`;return e===void 0&&this._cachedMeta.dataset?this.resolveDatasetElementOptions(n):this.resolveDataElementOptions(e||0,n)}getContext(e,t,n){let r=this.getDataset(),i;if(e>=0&&e<this._cachedMeta.data.length){let t=this._cachedMeta.data[e];i=t.$context||=il(this.getContext(),e,t),i.parsed=this.getParsed(e),i.raw=r.data[e],i.index=i.dataIndex=e}else i=this.$context||=rl(this.chart.getContext(),this.index),i.dataset=r,i.index=i.datasetIndex=this.index;return i.active=!!t,i.mode=n,i}resolveDatasetElementOptions(e){return this._resolveElementOptions(this.datasetElementType.id,e)}resolveDataElementOptions(e,t){return this._resolveElementOptions(this.dataElementType.id,t,e)}_resolveElementOptions(e,t=`default`,n){let r=t===`active`,i=this._cachedDataOpts,a=e+`-`+t,o=i[a],s=this.enableOptionSharing&&fo(n);if(o)return sl(o,s);let c=this.chart.config,l=c.datasetElementScopeKeys(this._type,e),u=r?[`${e}Hover`,`hover`,e,``]:[e,``],d=c.getOptionScopes(this.getDataset(),l),f=Object.keys(Z.elements[e]),p=c.resolveNamedOptions(d,f,()=>this.getContext(n,r,t),u);return p.$shared&&(p.$shared=s,i[a]=Object.freeze(sl(p,s))),p}_resolveAnimations(e,t,n){let r=this.chart,i=this._cachedDataOpts,a=`animation-${t}`,o=i[a];if(o)return o;let s;if(r.options.animation!==!1){let r=this.chart.config,i=r.datasetAnimationScopeKeys(this._type,t),a=r.getOptionScopes(this.getDataset(),i);s=r.createResolver(a,this.getContext(e,n,t))}let c=new Vc(r,s&&s.animations);return s&&s._cacheable&&(i[a]=Object.freeze(c)),c}getSharedOptions(e){if(e.$shared)return this._sharedOptions||=Object.assign({},e)}includeOptions(e,t){return!t||ol(e)||this.chart._animationsDisabled}_getSharedOptions(e,t){let n=this.resolveDataElementOptions(e,t),r=this._sharedOptions,i=this.getSharedOptions(n),a=this.includeOptions(t,i)||i!==r;return this.updateSharedOptions(i,t,n),{sharedOptions:i,includeOptions:a}}updateElement(e,t,n,r){ol(r)?Object.assign(e,n):this._resolveAnimations(t,r).update(e,n)}updateSharedOptions(e,t,n){e&&!ol(t)&&this._resolveAnimations(void 0,t).update(e,n)}_setStyle(e,t,n,r){e.active=r;let i=this.getStyle(t,r);this._resolveAnimations(t,n,r).update(e,{options:!r&&this.getSharedOptions(i)||i})}removeHoverStyle(e,t,n){this._setStyle(e,n,`active`,!1)}setHoverStyle(e,t,n){this._setStyle(e,n,`active`,!0)}_removeDatasetHoverStyle(){let e=this._cachedMeta.dataset;e&&this._setStyle(e,void 0,`active`,!1)}_setDatasetHoverStyle(){let e=this._cachedMeta.dataset;e&&this._setStyle(e,void 0,`active`,!0)}_resyncElements(e){let t=this._data,n=this._cachedMeta.data;for(let[e,t,n]of this._syncList)this[e](t,n);this._syncList=[];let r=n.length,i=t.length,a=Math.min(i,r);a&&this.parse(0,a),i>r?this._insertElements(r,i-r,e):i<r&&this._removeElements(i,r-i)}_insertElements(e,t,n=!0){let r=this._cachedMeta,i=r.data,a=e+t,o,s=e=>{for(e.length+=t,o=e.length-1;o>=a;o--)e[o]=e[o-t]};for(s(i),o=e;o<a;++o)i[o]=new this.dataElementType;this._parsing&&s(r._parsed),this.parse(e,t),n&&this.updateElements(i,e,t,`reset`)}updateElements(e,t,n,r){}_removeElements(e,t){let n=this._cachedMeta;if(this._parsing){let r=n._parsed.splice(e,t);n._stacked&&al(n,r)}n.data.splice(e,t)}_sync(e){if(this._parsing)this._syncList.push(e);else{let[t,n,r]=e;this[t](n,r)}this.chart._dataChanges.push([this.index,...e])}_onDataPush(){let e=arguments.length;this._sync([`_insertElements`,this.getDataset().data.length-e,e])}_onDataPop(){this._sync([`_removeElements`,this._cachedMeta.data.length-1,1])}_onDataShift(){this._sync([`_removeElements`,0,1])}_onDataSplice(e,t){t&&this._sync([`_removeElements`,e,t]);let n=arguments.length-2;n&&this._sync([`_insertElements`,e,n])}_onDataUnshift(){this._sync([`_insertElements`,0,arguments.length])}};function ul(e,t){if(!e._cache.$bar){let n=e.getMatchingVisibleMetas(t),r=[];for(let t=0,i=n.length;t<i;t++)r=r.concat(n[t].controller.getAllParsedValues(e));e._cache.$bar=Jo(r.sort((e,t)=>e-t))}return e._cache.$bar}function dl(e){let t=e.iScale,n=ul(t,e.type),r=t._length,i,a,o,s,c=()=>{o!==32767&&o!==-32768&&(fo(s)&&(r=Math.min(r,Math.abs(o-s)||r)),s=o)};for(i=0,a=n.length;i<a;++i)o=t.getPixelForValue(n[i]),c();for(s=void 0,i=0,a=t.ticks.length;i<a;++i)o=t.getPixelForTick(i),c();return r}function fl(e,t,n,r){let i=n.barThickness,a,o;return U(i)?(a=t.min*n.categoryPercentage,o=n.barPercentage):(a=i*r,o=1),{chunk:a/r,ratio:o,start:t.pixels[e]-a/2}}function pl(e,t,n,r){let i=t.pixels,a=i[e],o=e>0?i[e-1]:null,s=e<i.length-1?i[e+1]:null,c=n.categoryPercentage;o===null&&(o=a-(s===null?t.end-t.start:s-a)),s===null&&(s=a+a-o);let l=a-(a-Math.min(o,s))/2*c;return{chunk:Math.abs(s-o)/2*c/r,ratio:n.barPercentage,start:l}}function ml(e,t,n,r){let i=n.parse(e[0],r),a=n.parse(e[1],r),o=Math.min(i,a),s=Math.max(i,a),c=o,l=s;Math.abs(o)>Math.abs(s)&&(c=s,l=o),t[n.axis]=l,t._custom={barStart:c,barEnd:l,start:i,end:a,min:o,max:s}}function hl(e,t,n,r){return W(e)?ml(e,t,n,r):t[n.axis]=n.parse(e,r),t}function gl(e,t,n,r){let i=e.iScale,a=e.vScale,o=i.getLabels(),s=i===a,c=[],l,u,d,f;for(l=n,u=n+r;l<u;++l)f=t[l],d={},d[i.axis]=s||i.parse(o[l],l),c.push(hl(f,d,a,l));return c}function _l(e){return e&&e.barStart!==void 0&&e.barEnd!==void 0}function vl(e,t,n){return e===0?(t.isHorizontal()?1:-1)*(t.min>=n?1:-1):Co(e)}function yl(e){let t,n,r,i,a;return e.horizontal?(t=e.base>e.x,n=`left`,r=`right`):(t=e.base<e.y,n=`bottom`,r=`top`),t?(i=`end`,a=`start`):(i=`start`,a=`end`),{start:n,end:r,reverse:t,top:i,bottom:a}}function bl(e,t,n,r){let i=t.borderSkipped,a={};if(!i){e.borderSkipped=a;return}if(i===!0){e.borderSkipped={top:!0,right:!0,bottom:!0,left:!0};return}let{start:o,end:s,reverse:c,top:l,bottom:u}=yl(e);i===`middle`&&n&&(e.enableBorderRadius=!0,(n._top||0)===r?i=l:(n._bottom||0)===r?i=u:(a[xl(u,o,s,c)]=!0,i=l)),a[xl(i,o,s,c)]=!0,e.borderSkipped=a}function xl(e,t,n,r){return r?(e=Sl(e,t,n),e=Cl(e,n,t)):e=Cl(e,t,n),e}function Sl(e,t,n){return e===t?n:e===n?t:e}function Cl(e,t,n){return e===`start`?t:e===`end`?n:e}function wl(e,{inflateAmount:t},n){e.inflateAmount=t===`auto`?n===1?.33:0:t}var Tl=class extends ll{static id=`bar`;static defaults={datasetElementType:!1,dataElementType:`bar`,categoryPercentage:.8,barPercentage:.9,grouped:!0,animations:{numbers:{type:`number`,properties:[`x`,`y`,`base`,`width`,`height`]}}};static overrides={scales:{_index_:{type:`category`,offset:!0,grid:{offset:!0}},_value_:{type:`linear`,beginAtZero:!0}}};parsePrimitiveData(e,t,n,r){return gl(e,t,n,r)}parseArrayData(e,t,n,r){return gl(e,t,n,r)}parseObjectData(e,t,n,r){let{iScale:i,vScale:a}=e,{xAxisKey:o=`x`,yAxisKey:s=`y`}=this._parsing,c=i.axis===`x`?o:s,l=a.axis===`x`?o:s,u=[],d,f,p,m;for(d=n,f=n+r;d<f;++d)m=t[d],p={},p[i.axis]=i.parse(lo(m,c),d),u.push(hl(lo(m,l),p,a,d));return u}updateRangeFromParsed(e,t,n,r){super.updateRangeFromParsed(e,t,n,r);let i=n._custom;i&&t===this._cachedMeta.vScale&&(e.min=Math.min(e.min,i.min),e.max=Math.max(e.max,i.max))}getMaxOverflow(){return 0}getLabelAndValue(e){let{iScale:t,vScale:n}=this._cachedMeta,r=this.getParsed(e),i=r._custom,a=_l(i)?`[`+i.start+`, `+i.end+`]`:``+n.getLabelForValue(r[n.axis]);return{label:``+t.getLabelForValue(r[t.axis]),value:a}}initialize(){this.enableOptionSharing=!0,super.initialize();let e=this._cachedMeta;e.stack=this.getDataset().stack}update(e){let t=this._cachedMeta;this.updateElements(t.data,0,t.data.length,e)}updateElements(e,t,n,r){let i=r===`reset`,{index:a,_cachedMeta:{vScale:o}}=this,s=o.getBasePixel(),c=o.isHorizontal(),l=this._getRuler(),{sharedOptions:u,includeOptions:d}=this._getSharedOptions(t,r);for(let f=t;f<t+n;f++){let t=this.getParsed(f),n=i||U(t[o.axis])?{base:s,head:s}:this._calculateBarValuePixels(f),p=this._calculateBarIndexPixels(f,l),m=(t._stacks||{})[o.axis],h={horizontal:c,base:n.base,enableBorderRadius:!m||_l(t._custom)||a===m._top||a===m._bottom,x:c?n.head:p.center,y:c?p.center:n.head,height:c?p.size:Math.abs(n.size),width:c?Math.abs(n.size):p.size};d&&(h.options=u||this.resolveDataElementOptions(f,e[f].active?`active`:r));let g=h.options||e[f].options;bl(h,g,m,a),wl(h,g,l.ratio),this.updateElement(e[f],f,h,r)}}_getStacks(e,t){let{iScale:n}=this._cachedMeta,r=n.getMatchingVisibleMetas(this._type).filter(e=>e.controller.options.grouped),i=n.options.stacked,a=[],o=this._cachedMeta.controller.getParsed(t),s=o&&o[n.axis],c=e=>{let t=e._parsed.find(e=>e[n.axis]===s),r=t&&t[e.vScale.axis];if(U(r)||isNaN(r))return!0};for(let n of r)if(!(t!==void 0&&c(n))&&((i===!1||a.indexOf(n.stack)===-1||i===void 0&&n.stack===void 0)&&a.push(n.stack),n.index===e))break;return a.length||a.push(void 0),a}_getStackCount(e){return this._getStacks(void 0,e).length}_getAxisCount(){return this._getAxis().length}getFirstScaleIdForIndexAxis(){let e=this.chart.scales,t=this.chart.options.indexAxis;return Object.keys(e).filter(n=>e[n].axis===t).shift()}_getAxis(){let e={},t=this.getFirstScaleIdForIndexAxis();for(let n of this.chart.data.datasets)e[q(this.chart.options.indexAxis===`x`?n.xAxisID:n.yAxisID,t)]=!0;return Object.keys(e)}_getStackIndex(e,t,n){let r=this._getStacks(e,n),i=t===void 0?-1:r.indexOf(t);return i===-1?r.length-1:i}_getRuler(){let e=this.options,t=this._cachedMeta,n=t.iScale,r=[],i,a;for(i=0,a=t.data.length;i<a;++i)r.push(n.getPixelForValue(this.getParsed(i)[n.axis],i));let o=e.barThickness;return{min:o||dl(t),pixels:r,start:n._startPixel,end:n._endPixel,stackCount:this._getStackCount(),scale:n,grouped:e.grouped,ratio:o?1:e.categoryPercentage*e.barPercentage}}_calculateBarValuePixels(e){let{_cachedMeta:{vScale:t,_stacked:n,index:r},options:{base:i,minBarLength:a}}=this,o=i||0,s=this.getParsed(e),c=s._custom,l=_l(c),u=s[t.axis],d=0,f=n?this.applyStack(t,s,n):u,p,m;f!==u&&(d=f-u,f=u),l&&(u=c.barStart,f=c.barEnd-c.barStart,u!==0&&Co(u)!==Co(c.barEnd)&&(d=0),d+=u);let h=!U(i)&&!l?i:d,g=t.getPixelForValue(h);if(p=this.chart.getDataVisibility(e)?t.getPixelForValue(d+f):g,m=p-g,Math.abs(m)<a){m=vl(m,t,o)*a,u===o&&(g-=m/2);let e=t.getPixelForDecimal(0),i=t.getPixelForDecimal(1);g=Math.max(Math.min(g,Math.max(e,i)),Math.min(e,i)),p=g+m,n&&!l&&(s._stacks[t.axis]._visualValues[r]=t.getValueForPixel(p)-t.getValueForPixel(g))}if(g===t.getPixelForValue(o)){let e=Co(m)*t.getLineWidthForValue(o)/2;g+=e,m-=e}return{size:m,base:g,head:p,center:p+m/2}}_calculateBarIndexPixels(e,t){let n=t.scale,r=this.options,i=r.skipNull,a=q(r.maxBarThickness,1/0),o,s,c=this._getAxisCount();if(t.grouped){let n=i?this._getStackCount(e):t.stackCount,l=r.barThickness===`flex`?pl(e,t,r,n*c):fl(e,t,r,n*c),u=this.chart.options.indexAxis===`x`?this.getDataset().xAxisID:this.getDataset().yAxisID,d=this._getAxis().indexOf(q(u,this.getFirstScaleIdForIndexAxis())),f=this._getStackIndex(this.index,this._cachedMeta.stack,i?e:void 0)+d;o=l.start+l.chunk*f+l.chunk/2,s=Math.min(a,l.chunk*l.ratio)}else o=n.getPixelForValue(this.getParsed(e)[n.axis],e),s=Math.min(a,t.min*t.ratio);return{base:o-s/2,head:o+s/2,center:o,size:s}}draw(){let e=this._cachedMeta,t=e.vScale,n=e.data,r=n.length,i=0;for(;i<r;++i)this.getParsed(i)[t.axis]!==null&&!n[i].hidden&&n[i].draw(this._ctx)}};function El(){throw Error(`This method is not implemented: Check that a complete date adapter is provided.`)}var Dl={_date:class e{static override(t){Object.assign(e.prototype,t)}options;constructor(e){this.options=e||{}}init(){}formats(){return El()}parse(){return El()}format(){return El()}add(){return El()}diff(){return El()}startOf(){return El()}endOf(){return El()}}};function Ol(e,t,n,r){let{controller:i,data:a,_sorted:o}=e,s=i._cachedMeta.iScale,c=e.dataset&&e.dataset.options?e.dataset.options.spanGaps:null;if(s&&t===s.axis&&t!==`r`&&o&&a.length){let o=s._reversePixels?Uo:Ho;if(!r){let r=o(a,t,n);if(c){let{vScale:t}=i._cachedMeta,{_parsed:n}=e,a=n.slice(0,r.lo+1).reverse().findIndex(e=>!U(e[t.axis]));r.lo-=Math.max(0,a);let o=n.slice(r.hi).findIndex(e=>!U(e[t.axis]));r.hi+=Math.max(0,o)}return r}if(i._sharedOptions){let e=a[0],r=typeof e.getRange==`function`&&e.getRange(t);if(r){let e=o(a,t,n-r),i=o(a,t,n+r);return{lo:e.lo,hi:i.hi}}}}return{lo:0,hi:a.length-1}}function kl(e,t,n,r,i){let a=e.getSortedVisibleDatasetMetas(),o=n[t];for(let e=0,n=a.length;e<n;++e){let{index:n,data:s}=a[e],{lo:c,hi:l}=Ol(a[e],t,o,i);for(let e=c;e<=l;++e){let t=s[e];t.skip||r(t,n,e)}}}function Al(e){let t=e.indexOf(`x`)!==-1,n=e.indexOf(`y`)!==-1;return function(e,r){let i=t?Math.abs(e.x-r.x):0,a=n?Math.abs(e.y-r.y):0;return Math.sqrt(i**2+a**2)}}function jl(e,t,n,r,i){let a=[];return!i&&!e.isPointInArea(t)||kl(e,n,t,function(n,o,s){!i&&!As(n,e.chartArea,0)||n.inRange(t.x,t.y,r)&&a.push({element:n,datasetIndex:o,index:s})},!0),a}function Ml(e,t,n,r){let i=[];function a(e,n,a){let{startAngle:o,endAngle:s}=e.getProps([`startAngle`,`endAngle`],r),{angle:c}=Po(e,{x:t.x,y:t.y});Lo(c,o,s)&&i.push({element:e,datasetIndex:n,index:a})}return kl(e,n,t,a),i}function Nl(e,t,n,r,i,a){let o=[],s=Al(n),c=1/0;function l(n,l,u){let d=n.inRange(t.x,t.y,i);if(r&&!d)return;let f=n.getCenterPoint(i);if(!(a||e.isPointInArea(f))&&!d)return;let p=s(t,f);p<c?(o=[{element:n,datasetIndex:l,index:u}],c=p):p===c&&o.push({element:n,datasetIndex:l,index:u})}return kl(e,n,t,l),o}function Pl(e,t,n,r,i,a){return!a&&!e.isPointInArea(t)?[]:n===`r`&&!r?Ml(e,t,n,i):Nl(e,t,n,r,i,a)}function Fl(e,t,n,r,i){let a=[],o=n===`x`?`inXRange`:`inYRange`,s=!1;return kl(e,n,t,(e,r,c)=>{e[o]&&e[o](t[n],i)&&(a.push({element:e,datasetIndex:r,index:c}),s||=e.inRange(t.x,t.y,i))}),r&&!s?[]:a}var Il={evaluateInteractionItems:kl,modes:{index(e,t,n,r){let i=Sc(t,e),a=n.axis||`x`,o=n.includeInvisible||!1,s=n.intersect?jl(e,i,a,r,o):Pl(e,i,a,!1,r,o),c=[];return s.length?(e.getSortedVisibleDatasetMetas().forEach(e=>{let t=s[0].index,n=e.data[t];n&&!n.skip&&c.push({element:n,datasetIndex:e.index,index:t})}),c):[]},dataset(e,t,n,r){let i=Sc(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1,s=n.intersect?jl(e,i,a,r,o):Pl(e,i,a,!1,r,o);if(s.length>0){let t=s[0].datasetIndex,n=e.getDatasetMeta(t).data;s=[];for(let e=0;e<n.length;++e)s.push({element:n[e],datasetIndex:t,index:e})}return s},point(e,t,n,r){return jl(e,Sc(t,e),n.axis||`xy`,r,n.includeInvisible||!1)},nearest(e,t,n,r){let i=Sc(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1;return Pl(e,i,a,n.intersect,r,o)},x(e,t,n,r){return Fl(e,Sc(t,e),`x`,n.intersect,r)},y(e,t,n,r){return Fl(e,Sc(t,e),`y`,n.intersect,r)}}},Ll=[`left`,`top`,`right`,`bottom`];function Rl(e,t){return e.filter(e=>e.pos===t)}function zl(e,t){return e.filter(e=>Ll.indexOf(e.pos)===-1&&e.box.axis===t)}function Bl(e,t){return e.sort((e,n)=>{let r=t?n:e,i=t?e:n;return r.weight===i.weight?r.index-i.index:r.weight-i.weight})}function Vl(e){let t=[],n,r,i,a,o,s;for(n=0,r=(e||[]).length;n<r;++n)i=e[n],{position:a,options:{stack:o,stackWeight:s=1}}=i,t.push({index:n,box:i,pos:a,horizontal:i.isHorizontal(),weight:i.weight,stack:o&&a+o,stackWeight:s});return t}function Hl(e){let t={};for(let n of e){let{stack:e,pos:r,stackWeight:i}=n;if(!e||!Ll.includes(r))continue;let a=t[e]||(t[e]={count:0,placed:0,weight:0,size:0});a.count++,a.weight+=i}return t}function Ul(e,t){let n=Hl(e),{vBoxMaxWidth:r,hBoxMaxHeight:i}=t,a,o,s;for(a=0,o=e.length;a<o;++a){s=e[a];let{fullSize:o}=s.box,c=n[s.stack],l=c&&s.stackWeight/c.weight;s.horizontal?(s.width=l?l*r:o&&t.availableWidth,s.height=i):(s.width=r,s.height=l?l*i:o&&t.availableHeight)}return n}function Wl(e){let t=Vl(e),n=Bl(t.filter(e=>e.box.fullSize),!0),r=Bl(Rl(t,`left`),!0),i=Bl(Rl(t,`right`)),a=Bl(Rl(t,`top`),!0),o=Bl(Rl(t,`bottom`)),s=zl(t,`x`),c=zl(t,`y`);return{fullSize:n,leftAndTop:r.concat(a),rightAndBottom:i.concat(c).concat(o).concat(s),chartArea:Rl(t,`chartArea`),vertical:r.concat(i).concat(c),horizontal:a.concat(o).concat(s)}}function Gl(e,t,n,r){return Math.max(e[n],t[n])+Math.max(e[r],t[r])}function Kl(e,t){e.top=Math.max(e.top,t.top),e.left=Math.max(e.left,t.left),e.bottom=Math.max(e.bottom,t.bottom),e.right=Math.max(e.right,t.right)}function ql(e,t,n,r){let{pos:i,box:a}=n,o=e.maxPadding;if(!G(i)){n.size&&(e[i]-=n.size);let t=r[n.stack]||{size:0,count:1};t.size=Math.max(t.size,n.horizontal?a.height:a.width),n.size=t.size/t.count,e[i]+=n.size}a.getPadding&&Kl(o,a.getPadding());let s=Math.max(0,t.outerWidth-Gl(o,e,`left`,`right`)),c=Math.max(0,t.outerHeight-Gl(o,e,`top`,`bottom`)),l=s!==e.w,u=c!==e.h;return e.w=s,e.h=c,n.horizontal?{same:l,other:u}:{same:u,other:l}}function Jl(e){let t=e.maxPadding;function n(n){let r=Math.max(t[n]-e[n],0);return e[n]+=r,r}e.y+=n(`top`),e.x+=n(`left`),n(`right`),n(`bottom`)}function Yl(e,t){let n=t.maxPadding;function r(e){let r={left:0,top:0,right:0,bottom:0};return e.forEach(e=>{r[e]=Math.max(t[e],n[e])}),r}return r(e?[`left`,`right`]:[`top`,`bottom`])}function Xl(e,t,n,r){let i=[],a,o,s,c,l,u;for(a=0,o=e.length,l=0;a<o;++a){s=e[a],c=s.box,c.update(s.width||t.w,s.height||t.h,Yl(s.horizontal,t));let{same:o,other:d}=ql(t,n,s,r);l|=o&&i.length,u||=d,c.fullSize||i.push(s)}return l&&Xl(i,t,n,r)||u}function Zl(e,t,n,r,i){e.top=n,e.left=t,e.right=t+r,e.bottom=n+i,e.width=r,e.height=i}function Ql(e,t,n,r){let i=n.padding,{x:a,y:o}=t;for(let s of e){let e=s.box,c=r[s.stack]||{count:1,placed:0,weight:1},l=s.stackWeight/c.weight||1;if(s.horizontal){let r=t.w*l,a=c.size||e.height;fo(c.start)&&(o=c.start),e.fullSize?Zl(e,i.left,o,n.outerWidth-i.right-i.left,a):Zl(e,t.left+c.placed,o,r,a),c.start=o,c.placed+=r,o=e.bottom}else{let r=t.h*l,o=c.size||e.width;fo(c.start)&&(a=c.start),e.fullSize?Zl(e,a,i.top,o,n.outerHeight-i.bottom-i.top):Zl(e,a,t.top+c.placed,o,r),c.start=a,c.placed+=r,a=e.right}}t.x=a,t.y=o}var $l={addBox(e,t){e.boxes||=[],t.fullSize=t.fullSize||!1,t.position=t.position||`top`,t.weight=t.weight||0,t._layers=t._layers||function(){return[{z:0,draw(e){t.draw(e)}}]},e.boxes.push(t)},removeBox(e,t){let n=e.boxes?e.boxes.indexOf(t):-1;n!==-1&&e.boxes.splice(n,1)},configure(e,t,n){t.fullSize=n.fullSize,t.position=n.position,t.weight=n.weight},update(e,t,n,r){if(!e)return;let i=Q(e.options.layout.padding),a=Math.max(t-i.width,0),o=Math.max(n-i.height,0),s=Wl(e.boxes),c=s.vertical,l=s.horizontal;Y(e.boxes,e=>{typeof e.beforeLayout==`function`&&e.beforeLayout()});let u=c.reduce((e,t)=>t.box.options&&t.box.options.display===!1?e:e+1,0)||1,d=Object.freeze({outerWidth:t,outerHeight:n,padding:i,availableWidth:a,availableHeight:o,vBoxMaxWidth:a/2/u,hBoxMaxHeight:o/2}),f=Object.assign({},i);Kl(f,Q(r));let p=Object.assign({maxPadding:f,w:a,h:o,x:i.left,y:i.top},i),m=Ul(c.concat(l),d);Xl(s.fullSize,p,d,m),Xl(c,p,d,m),Xl(l,p,d,m)&&Xl(c,p,d,m),Jl(p),Ql(s.leftAndTop,p,d,m),p.x+=p.w,p.y+=p.h,Ql(s.rightAndBottom,p,d,m),e.chartArea={left:p.left,top:p.top,right:p.left+p.w,bottom:p.top+p.h,height:p.h,width:p.w},Y(s.chartArea,t=>{let n=t.box;Object.assign(n,e.chartArea),n.update(p.w,p.h,{left:0,top:0,right:0,bottom:0})})}},eu=class{acquireContext(e,t){}releaseContext(e){return!1}addEventListener(e,t,n){}removeEventListener(e,t,n){}getDevicePixelRatio(){return 1}getMaximumSize(e,t,n,r){return t=Math.max(0,t||e.width),n||=e.height,{width:t,height:Math.max(0,r?Math.floor(t/r):n)}}isAttached(e){return!0}updateConfig(e){}},tu=class extends eu{acquireContext(e){return e&&e.getContext&&e.getContext(`2d`)||null}updateConfig(e){e.options.animation=!1}},nu=`$chartjs`,ru={touchstart:`mousedown`,touchmove:`mousemove`,touchend:`mouseup`,pointerenter:`mouseenter`,pointerdown:`mousedown`,pointermove:`mousemove`,pointerup:`mouseup`,pointerleave:`mouseout`,pointerout:`mouseout`},iu=e=>e===null||e===``;function au(e,t){let n=e.style,r=e.getAttribute(`height`),i=e.getAttribute(`width`);if(e[nu]={initial:{height:r,width:i,style:{display:n.display,height:n.height,width:n.width}}},n.display=n.display||`block`,n.boxSizing=n.boxSizing||`border-box`,iu(i)){let t=Oc(e,`width`);t!==void 0&&(e.width=t)}if(iu(r)){if(e.style.height===``)e.height=e.width/(t||2);else{let t=Oc(e,`height`);t!==void 0&&(e.height=t)}}return e}var ou=Dc?{passive:!0}:!1;function su(e,t,n){e&&e.addEventListener(t,n,ou)}function cu(e,t,n){e&&e.canvas&&e.canvas.removeEventListener(t,n,ou)}function lu(e,t){let n=ru[e.type]||e.type,{x:r,y:i}=Sc(e,t);return{type:n,chart:t,native:e,x:r===void 0?null:r,y:i===void 0?null:i}}function uu(e,t){for(let n of e)if(n===t||n.contains(t))return!0}function du(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=uu(n.addedNodes,r),t&&=!uu(n.removedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}function fu(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=uu(n.removedNodes,r),t&&=!uu(n.addedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}var pu=new Map,mu=0;function hu(){let e=window.devicePixelRatio;e!==mu&&(mu=e,pu.forEach((t,n)=>{n.currentDevicePixelRatio!==e&&t()}))}function gu(e,t){pu.size||window.addEventListener(`resize`,hu),pu.set(e,t)}function _u(e){pu.delete(e),pu.size||window.removeEventListener(`resize`,hu)}function vu(e,t,n){let r=e.canvas,i=r&&mc(r);if(!i)return;let a=Xo((e,t)=>{let r=i.clientWidth;n(e,t),r<i.clientWidth&&n()},window),o=new ResizeObserver(e=>{let t=e[0],n=t.contentRect.width,r=t.contentRect.height;(n!==0||r!==0)&&a(n,r)});return o.observe(i),gu(e,a),o}function yu(e,t,n){n&&n.disconnect(),t===`resize`&&_u(e)}function bu(e,t,n){let r=e.canvas,i=Xo(t=>{e.ctx!==null&&n(lu(t,e))},e);return su(r,t,i),i}var xu=class extends eu{acquireContext(e,t){let n=e&&e.getContext&&e.getContext(`2d`);return n&&n.canvas===e?(au(e,t),n):null}releaseContext(e){let t=e.canvas;if(!t[nu])return!1;let n=t[nu].initial;[`height`,`width`].forEach(e=>{let r=n[e];U(r)?t.removeAttribute(e):t.setAttribute(e,r)});let r=n.style||{};return Object.keys(r).forEach(e=>{t.style[e]=r[e]}),t.width=t.width,delete t[nu],!0}addEventListener(e,t,n){this.removeEventListener(e,t);let r=e.$proxies||={};r[t]=({attach:du,detach:fu,resize:vu}[t]||bu)(e,t,n)}removeEventListener(e,t){let n=e.$proxies||={},r=n[t];r&&(({attach:yu,detach:yu,resize:yu}[t]||cu)(e,t,r),n[t]=void 0)}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(e,t,n,r){return Tc(e,t,n,r)}isAttached(e){let t=e&&mc(e);return!!(t&&t.isConnected)}};function Su(e){return!pc()||typeof OffscreenCanvas<`u`&&e instanceof OffscreenCanvas?tu:xu}var Cu=class{static defaults={};static defaultRoutes=void 0;x;y;active=!1;options;$animations;tooltipPosition(e){let{x:t,y:n}=this.getProps([`x`,`y`],e);return{x:t,y:n}}hasValue(){return Oo(this.x)&&Oo(this.y)}getProps(e,t){let n=this.$animations;if(!t||!n)return this;let r={};return e.forEach(e=>{r[e]=n[e]&&n[e].active()?n[e]._to:this[e]}),r}};function wu(e,t){let n=e.options.ticks,r=Tu(e),i=Math.min(n.maxTicksLimit||r,r),a=n.major.enabled?Du(t):[],o=a.length,s=a[0],c=a[o-1],l=[];if(o>i)return Ou(t,l,a,o/i),l;let u=Eu(a,t,i);if(o>0){let e,n,r=o>1?Math.round((c-s)/(o-1)):null;for(ku(t,l,u,U(r)?0:s-r,s),e=0,n=o-1;e<n;e++)ku(t,l,u,a[e],a[e+1]);return ku(t,l,u,c,U(r)?t.length:c+r),l}return ku(t,l,u),l}function Tu(e){let t=e.options.offset,n=e._tickSize(),r=e._length/n+ +!t,i=e._maxLength/n;return Math.floor(Math.min(r,i))}function Eu(e,t,n){let r=Au(e),i=t.length/n;if(!r)return Math.max(i,1);let a=Eo(r);for(let e=0,t=a.length-1;e<t;e++){let t=a[e];if(t>i)return t}return Math.max(i,1)}function Du(e){let t=[],n,r;for(n=0,r=e.length;n<r;n++)e[n].major&&t.push(n);return t}function Ou(e,t,n,r){let i=0,a=n[0],o;for(r=Math.ceil(r),o=0;o<e.length;o++)o===a&&(t.push(e[o]),i++,a=n[i*r])}function ku(e,t,n,r,i){let a=q(r,0),o=Math.min(q(i,e.length),e.length),s=0,c,l,u;for(n=Math.ceil(n),i&&(c=i-r,n=c/Math.floor(c/n)),u=a;u<0;)s++,u=Math.round(a+s*n);for(l=Math.max(a,0);l<o;l++)l===u&&(t.push(e[l]),s++,u=Math.round(a+s*n))}function Au(e){let t=e.length,n,r;if(t<2)return!1;for(r=e[0],n=1;n<t;++n)if(e[n]-e[n-1]!==r)return!1;return r}var ju=e=>e===`left`?`right`:e===`right`?`left`:e,Mu=(e,t,n)=>t===`top`||t===`left`?e[t]+n:e[t]-n,Nu=(e,t)=>Math.min(t||e,e);function Pu(e,t){let n=[],r=e.length/t,i=e.length,a=0;for(;a<i;a+=r)n.push(e[Math.floor(a)]);return n}function Fu(e,t,n){let r=e.ticks.length,i=Math.min(t,r-1),a=e._startPixel,o=e._endPixel,s=1e-6,c=e.getPixelForTick(i),l;if(!(n&&(l=r===1?Math.max(c-a,o-c):t===0?(e.getPixelForTick(1)-c)/2:(c-e.getPixelForTick(i-1))/2,c+=i<t?l:-l,c<a-s||c>o+s)))return c}function Iu(e,t){Y(e,e=>{let n=e.gc,r=n.length/2,i;if(r>t){for(i=0;i<r;++i)delete e.data[n[i]];n.splice(0,r)}})}function Lu(e){return e.drawTicks?e.tickLength:0}function Ru(e,t){if(!e.display)return 0;let n=$(e.font,t),r=Q(e.padding);return(W(e.text)?e.text.length:1)*n.lineHeight+r.height}function zu(e,t){return qs(e,{scale:t,type:`scale`})}function Bu(e,t,n){return qs(e,{tick:n,index:t,type:`tick`})}function Vu(e,t,n){let r=Qo(e);return(n&&t!==`right`||!n&&t===`right`)&&(r=ju(r)),r}function Hu(e,t,n,r){let{top:i,left:a,bottom:o,right:s,chart:c}=e,{chartArea:l,scales:u}=c,d=0,f,p,m,h=o-i,g=s-a;if(e.isHorizontal()){if(p=$o(r,a,s),G(n)){let e=Object.keys(n)[0],r=n[e];m=u[e].getPixelForValue(r)+h-t}else m=n===`center`?(l.bottom+l.top)/2+h-t:Mu(e,n,t);f=s-a}else{if(G(n)){let e=Object.keys(n)[0],r=n[e];p=u[e].getPixelForValue(r)-g+t}else p=n===`center`?(l.left+l.right)/2-g+t:Mu(e,n,t);m=$o(r,o,i),d=n===`left`?-yo:yo}return{titleX:p,titleY:m,maxWidth:f,rotation:d}}var Uu=class e extends Cu{constructor(e){super(),this.id=e.id,this.type=e.type,this.options=void 0,this.ctx=e.ctx,this.chart=e.chart,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this._margins={left:0,right:0,top:0,bottom:0},this.maxWidth=void 0,this.maxHeight=void 0,this.paddingTop=void 0,this.paddingBottom=void 0,this.paddingLeft=void 0,this.paddingRight=void 0,this.axis=void 0,this.labelRotation=void 0,this.min=void 0,this.max=void 0,this._range=void 0,this.ticks=[],this._gridLineItems=null,this._labelItems=null,this._labelSizes=null,this._length=0,this._maxLength=0,this._longestTextCache={},this._startPixel=void 0,this._endPixel=void 0,this._reversePixels=!1,this._userMax=void 0,this._userMin=void 0,this._suggestedMax=void 0,this._suggestedMin=void 0,this._ticksLength=0,this._borderValue=0,this._cache={},this._dataLimitsCached=!1,this.$context=void 0}init(e){this.options=e.setContext(this.getContext()),this.axis=e.axis,this._userMin=this.parse(e.min),this._userMax=this.parse(e.max),this._suggestedMin=this.parse(e.suggestedMin),this._suggestedMax=this.parse(e.suggestedMax)}parse(e,t){return e}getUserBounds(){let{_userMin:e,_userMax:t,_suggestedMin:n,_suggestedMax:r}=this;return e=Za(e,1/0),t=Za(t,-1/0),n=Za(n,1/0),r=Za(r,-1/0),{min:Za(e,n),max:Za(t,r),minDefined:K(e),maxDefined:K(t)}}getMinMax(e){let{min:t,max:n,minDefined:r,maxDefined:i}=this.getUserBounds(),a;if(r&&i)return{min:t,max:n};let o=this.getMatchingVisibleMetas();for(let s=0,c=o.length;s<c;++s)a=o[s].controller.getMinMax(this,e),r||(t=Math.min(t,a.min)),i||(n=Math.max(n,a.max));return t=i&&t>n?n:t,n=r&&t>n?t:n,{min:Za(t,Za(n,t)),max:Za(n,Za(t,n))}}getPadding(){return{left:this.paddingLeft||0,top:this.paddingTop||0,right:this.paddingRight||0,bottom:this.paddingBottom||0}}getTicks(){return this.ticks}getLabels(){let e=this.chart.data;return this.options.labels||(this.isHorizontal()?e.xLabels:e.yLabels)||e.labels||[]}getLabelItems(e=this.chart.chartArea){return this._labelItems||=this._computeLabelItems(e)}beforeLayout(){this._cache={},this._dataLimitsCached=!1}beforeUpdate(){J(this.options.beforeUpdate,[this])}update(e,t,n){let{beginAtZero:r,grace:i,ticks:a}=this.options,o=a.sampleSize;this.beforeUpdate(),this.maxWidth=e,this.maxHeight=t,this._margins=n=Object.assign({left:0,right:0,top:0,bottom:0},n),this.ticks=null,this._labelSizes=null,this._gridLineItems=null,this._labelItems=null,this.beforeSetDimensions(),this.setDimensions(),this.afterSetDimensions(),this._maxLength=this.isHorizontal()?this.width+n.left+n.right:this.height+n.top+n.bottom,this._dataLimitsCached||=(this.beforeDataLimits(),this.determineDataLimits(),this.afterDataLimits(),this._range=Ks(this,i,r),!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();let s=o<this.ticks.length;this._convertTicksToLabels(s?Pu(this.ticks,o):this.ticks),this.configure(),this.beforeCalculateLabelRotation(),this.calculateLabelRotation(),this.afterCalculateLabelRotation(),a.display&&(a.autoSkip||a.source===`auto`)&&(this.ticks=wu(this,this.ticks),this._labelSizes=null,this.afterAutoSkip()),s&&this._convertTicksToLabels(this.ticks),this.beforeFit(),this.fit(),this.afterFit(),this.afterUpdate()}configure(){let e=this.options.reverse,t,n;this.isHorizontal()?(t=this.left,n=this.right):(t=this.top,n=this.bottom,e=!e),this._startPixel=t,this._endPixel=n,this._reversePixels=e,this._length=n-t,this._alignToPixels=this.options.alignToPixels}afterUpdate(){J(this.options.afterUpdate,[this])}beforeSetDimensions(){J(this.options.beforeSetDimensions,[this])}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=0,this.right=this.width):(this.height=this.maxHeight,this.top=0,this.bottom=this.height),this.paddingLeft=0,this.paddingTop=0,this.paddingRight=0,this.paddingBottom=0}afterSetDimensions(){J(this.options.afterSetDimensions,[this])}_callHooks(e){this.chart.notifyPlugins(e,this.getContext()),J(this.options[e],[this])}beforeDataLimits(){this._callHooks(`beforeDataLimits`)}determineDataLimits(){}afterDataLimits(){this._callHooks(`afterDataLimits`)}beforeBuildTicks(){this._callHooks(`beforeBuildTicks`)}buildTicks(){return[]}afterBuildTicks(){this._callHooks(`afterBuildTicks`)}beforeTickToLabelConversion(){J(this.options.beforeTickToLabelConversion,[this])}generateTickLabels(e){let t=this.options.ticks,n,r,i;for(n=0,r=e.length;n<r;n++)i=e[n],i.label=J(t.callback,[i.value,n,e],this)}afterTickToLabelConversion(){J(this.options.afterTickToLabelConversion,[this])}beforeCalculateLabelRotation(){J(this.options.beforeCalculateLabelRotation,[this])}calculateLabelRotation(){let e=this.options,t=e.ticks,n=Nu(this.ticks.length,e.ticks.maxTicksLimit),r=t.minRotation||0,i=t.maxRotation,a=r,o,s,c;if(!this._isVisible()||!t.display||r>=i||n<=1||!this.isHorizontal()){this.labelRotation=r;return}let l=this._getLabelSizes(),u=l.widest.width,d=l.highest.height,f=Ro(this.chart.width-u,0,this.maxWidth);o=e.offset?this.maxWidth/n:f/(n-1),u+6>o&&(o=f/(n-(e.offset?.5:1)),s=this.maxHeight-Lu(e.grid)-t.padding-Ru(e.title,this.chart.options.font),c=Math.sqrt(u*u+d*d),a=Mo(Math.min(Math.asin(Ro((l.highest.height+6)/o,-1,1)),Math.asin(Ro(s/c,-1,1))-Math.asin(Ro(d/c,-1,1)))),a=Math.max(r,Math.min(i,a))),this.labelRotation=a}afterCalculateLabelRotation(){J(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){J(this.options.beforeFit,[this])}fit(){let e={width:0,height:0},{chart:t,options:{ticks:n,title:r,grid:i}}=this,a=this._isVisible(),o=this.isHorizontal();if(a){let a=Ru(r,t.options.font);if(o?(e.width=this.maxWidth,e.height=Lu(i)+a):(e.height=this.maxHeight,e.width=Lu(i)+a),n.display&&this.ticks.length){let{first:t,last:r,widest:i,highest:a}=this._getLabelSizes(),s=n.padding*2,c=jo(this.labelRotation),l=Math.cos(c),u=Math.sin(c);if(o){let t=n.mirror?0:u*i.width+l*a.height;e.height=Math.min(this.maxHeight,e.height+t+s)}else{let t=n.mirror?0:l*i.width+u*a.height;e.width=Math.min(this.maxWidth,e.width+t+s)}this._calculatePadding(t,r,u,l)}}this._handleMargins(),o?(this.width=this._length=t.width-this._margins.left-this._margins.right,this.height=e.height):(this.width=e.width,this.height=this._length=t.height-this._margins.top-this._margins.bottom)}_calculatePadding(e,t,n,r){let{ticks:{align:i,padding:a},position:o}=this.options,s=this.labelRotation!==0,c=o!==`top`&&this.axis===`x`;if(this.isHorizontal()){let o=this.getPixelForTick(0)-this.left,l=this.right-this.getPixelForTick(this.ticks.length-1),u=0,d=0;s?c?(u=r*e.width,d=n*t.height):(u=n*e.height,d=r*t.width):i===`start`?d=t.width:i===`end`?u=e.width:i!==`inner`&&(u=e.width/2,d=t.width/2),this.paddingLeft=Math.max((u-o+a)*this.width/(this.width-o),0),this.paddingRight=Math.max((d-l+a)*this.width/(this.width-l),0)}else{let n=t.height/2,r=e.height/2;i===`start`?(n=0,r=e.height):i===`end`&&(n=t.height,r=0),this.paddingTop=n+a,this.paddingBottom=r+a}}_handleMargins(){this._margins&&(this._margins.left=Math.max(this.paddingLeft,this._margins.left),this._margins.top=Math.max(this.paddingTop,this._margins.top),this._margins.right=Math.max(this.paddingRight,this._margins.right),this._margins.bottom=Math.max(this.paddingBottom,this._margins.bottom))}afterFit(){J(this.options.afterFit,[this])}isHorizontal(){let{axis:e,position:t}=this.options;return t===`top`||t===`bottom`||e===`x`}isFullSize(){return this.options.fullSize}_convertTicksToLabels(e){this.beforeTickToLabelConversion(),this.generateTickLabels(e);let t,n;for(t=0,n=e.length;t<n;t++)U(e[t].label)&&(e.splice(t,1),n--,t--);this.afterTickToLabelConversion()}_getLabelSizes(){let e=this._labelSizes;if(!e){let t=this.options.ticks.sampleSize,n=this.ticks;t<n.length&&(n=Pu(n,t)),this._labelSizes=e=this._computeLabelSizes(n,n.length,this.options.ticks.maxTicksLimit)}return e}_computeLabelSizes(e,t,n){let{ctx:r,_longestTextCache:i}=this,a=[],o=[],s=Math.floor(t/Nu(t,n)),c=0,l=0,u,d,f,p,m,h,g,_,v,y,b;for(u=0;u<t;u+=s){if(p=e[u].label,m=this._resolveTickFontOptions(u),r.font=h=m.string,g=i[h]=i[h]||{data:{},gc:[]},_=m.lineHeight,v=y=0,!U(p)&&!W(p))v=ws(r,g.data,g.gc,v,p),y=_;else if(W(p))for(d=0,f=p.length;d<f;++d)b=p[d],!U(b)&&!W(b)&&(v=ws(r,g.data,g.gc,v,b),y+=_);a.push(v),o.push(y),c=Math.max(v,c),l=Math.max(y,l)}Iu(i,t);let x=a.indexOf(c),S=o.indexOf(l),C=e=>({width:a[e]||0,height:o[e]||0});return{first:C(0),last:C(t-1),widest:C(x),highest:C(S),widths:a,heights:o}}getLabelForValue(e){return e}getPixelForValue(e,t){return NaN}getValueForPixel(e){}getPixelForTick(e){let t=this.ticks;return e<0||e>t.length-1?null:this.getPixelForValue(t[e].value)}getPixelForDecimal(e){this._reversePixels&&(e=1-e);let t=this._startPixel+e*this._length;return zo(this._alignToPixels?Es(this.chart,t,0):t)}getDecimalForPixel(e){let t=(e-this._startPixel)/this._length;return this._reversePixels?1-t:t}getBasePixel(){return this.getPixelForValue(this.getBaseValue())}getBaseValue(){let{min:e,max:t}=this;return e<0&&t<0?t:e>0&&t>0?e:0}getContext(e){let t=this.ticks||[];if(e>=0&&e<t.length){let n=t[e];return n.$context||=Bu(this.getContext(),e,n)}return this.$context||=zu(this.chart.getContext(),this)}_tickSize(){let e=this.options.ticks,t=jo(this.labelRotation),n=Math.abs(Math.cos(t)),r=Math.abs(Math.sin(t)),i=this._getLabelSizes(),a=e.autoSkipPadding||0,o=i?i.widest.width+a:0,s=i?i.highest.height+a:0;return this.isHorizontal()?s*n>o*r?o/n:s/r:s*r<o*n?s/n:o/r}_isVisible(){let e=this.options.display;return e===`auto`?this.getMatchingVisibleMetas().length>0:!!e}_computeGridLineItems(e){let t=this.axis,n=this.chart,r=this.options,{grid:i,position:a,border:o}=r,s=i.offset,c=this.isHorizontal(),l=this.ticks.length+ +!!s,u=Lu(i),d=[],f=o.setContext(this.getContext()),p=f.display?f.width:0,m=p/2,h=function(e){return Es(n,e,p)},g,_,v,y,b,x,S,C,w,T,E,D;if(a===`top`)g=h(this.bottom),x=this.bottom-u,C=g-m,T=h(e.top)+m,D=e.bottom;else if(a===`bottom`)g=h(this.top),T=e.top,D=h(e.bottom)-m,x=g+m,C=this.top+u;else if(a===`left`)g=h(this.right),b=this.right-u,S=g-m,w=h(e.left)+m,E=e.right;else if(a===`right`)g=h(this.left),w=e.left,E=h(e.right)-m,b=g+m,S=this.left+u;else if(t===`x`){if(a===`center`)g=h((e.top+e.bottom)/2+.5);else if(G(a)){let e=Object.keys(a)[0],t=a[e];g=h(this.chart.scales[e].getPixelForValue(t))}T=e.top,D=e.bottom,x=g+m,C=x+u}else if(t===`y`){if(a===`center`)g=h((e.left+e.right)/2);else if(G(a)){let e=Object.keys(a)[0],t=a[e];g=h(this.chart.scales[e].getPixelForValue(t))}b=g-m,S=b-u,w=e.left,E=e.right}let O=q(r.ticks.maxTicksLimit,l),k=Math.max(1,Math.ceil(l/O));for(_=0;_<l;_+=k){let e=this.getContext(_),t=i.setContext(e),r=o.setContext(e),a=t.lineWidth,l=t.color,u=r.dash||[],f=r.dashOffset,p=t.tickWidth,m=t.tickColor,h=t.tickBorderDash||[],g=t.tickBorderDashOffset;v=Fu(this,_,s),v!==void 0&&(y=Es(n,v,a),c?b=S=w=E=y:x=C=T=D=y,d.push({tx1:b,ty1:x,tx2:S,ty2:C,x1:w,y1:T,x2:E,y2:D,width:a,color:l,borderDash:u,borderDashOffset:f,tickWidth:p,tickColor:m,tickBorderDash:h,tickBorderDashOffset:g}))}return this._ticksLength=l,this._borderValue=g,d}_computeLabelItems(e){let t=this.axis,n=this.options,{position:r,ticks:i}=n,a=this.isHorizontal(),o=this.ticks,{align:s,crossAlign:c,padding:l,mirror:u}=i,d=Lu(n.grid),f=d+l,p=u?-l:f,m=-jo(this.labelRotation),h=[],g,_,v,y,b,x,S,C,w,T,E,D,O=`middle`;if(r===`top`)x=this.bottom-p,S=this._getXAxisLabelAlignment();else if(r===`bottom`)x=this.top+p,S=this._getXAxisLabelAlignment();else if(r===`left`){let e=this._getYAxisLabelAlignment(d);S=e.textAlign,b=e.x}else if(r===`right`){let e=this._getYAxisLabelAlignment(d);S=e.textAlign,b=e.x}else if(t===`x`){if(r===`center`)x=(e.top+e.bottom)/2+f;else if(G(r)){let e=Object.keys(r)[0],t=r[e];x=this.chart.scales[e].getPixelForValue(t)+f}S=this._getXAxisLabelAlignment()}else if(t===`y`){if(r===`center`)b=(e.left+e.right)/2-f;else if(G(r)){let e=Object.keys(r)[0],t=r[e];b=this.chart.scales[e].getPixelForValue(t)}S=this._getYAxisLabelAlignment(d).textAlign}t===`y`&&(s===`start`?O=`top`:s===`end`&&(O=`bottom`));let k=this._getLabelSizes();for(g=0,_=o.length;g<_;++g){v=o[g],y=v.label;let e=i.setContext(this.getContext(g));C=this.getPixelForTick(g)+i.labelOffset,w=this._resolveTickFontOptions(g),T=w.lineHeight,E=W(y)?y.length:1;let t=E/2,n=e.color,s=e.textStrokeColor,l=e.textStrokeWidth,d=S;a?(b=C,S===`inner`&&(d=g===_-1?this.options.reverse?`left`:`right`:g===0?this.options.reverse?`right`:`left`:`center`),D=r===`top`?c===`near`||m!==0?-E*T+T/2:c===`center`?-k.highest.height/2-t*T+T:-k.highest.height+T/2:c===`near`||m!==0?T/2:c===`center`?k.highest.height/2-t*T:k.highest.height-E*T,u&&(D*=-1),m!==0&&!e.showLabelBackdrop&&(b+=T/2*Math.sin(m))):(x=C,D=(1-E)*T/2);let f;if(e.showLabelBackdrop){let t=Q(e.backdropPadding),n=k.heights[g],r=k.widths[g],i=D-t.top,a=0-t.left;switch(O){case`middle`:i-=n/2;break;case`bottom`:i-=n}switch(S){case`center`:a-=r/2;break;case`right`:a-=r;break;case`inner`:g===_-1?a-=r:g>0&&(a-=r/2)}f={left:a,top:i,width:r+t.width,height:n+t.height,color:e.backdropColor}}h.push({label:y,font:w,textOffset:D,options:{rotation:m,color:n,strokeColor:s,strokeWidth:l,textAlign:d,textBaseline:O,translation:[b,x],backdrop:f}})}return h}_getXAxisLabelAlignment(){let{position:e,ticks:t}=this.options;if(-jo(this.labelRotation))return e===`top`?`left`:`right`;let n=`center`;return t.align===`start`?n=`left`:t.align===`end`?n=`right`:t.align===`inner`&&(n=`inner`),n}_getYAxisLabelAlignment(e){let{position:t,ticks:{crossAlign:n,mirror:r,padding:i}}=this.options,a=this._getLabelSizes(),o=e+i,s=a.widest.width,c,l;return t===`left`?r?(l=this.right+i,n===`near`?c=`left`:n===`center`?(c=`center`,l+=s/2):(c=`right`,l+=s)):(l=this.right-o,n===`near`?c=`right`:n===`center`?(c=`center`,l-=s/2):(c=`left`,l=this.left)):t===`right`?r?(l=this.left+i,n===`near`?c=`right`:n===`center`?(c=`center`,l-=s/2):(c=`left`,l-=s)):(l=this.left+o,n===`near`?c=`left`:n===`center`?(c=`center`,l+=s/2):(c=`right`,l=this.right)):c=`right`,{textAlign:c,x:l}}_computeLabelArea(){if(this.options.ticks.mirror)return;let e=this.chart,t=this.options.position;if(t===`left`||t===`right`)return{top:0,left:this.left,bottom:e.height,right:this.right};if(t===`top`||t===`bottom`)return{top:this.top,left:0,bottom:this.bottom,right:e.width}}drawBackground(){let{ctx:e,options:{backgroundColor:t},left:n,top:r,width:i,height:a}=this;t&&(e.save(),e.fillStyle=t,e.fillRect(n,r,i,a),e.restore())}getLineWidthForValue(e){let t=this.options.grid;if(!this._isVisible()||!t.display)return 0;let n=this.ticks.findIndex(t=>t.value===e);return n>=0?t.setContext(this.getContext(n)).lineWidth:0}drawGrid(e){let t=this.options.grid,n=this.ctx,r=this._gridLineItems||=this._computeGridLineItems(e),i,a,o=(e,t,r)=>{!r.width||!r.color||(n.save(),n.lineWidth=r.width,n.strokeStyle=r.color,n.setLineDash(r.borderDash||[]),n.lineDashOffset=r.borderDashOffset,n.beginPath(),n.moveTo(e.x,e.y),n.lineTo(t.x,t.y),n.stroke(),n.restore())};if(t.display)for(i=0,a=r.length;i<a;++i){let e=r[i];t.drawOnChartArea&&o({x:e.x1,y:e.y1},{x:e.x2,y:e.y2},e),t.drawTicks&&o({x:e.tx1,y:e.ty1},{x:e.tx2,y:e.ty2},{color:e.tickColor,width:e.tickWidth,borderDash:e.tickBorderDash,borderDashOffset:e.tickBorderDashOffset})}}drawBorder(){let{chart:e,ctx:t,options:{border:n,grid:r}}=this,i=n.setContext(this.getContext()),a=n.display?i.width:0;if(!a)return;let o=r.setContext(this.getContext(0)).lineWidth,s=this._borderValue,c,l,u,d;this.isHorizontal()?(c=Es(e,this.left,a)-a/2,l=Es(e,this.right,o)+o/2,u=d=s):(u=Es(e,this.top,a)-a/2,d=Es(e,this.bottom,o)+o/2,c=l=s),t.save(),t.lineWidth=i.width,t.strokeStyle=i.color,t.beginPath(),t.moveTo(c,u),t.lineTo(l,d),t.stroke(),t.restore()}drawLabels(e){if(!this.options.ticks.display)return;let t=this.ctx,n=this._computeLabelArea();n&&js(t,n);let r=this.getLabelItems(e);for(let e of r){let n=e.options,r=e.font,i=e.label,a=e.textOffset;Is(t,i,0,a,r,n)}n&&Ms(t)}drawTitle(){let{ctx:e,options:{position:t,title:n,reverse:r}}=this;if(!n.display)return;let i=$(n.font),a=Q(n.padding),o=n.align,s=i.lineHeight/2;t===`bottom`||t===`center`||G(t)?(s+=a.bottom,W(n.text)&&(s+=i.lineHeight*(n.text.length-1))):s+=a.top;let{titleX:c,titleY:l,maxWidth:u,rotation:d}=Hu(this,s,t,o);Is(e,n.text,0,0,i,{color:n.color,maxWidth:u,rotation:d,textAlign:Vu(o,t,r),textBaseline:`middle`,translation:[c,l]})}draw(e){this._isVisible()&&(this.drawBackground(),this.drawGrid(e),this.drawBorder(),this.drawTitle(),this.drawLabels(e))}_layers(){let t=this.options,n=t.ticks&&t.ticks.z||0,r=q(t.grid&&t.grid.z,-1),i=q(t.border&&t.border.z,0);return!this._isVisible()||this.draw!==e.prototype.draw?[{z:n,draw:e=>{this.draw(e)}}]:[{z:r,draw:e=>{this.drawBackground(),this.drawGrid(e),this.drawTitle()}},{z:i,draw:()=>{this.drawBorder()}},{z:n,draw:e=>{this.drawLabels(e)}}]}getMatchingVisibleMetas(e){let t=this.chart.getSortedVisibleDatasetMetas(),n=this.axis+`AxisID`,r=[],i,a;for(i=0,a=t.length;i<a;++i){let a=t[i];a[n]===this.id&&(!e||a.type===e)&&r.push(a)}return r}_resolveTickFontOptions(e){return $(this.options.ticks.setContext(this.getContext(e)).font)}_maxDigits(){let e=this._resolveTickFontOptions(0).lineHeight;return(this.isHorizontal()?this.width:this.height)/e}},Wu=class{constructor(e,t,n){this.type=e,this.scope=t,this.override=n,this.items=Object.create(null)}isForType(e){return Object.prototype.isPrototypeOf.call(this.type.prototype,e.prototype)}register(e){let t=Object.getPrototypeOf(e),n;qu(t)&&(n=this.register(t));let r=this.items,i=e.id,a=this.scope+`.`+i;if(!i)throw Error(`class does not have id: `+e);return i in r?a:(r[i]=e,Gu(e,a,n),this.override&&Z.override(e.id,e.overrides),a)}get(e){return this.items[e]}unregister(e){let t=this.items,n=e.id,r=this.scope;n in t&&delete t[n],r&&n in Z[r]&&(delete Z[r][n],this.override&&delete ys[n])}};function Gu(e,t,n){let r=ro(Object.create(null),[n?Z.get(n):{},Z.get(t),e.defaults]);Z.set(t,r),e.defaultRoutes&&Ku(t,e.defaultRoutes),e.descriptors&&Z.describe(t,e.descriptors)}function Ku(e,t){Object.keys(t).forEach(n=>{let r=n.split(`.`),i=r.pop(),a=[e].concat(r).join(`.`),o=t[n].split(`.`),s=o.pop(),c=o.join(`.`);Z.route(a,i,c,s)})}function qu(e){return`id`in e&&`defaults`in e}var Ju=new class{constructor(){this.controllers=new Wu(ll,`datasets`,!0),this.elements=new Wu(Cu,`elements`),this.plugins=new Wu(Object,`plugins`),this.scales=new Wu(Uu,`scales`),this._typedRegistries=[this.controllers,this.scales,this.elements]}add(...e){this._each(`register`,e)}remove(...e){this._each(`unregister`,e)}addControllers(...e){this._each(`register`,e,this.controllers)}addElements(...e){this._each(`register`,e,this.elements)}addPlugins(...e){this._each(`register`,e,this.plugins)}addScales(...e){this._each(`register`,e,this.scales)}getController(e){return this._get(e,this.controllers,`controller`)}getElement(e){return this._get(e,this.elements,`element`)}getPlugin(e){return this._get(e,this.plugins,`plugin`)}getScale(e){return this._get(e,this.scales,`scale`)}removeControllers(...e){this._each(`unregister`,e,this.controllers)}removeElements(...e){this._each(`unregister`,e,this.elements)}removePlugins(...e){this._each(`unregister`,e,this.plugins)}removeScales(...e){this._each(`unregister`,e,this.scales)}_each(e,t,n){[...t].forEach(t=>{let r=n||this._getRegistryForType(t);n||r.isForType(t)||r===this.plugins&&t.id?this._exec(e,r,t):Y(t,t=>{let r=n||this._getRegistryForType(t);this._exec(e,r,t)})})}_exec(e,t,n){let r=uo(e);J(n[`before`+r],[],n),t[e](n),J(n[`after`+r],[],n)}_getRegistryForType(e){for(let t=0;t<this._typedRegistries.length;t++){let n=this._typedRegistries[t];if(n.isForType(e))return n}return this.plugins}_get(e,t,n){let r=t.get(e);if(r===void 0)throw Error(`"`+e+`" is not a registered `+n+`.`);return r}},Yu=class{constructor(){this._init=void 0}notify(e,t,n,r){if(t===`beforeInit`&&(this._init=this._createDescriptors(e,!0),this._notify(this._init,e,`install`)),this._init===void 0)return;let i=r?this._descriptors(e).filter(r):this._descriptors(e),a=this._notify(i,e,t,n);return t===`afterDestroy`&&(this._notify(i,e,`stop`),this._notify(this._init,e,`uninstall`),this._init=void 0),a}_notify(e,t,n,r){r||={};for(let i of e){let e=i.plugin,a=e[n];if(J(a,[t,r,i.options],e)===!1&&r.cancelable)return!1}return!0}invalidate(){U(this._cache)||(this._oldCache=this._cache,this._cache=void 0)}_descriptors(e){if(this._cache)return this._cache;let t=this._cache=this._createDescriptors(e);return this._notifyStateChanges(e),t}_createDescriptors(e,t){let n=e&&e.config,r=q(n.options&&n.options.plugins,{}),i=Xu(n);return r===!1&&!t?[]:Qu(e,i,r,t)}_notifyStateChanges(e){let t=this._oldCache||[],n=this._cache,r=(e,t)=>e.filter(e=>!t.some(t=>e.plugin.id===t.plugin.id));this._notify(r(t,n),e,`stop`),this._notify(r(n,t),e,`start`)}};function Xu(e){let t={},n=[],r=Object.keys(Ju.plugins.items);for(let e=0;e<r.length;e++)n.push(Ju.getPlugin(r[e]));let i=e.plugins||[];for(let e=0;e<i.length;e++){let r=i[e];n.indexOf(r)===-1&&(n.push(r),t[r.id]=!0)}return{plugins:n,localIds:t}}function Zu(e,t){return!t&&e===!1?null:e===!0?{}:e}function Qu(e,{plugins:t,localIds:n},r,i){let a=[],o=e.getContext();for(let s of t){let t=s.id,c=Zu(r[t],i);c!==null&&a.push({plugin:s,options:$u(e.config,{plugin:s,local:n[t]},c,o)})}return a}function $u(e,{plugin:t,local:n},r,i){let a=e.pluginScopeKeys(t),o=e.getOptionScopes(r,a);return n&&t.defaults&&o.push(t.defaults),e.createResolver(o,i,[``],{scriptable:!1,indexable:!1,allKeys:!0})}function ed(e,t){let n=Z.datasets[e]||{};return((t.datasets||{})[e]||{}).indexAxis||t.indexAxis||n.indexAxis||`x`}function td(e,t){let n=e;return e===`_index_`?n=t:e===`_value_`&&(n=t===`x`?`y`:`x`),n}function nd(e,t){return e===t?`_index_`:`_value_`}function rd(e){if(e===`x`||e===`y`||e===`r`)return e}function id(e){if(e===`top`||e===`bottom`)return`x`;if(e===`left`||e===`right`)return`y`}function ad(e,...t){if(rd(e))return e;for(let n of t){let t=n.axis||id(n.position)||e.length>1&&rd(e[0].toLowerCase());if(t)return t}throw Error(`Cannot determine type of '${e}' axis. Please provide 'axis' or 'position' option.`)}function od(e,t,n){if(n[t+`AxisID`]===e)return{axis:t}}function sd(e,t){if(t.data&&t.data.datasets){let n=t.data.datasets.filter(t=>t.xAxisID===e||t.yAxisID===e);if(n.length)return od(e,`x`,n[0])||od(e,`y`,n[0])}return{}}function cd(e,t){let n=ys[e.type]||{scales:{}},r=t.scales||{},i=ed(e.type,t),a=Object.create(null);return Object.keys(r).forEach(t=>{let o=r[t];if(!G(o))return console.error(`Invalid scale configuration for scale: ${t}`);if(o._proxy)return console.warn(`Ignoring resolver passed as options for scale: ${t}`);let s=ad(t,o,sd(t,e),Z.scales[o.type]),c=nd(s,i),l=n.scales||{};a[t]=io(Object.create(null),[{axis:s},o,l[s],l[c]])}),e.data.datasets.forEach(n=>{let i=n.type||e.type,o=n.indexAxis||ed(i,t),s=(ys[i]||{}).scales||{};Object.keys(s).forEach(e=>{let t=td(e,o),i=n[t+`AxisID`]||t;a[i]=a[i]||Object.create(null),io(a[i],[{axis:t},r[i],s[e]])})}),Object.keys(a).forEach(e=>{let t=a[e];io(t,[Z.scales[t.type],Z.scale])}),a}function ld(e){let t=e.options||={};t.plugins=q(t.plugins,{}),t.scales=cd(e,t)}function ud(e){return e||={},e.datasets=e.datasets||[],e.labels=e.labels||[],e}function dd(e){return e||={},e.data=ud(e.data),ld(e),e}var fd=new Map,pd=new Set;function md(e,t){let n=fd.get(e);return n||(n=t(),fd.set(e,n),pd.add(n)),n}var hd=(e,t,n)=>{let r=lo(t,n);r!==void 0&&e.add(r)},gd=class{constructor(e){this._config=dd(e),this._scopeCache=new Map,this._resolverCache=new Map}get platform(){return this._config.platform}get type(){return this._config.type}set type(e){this._config.type=e}get data(){return this._config.data}set data(e){this._config.data=ud(e)}get options(){return this._config.options}set options(e){this._config.options=e}get plugins(){return this._config.plugins}update(){let e=this._config;this.clearCache(),ld(e)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(e){return md(e,()=>[[`datasets.${e}`,``]])}datasetAnimationScopeKeys(e,t){return md(`${e}.transition.${t}`,()=>[[`datasets.${e}.transitions.${t}`,`transitions.${t}`],[`datasets.${e}`,``]])}datasetElementScopeKeys(e,t){return md(`${e}-${t}`,()=>[[`datasets.${e}.elements.${t}`,`datasets.${e}`,`elements.${t}`,``]])}pluginScopeKeys(e){let t=e.id,n=this.type;return md(`${n}-plugin-${t}`,()=>[[`plugins.${t}`,...e.additionalOptionScopes||[]]])}_cachedScopes(e,t){let n=this._scopeCache,r=n.get(e);return(!r||t)&&(r=new Map,n.set(e,r)),r}getOptionScopes(e,t,n){let{options:r,type:i}=this,a=this._cachedScopes(e,n),o=a.get(t);if(o)return o;let s=new Set;t.forEach(t=>{e&&(s.add(e),t.forEach(t=>hd(s,e,t))),t.forEach(e=>hd(s,r,e)),t.forEach(e=>hd(s,ys[i]||{},e)),t.forEach(e=>hd(s,Z,e)),t.forEach(e=>hd(s,bs,e))});let c=Array.from(s);return c.length===0&&c.push(Object.create(null)),pd.has(t)&&a.set(t,c),c}chartOptionScopes(){let{options:e,type:t}=this;return[e,ys[t]||{},Z.datasets[t]||{},{type:t},Z,bs]}resolveNamedOptions(e,t,n,r=[``]){let i={$shared:!0},{resolver:a,subPrefixes:o}=_d(this._resolverCache,e,r),s=a;if(yd(a,t)){i.$shared=!1,n=po(n)?n():n;let t=this.createResolver(e,n,o);s=Ys(a,n,t)}for(let e of t)i[e]=s[e];return i}createResolver(e,t,n=[``],r){let{resolver:i}=_d(this._resolverCache,e,n);return G(t)?Ys(i,t,void 0,r):i}};function _d(e,t,n){let r=e.get(t);r||(r=new Map,e.set(t,r));let i=n.join(),a=r.get(i);return a||(a={resolver:Js(t,n),subPrefixes:n.filter(e=>!e.toLowerCase().includes(`hover`))},r.set(i,a)),a}var vd=e=>G(e)&&Object.getOwnPropertyNames(e).some(t=>po(e[t]));function yd(e,t){let{isScriptable:n,isIndexable:r}=Xs(e);for(let i of t){let t=n(i),a=r(i),o=(a||t)&&e[i];if(t&&(po(o)||vd(o))||a&&W(o))return!0}return!1}var bd=`4.5.1`,xd=[`top`,`bottom`,`left`,`right`,`chartArea`];function Sd(e,t){return e===`top`||e===`bottom`||xd.indexOf(e)===-1&&t===`x`}function Cd(e,t){return function(n,r){return n[e]===r[e]?n[t]-r[t]:n[e]-r[e]}}function wd(e){let t=e.chart,n=t.options.animation;t.notifyPlugins(`afterRender`),J(n&&n.onComplete,[e],t)}function Td(e){let t=e.chart,n=t.options.animation;J(n&&n.onProgress,[e],t)}function Ed(e){return pc()&&typeof e==`string`?e=document.getElementById(e):e&&e.length&&(e=e[0]),e&&e.canvas&&(e=e.canvas),e}var Dd={},Od=e=>{let t=Ed(e);return Object.values(Dd).filter(e=>e.canvas===t).pop()};function kd(e,t,n){let r=Object.keys(e);for(let i of r){let r=+i;if(r>=t){let a=e[i];delete e[i],(n>0||r>t)&&(e[r+n]=a)}}}function Ad(e,t,n,r){return!n||e.type===`mouseout`?null:r?t:e}var jd=class{static defaults=Z;static instances=Dd;static overrides=ys;static registry=Ju;static version=bd;static getChart=Od;static register(...e){Ju.add(...e),Md()}static unregister(...e){Ju.remove(...e),Md()}constructor(e,t){let n=this.config=new gd(t),r=Ed(e),i=Od(r);if(i)throw Error(`Canvas is already in use. Chart with ID '`+i.id+`' must be destroyed before the canvas with ID '`+i.canvas.id+`' can be reused.`);let a=n.createResolver(n.chartOptionScopes(),this.getContext());this.platform=new(n.platform||(Su(r))),this.platform.updateConfig(n);let o=this.platform.acquireContext(r,a.aspectRatio),s=o&&o.canvas,c=s&&s.height,l=s&&s.width;if(this.id=Xa(),this.ctx=o,this.canvas=s,this.width=l,this.height=c,this._options=a,this._aspectRatio=this.aspectRatio,this._layers=[],this._metasets=[],this._stacks=void 0,this.boxes=[],this.currentDevicePixelRatio=void 0,this.chartArea=void 0,this._active=[],this._lastEvent=void 0,this._listeners={},this._responsiveListeners=void 0,this._sortedMetasets=[],this.scales={},this._plugins=new Yu,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=Zo(e=>this.update(e),a.resizeDelay||0),this._dataChanges=[],Dd[this.id]=this,!o||!s){console.error(`Failed to create chart: can't acquire context from the given item`);return}Lc.listen(this,`complete`,wd),Lc.listen(this,`progress`,Td),this._initialize(),this.attached&&this.update()}get aspectRatio(){let{options:{aspectRatio:e,maintainAspectRatio:t},width:n,height:r,_aspectRatio:i}=this;return U(e)?t&&i?i:r?n/r:null:e}get data(){return this.config.data}set data(e){this.config.data=e}get options(){return this._options}set options(e){this.config.options=e}get registry(){return Ju}_initialize(){return this.notifyPlugins(`beforeInit`),this.options.responsive?this.resize():Ec(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins(`afterInit`),this}clear(){return Ds(this.canvas,this.ctx),this}stop(){return Lc.stop(this),this}resize(e,t){Lc.running(this)?this._resizeBeforeDraw={width:e,height:t}:this._resize(e,t)}_resize(e,t){let n=this.options,r=this.canvas,i=n.maintainAspectRatio&&this.aspectRatio,a=this.platform.getMaximumSize(r,e,t,i),o=n.devicePixelRatio||this.platform.getDevicePixelRatio(),s=this.width?`resize`:`attach`;this.width=a.width,this.height=a.height,this._aspectRatio=this.aspectRatio,Ec(this,o,!0)&&(this.notifyPlugins(`resize`,{size:a}),J(n.onResize,[this,a],this),this.attached&&this._doResize(s)&&this.render())}ensureScalesHaveIDs(){Y(this.options.scales||{},(e,t)=>{e.id=t})}buildOrUpdateScales(){let e=this.options,t=e.scales,n=this.scales,r=Object.keys(n).reduce((e,t)=>(e[t]=!1,e),{}),i=[];t&&(i=i.concat(Object.keys(t).map(e=>{let n=t[e],r=ad(e,n),i=r===`r`,a=r===`x`;return{options:n,dposition:i?`chartArea`:a?`bottom`:`left`,dtype:i?`radialLinear`:a?`category`:`linear`}}))),Y(i,t=>{let i=t.options,a=i.id,o=ad(a,i),s=q(i.type,t.dtype);(i.position===void 0||Sd(i.position,o)!==Sd(t.dposition))&&(i.position=t.dposition),r[a]=!0;let c=null;a in n&&n[a].type===s?c=n[a]:(c=new(Ju.getScale(s))({id:a,type:s,ctx:this.ctx,chart:this}),n[c.id]=c),c.init(i,e)}),Y(r,(e,t)=>{e||delete n[t]}),Y(n,e=>{$l.configure(this,e,e.options),$l.addBox(this,e)})}_updateMetasets(){let e=this._metasets,t=this.data.datasets.length,n=e.length;if(e.sort((e,t)=>e.index-t.index),n>t){for(let e=t;e<n;++e)this._destroyDatasetMeta(e);e.splice(t,n-t)}this._sortedMetasets=e.slice(0).sort(Cd(`order`,`index`))}_removeUnreferencedMetasets(){let{_metasets:e,data:{datasets:t}}=this;e.length>t.length&&delete this._stacks,e.forEach((e,n)=>{t.filter(t=>t===e._dataset).length===0&&this._destroyDatasetMeta(n)})}buildOrUpdateControllers(){let e=[],t=this.data.datasets,n,r;for(this._removeUnreferencedMetasets(),n=0,r=t.length;n<r;n++){let r=t[n],i=this.getDatasetMeta(n),a=r.type||this.config.type;if(i.type&&i.type!==a&&(this._destroyDatasetMeta(n),i=this.getDatasetMeta(n)),i.type=a,i.indexAxis=r.indexAxis||ed(a,this.options),i.order=r.order||0,i.index=n,i.label=``+r.label,i.visible=this.isDatasetVisible(n),i.controller)i.controller.updateIndex(n),i.controller.linkScales();else{let t=Ju.getController(a),{datasetElementType:r,dataElementType:o}=Z.datasets[a];Object.assign(t,{dataElementType:Ju.getElement(o),datasetElementType:r&&Ju.getElement(r)}),i.controller=new t(this,n),e.push(i.controller)}}return this._updateMetasets(),e}_resetElements(){Y(this.data.datasets,(e,t)=>{this.getDatasetMeta(t).controller.reset()},this)}reset(){this._resetElements(),this.notifyPlugins(`reset`)}update(e){let t=this.config;t.update();let n=this._options=t.createResolver(t.chartOptionScopes(),this.getContext()),r=this._animationsDisabled=!n.animation;if(this._updateScales(),this._checkEventBindings(),this._updateHiddenIndices(),this._plugins.invalidate(),this.notifyPlugins(`beforeUpdate`,{mode:e,cancelable:!0})===!1)return;let i=this.buildOrUpdateControllers();this.notifyPlugins(`beforeElementsUpdate`);let a=0;for(let e=0,t=this.data.datasets.length;e<t;e++){let{controller:t}=this.getDatasetMeta(e),n=!r&&i.indexOf(t)===-1;t.buildOrUpdateElements(n),a=Math.max(+t.getMaxOverflow(),a)}a=this._minPadding=n.layout.autoPadding?a:0,this._updateLayout(a),r||Y(i,e=>{e.reset()}),this._updateDatasets(e),this.notifyPlugins(`afterUpdate`,{mode:e}),this._layers.sort(Cd(`z`,`_idx`));let{_active:o,_lastEvent:s}=this;s?this._eventHandler(s,!0):o.length&&this._updateHoverStyles(o,o,!0),this.render()}_updateScales(){Y(this.scales,e=>{$l.removeBox(this,e)}),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){let e=this.options;(!mo(new Set(Object.keys(this._listeners)),new Set(e.events))||!!this._responsiveListeners!==e.responsive)&&(this.unbindEvents(),this.bindEvents())}_updateHiddenIndices(){let{_hiddenIndices:e}=this,t=this._getUniformDataChanges()||[];for(let{method:n,start:r,count:i}of t)kd(e,r,n===`_removeElements`?-i:i)}_getUniformDataChanges(){let e=this._dataChanges;if(!e||!e.length)return;this._dataChanges=[];let t=this.data.datasets.length,n=t=>new Set(e.filter(e=>e[0]===t).map((e,t)=>t+`,`+e.splice(1).join(`,`))),r=n(0);for(let e=1;e<t;e++)if(!mo(r,n(e)))return;return Array.from(r).map(e=>e.split(`,`)).map(e=>({method:e[1],start:+e[2],count:+e[3]}))}_updateLayout(e){if(this.notifyPlugins(`beforeLayout`,{cancelable:!0})===!1)return;$l.update(this,this.width,this.height,e);let t=this.chartArea,n=t.width<=0||t.height<=0;this._layers=[],Y(this.boxes,e=>{n&&e.position===`chartArea`||(e.configure&&e.configure(),this._layers.push(...e._layers()))},this),this._layers.forEach((e,t)=>{e._idx=t}),this.notifyPlugins(`afterLayout`)}_updateDatasets(e){if(this.notifyPlugins(`beforeDatasetsUpdate`,{mode:e,cancelable:!0})!==!1){for(let e=0,t=this.data.datasets.length;e<t;++e)this.getDatasetMeta(e).controller.configure();for(let t=0,n=this.data.datasets.length;t<n;++t)this._updateDataset(t,po(e)?e({datasetIndex:t}):e);this.notifyPlugins(`afterDatasetsUpdate`,{mode:e})}}_updateDataset(e,t){let n=this.getDatasetMeta(e),r={meta:n,index:e,mode:t,cancelable:!0};this.notifyPlugins(`beforeDatasetUpdate`,r)!==!1&&(n.controller._update(t),r.cancelable=!1,this.notifyPlugins(`afterDatasetUpdate`,r))}render(){this.notifyPlugins(`beforeRender`,{cancelable:!0})!==!1&&(Lc.has(this)?this.attached&&!Lc.running(this)&&Lc.start(this):(this.draw(),wd({chart:this})))}draw(){let e;if(this._resizeBeforeDraw){let{width:e,height:t}=this._resizeBeforeDraw;this._resizeBeforeDraw=null,this._resize(e,t)}if(this.clear(),this.width<=0||this.height<=0||this.notifyPlugins(`beforeDraw`,{cancelable:!0})===!1)return;let t=this._layers;for(e=0;e<t.length&&t[e].z<=0;++e)t[e].draw(this.chartArea);for(this._drawDatasets();e<t.length;++e)t[e].draw(this.chartArea);this.notifyPlugins(`afterDraw`)}_getSortedDatasetMetas(e){let t=this._sortedMetasets,n=[],r,i;for(r=0,i=t.length;r<i;++r){let i=t[r];(!e||i.visible)&&n.push(i)}return n}getSortedVisibleDatasetMetas(){return this._getSortedDatasetMetas(!0)}_drawDatasets(){if(this.notifyPlugins(`beforeDatasetsDraw`,{cancelable:!0})===!1)return;let e=this.getSortedVisibleDatasetMetas();for(let t=e.length-1;t>=0;--t)this._drawDataset(e[t]);this.notifyPlugins(`afterDatasetsDraw`)}_drawDataset(e){let t=this.ctx,n={meta:e,index:e.index,cancelable:!0},r=Ic(this,e);this.notifyPlugins(`beforeDatasetDraw`,n)!==!1&&(r&&js(t,r),e.controller.draw(),r&&Ms(t),n.cancelable=!1,this.notifyPlugins(`afterDatasetDraw`,n))}isPointInArea(e){return As(e,this.chartArea,this._minPadding)}getElementsAtEventForMode(e,t,n,r){let i=Il.modes[t];return typeof i==`function`?i(this,e,n,r):[]}getDatasetMeta(e){let t=this.data.datasets[e],n=this._metasets,r=n.filter(e=>e&&e._dataset===t).pop();return r||(r={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:t&&t.order||0,index:e,_dataset:t,_parsed:[],_sorted:!1},n.push(r)),r}getContext(){return this.$context||=qs(null,{chart:this,type:`chart`})}getVisibleDatasetCount(){return this.getSortedVisibleDatasetMetas().length}isDatasetVisible(e){let t=this.data.datasets[e];if(!t)return!1;let n=this.getDatasetMeta(e);return typeof n.hidden==`boolean`?!n.hidden:!t.hidden}setDatasetVisibility(e,t){let n=this.getDatasetMeta(e);n.hidden=!t}toggleDataVisibility(e){this._hiddenIndices[e]=!this._hiddenIndices[e]}getDataVisibility(e){return!this._hiddenIndices[e]}_updateVisibility(e,t,n){let r=n?`show`:`hide`,i=this.getDatasetMeta(e),a=i.controller._resolveAnimations(void 0,r);fo(t)?(i.data[t].hidden=!n,this.update()):(this.setDatasetVisibility(e,n),a.update(i,{visible:n}),this.update(t=>t.datasetIndex===e?r:void 0))}hide(e,t){this._updateVisibility(e,t,!1)}show(e,t){this._updateVisibility(e,t,!0)}_destroyDatasetMeta(e){let t=this._metasets[e];t&&t.controller&&t.controller._destroy(),delete this._metasets[e]}_stop(){let e,t;for(this.stop(),Lc.remove(this),e=0,t=this.data.datasets.length;e<t;++e)this._destroyDatasetMeta(e)}destroy(){this.notifyPlugins(`beforeDestroy`);let{canvas:e,ctx:t}=this;this._stop(),this.config.clearCache(),e&&(this.unbindEvents(),Ds(e,t),this.platform.releaseContext(t),this.canvas=null,this.ctx=null),delete Dd[this.id],this.notifyPlugins(`afterDestroy`)}toBase64Image(...e){return this.canvas.toDataURL(...e)}bindEvents(){this.bindUserEvents(),this.options.responsive?this.bindResponsiveEvents():this.attached=!0}bindUserEvents(){let e=this._listeners,t=this.platform,n=(n,r)=>{t.addEventListener(this,n,r),e[n]=r},r=(e,t,n)=>{e.offsetX=t,e.offsetY=n,this._eventHandler(e)};Y(this.options.events,e=>n(e,r))}bindResponsiveEvents(){this._responsiveListeners||={};let e=this._responsiveListeners,t=this.platform,n=(n,r)=>{t.addEventListener(this,n,r),e[n]=r},r=(n,r)=>{e[n]&&(t.removeEventListener(this,n,r),delete e[n])},i=(e,t)=>{this.canvas&&this.resize(e,t)},a,o=()=>{r(`attach`,o),this.attached=!0,this.resize(),n(`resize`,i),n(`detach`,a)};a=()=>{this.attached=!1,r(`resize`,i),this._stop(),this._resize(0,0),n(`attach`,o)},t.isAttached(this.canvas)?o():a()}unbindEvents(){Y(this._listeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._listeners={},Y(this._responsiveListeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._responsiveListeners=void 0}updateHoverStyle(e,t,n){let r=n?`set`:`remove`,i,a,o,s;for(t===`dataset`&&(i=this.getDatasetMeta(e[0].datasetIndex),i.controller[`_`+r+`DatasetHoverStyle`]()),o=0,s=e.length;o<s;++o){a=e[o];let t=a&&this.getDatasetMeta(a.datasetIndex).controller;t&&t[r+`HoverStyle`](a.element,a.datasetIndex,a.index)}}getActiveElements(){return this._active||[]}setActiveElements(e){let t=this._active||[],n=e.map(({datasetIndex:e,index:t})=>{let n=this.getDatasetMeta(e);if(!n)throw Error(`No dataset found at index `+e);return{datasetIndex:e,element:n.data[t],index:t}});$a(n,t)||(this._active=n,this._lastEvent=null,this._updateHoverStyles(n,t))}notifyPlugins(e,t,n){return this._plugins.notify(this,e,t,n)}isPluginEnabled(e){return this._plugins._cache.filter(t=>t.plugin.id===e).length===1}_updateHoverStyles(e,t,n){let r=this.options.hover,i=(e,t)=>e.filter(e=>!t.some(t=>e.datasetIndex===t.datasetIndex&&e.index===t.index)),a=i(t,e),o=n?e:i(e,t);a.length&&this.updateHoverStyle(a,r.mode,!1),o.length&&r.mode&&this.updateHoverStyle(o,r.mode,!0)}_eventHandler(e,t){let n={event:e,replay:t,cancelable:!0,inChartArea:this.isPointInArea(e)},r=t=>(t.options.events||this.options.events).includes(e.native.type);if(this.notifyPlugins(`beforeEvent`,n,r)===!1)return;let i=this._handleEvent(e,t,n.inChartArea);return n.cancelable=!1,this.notifyPlugins(`afterEvent`,n,r),(i||n.changed)&&this.render(),this}_handleEvent(e,t,n){let{_active:r=[],options:i}=this,a=t,o=this._getActiveElements(e,r,n,a),s=ho(e),c=Ad(e,this._lastEvent,n,s);n&&(this._lastEvent=null,J(i.onHover,[e,o,this],this),s&&J(i.onClick,[e,o,this],this));let l=!$a(o,r);return(l||t)&&(this._active=o,this._updateHoverStyles(o,r,t)),this._lastEvent=c,l}_getActiveElements(e,t,n,r){if(e.type===`mouseout`)return[];if(!n)return t;let i=this.options.hover;return this.getElementsAtEventForMode(e,i.mode,i,r)}};function Md(){return Y(jd.instances,e=>e._plugins.invalidate())}function Nd(e,t){let{x:n,y:r,base:i,width:a,height:o}=e.getProps([`x`,`y`,`base`,`width`,`height`],t),s,c,l,u,d;return e.horizontal?(d=o/2,s=Math.min(n,i),c=Math.max(n,i),l=r-d,u=r+d):(d=a/2,s=n-d,c=n+d,l=Math.min(r,i),u=Math.max(r,i)),{left:s,top:l,right:c,bottom:u}}function Pd(e,t,n,r){return e?0:Ro(t,n,r)}function Fd(e,t,n){let r=e.options.borderWidth,i=e.borderSkipped,a=Us(r);return{t:Pd(i.top,a.top,0,n),r:Pd(i.right,a.right,0,t),b:Pd(i.bottom,a.bottom,0,n),l:Pd(i.left,a.left,0,t)}}function Id(e,t,n){let{enableBorderRadius:r}=e.getProps([`enableBorderRadius`]),i=e.options.borderRadius,a=Ws(i),o=Math.min(t,n),s=e.borderSkipped,c=r||G(i);return{topLeft:Pd(!c||s.top||s.left,a.topLeft,0,o),topRight:Pd(!c||s.top||s.right,a.topRight,0,o),bottomLeft:Pd(!c||s.bottom||s.left,a.bottomLeft,0,o),bottomRight:Pd(!c||s.bottom||s.right,a.bottomRight,0,o)}}function Ld(e){let t=Nd(e),n=t.right-t.left,r=t.bottom-t.top,i=Fd(e,n/2,r/2),a=Id(e,n/2,r/2);return{outer:{x:t.left,y:t.top,w:n,h:r,radius:a},inner:{x:t.left+i.l,y:t.top+i.t,w:n-i.l-i.r,h:r-i.t-i.b,radius:{topLeft:Math.max(0,a.topLeft-Math.max(i.t,i.l)),topRight:Math.max(0,a.topRight-Math.max(i.t,i.r)),bottomLeft:Math.max(0,a.bottomLeft-Math.max(i.b,i.l)),bottomRight:Math.max(0,a.bottomRight-Math.max(i.b,i.r))}}}}function Rd(e,t,n,r){let i=t===null,a=n===null,o=e&&!(i&&a)&&Nd(e,r);return o&&(i||Bo(t,o.left,o.right))&&(a||Bo(n,o.top,o.bottom))}function zd(e){return e.topLeft||e.topRight||e.bottomLeft||e.bottomRight}function Bd(e,t){e.rect(t.x,t.y,t.w,t.h)}function Vd(e,t,n={}){let r=e.x===n.x?0:-t,i=e.y===n.y?0:-t,a=(e.x+e.w===n.x+n.w?0:t)-r,o=(e.y+e.h===n.y+n.h?0:t)-i;return{x:e.x+r,y:e.y+i,w:e.w+a,h:e.h+o,radius:e.radius}}var Hd=class extends Cu{static id=`bar`;static defaults={borderSkipped:`start`,borderWidth:0,borderRadius:0,inflateAmount:`auto`,pointStyle:void 0};static defaultRoutes={backgroundColor:`backgroundColor`,borderColor:`borderColor`};constructor(e){super(),this.options=void 0,this.horizontal=void 0,this.base=void 0,this.width=void 0,this.height=void 0,this.inflateAmount=void 0,e&&Object.assign(this,e)}draw(e){let{inflateAmount:t,options:{borderColor:n,backgroundColor:r}}=this,{inner:i,outer:a}=Ld(this),o=zd(a.radius)?Ls:Bd;e.save(),(a.w!==i.w||a.h!==i.h)&&(e.beginPath(),o(e,Vd(a,t,i)),e.clip(),o(e,Vd(i,-t,a)),e.fillStyle=n,e.fill(`evenodd`)),e.beginPath(),o(e,Vd(i,t)),e.fillStyle=r,e.fill(),e.restore()}inRange(e,t,n){return Rd(this,e,t,n)}inXRange(e,t){return Rd(this,e,null,t)}inYRange(e,t){return Rd(this,null,e,t)}getCenterPoint(e){let{x:t,y:n,base:r,horizontal:i}=this.getProps([`x`,`y`,`base`,`horizontal`],e);return{x:i?(t+r)/2:t,y:i?n:(n+r)/2}}getRange(e){return e===`x`?this.width/2:this.height/2}},Ud=(e,t)=>{let{boxHeight:n=t,boxWidth:r=t}=e;return e.usePointStyle&&(n=Math.min(n,t),r=e.pointStyleWidth||Math.min(r,t)),{boxWidth:r,boxHeight:n,itemHeight:Math.max(t,n)}},Wd=(e,t)=>e!==null&&t!==null&&e.datasetIndex===t.datasetIndex&&e.index===t.index,Gd=class extends Cu{constructor(e){super(),this._added=!1,this.legendHitBoxes=[],this._hoveredItem=null,this.doughnutMode=!1,this.chart=e.chart,this.options=e.options,this.ctx=e.ctx,this.legendItems=void 0,this.columnSizes=void 0,this.lineWidths=void 0,this.maxHeight=void 0,this.maxWidth=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.height=void 0,this.width=void 0,this._margins=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(e,t,n){this.maxWidth=e,this.maxHeight=t,this._margins=n,this.setDimensions(),this.buildLabels(),this.fit()}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=this._margins.left,this.right=this.width):(this.height=this.maxHeight,this.top=this._margins.top,this.bottom=this.height)}buildLabels(){let e=this.options.labels||{},t=J(e.generateLabels,[this.chart],this)||[];e.filter&&(t=t.filter(t=>e.filter(t,this.chart.data))),e.sort&&(t=t.sort((t,n)=>e.sort(t,n,this.chart.data))),this.options.reverse&&t.reverse(),this.legendItems=t}fit(){let{options:e,ctx:t}=this;if(!e.display){this.width=this.height=0;return}let n=e.labels,r=$(n.font),i=r.size,a=this._computeTitleHeight(),{boxWidth:o,itemHeight:s}=Ud(n,i),c,l;t.font=r.string,this.isHorizontal()?(c=this.maxWidth,l=this._fitRows(a,i,o,s)+10):(l=this.maxHeight,c=this._fitCols(a,r,o,s)+10),this.width=Math.min(c,e.maxWidth||this.maxWidth),this.height=Math.min(l,e.maxHeight||this.maxHeight)}_fitRows(e,t,n,r){let{ctx:i,maxWidth:a,options:{labels:{padding:o}}}=this,s=this.legendHitBoxes=[],c=this.lineWidths=[0],l=r+o,u=e;i.textAlign=`left`,i.textBaseline=`middle`;let d=-1,f=-l;return this.legendItems.forEach((e,p)=>{let m=n+t/2+i.measureText(e.text).width;(p===0||c[c.length-1]+m+2*o>a)&&(u+=l,c[c.length-(p>0?0:1)]=0,f+=l,d++),s[p]={left:0,top:f,row:d,width:m,height:r},c[c.length-1]+=m+o}),u}_fitCols(e,t,n,r){let{ctx:i,maxHeight:a,options:{labels:{padding:o}}}=this,s=this.legendHitBoxes=[],c=this.columnSizes=[],l=a-e,u=o,d=0,f=0,p=0,m=0;return this.legendItems.forEach((e,a)=>{let{itemWidth:h,itemHeight:g}=Kd(n,t,i,e,r);a>0&&f+g+2*o>l&&(u+=d+o,c.push({width:d,height:f}),p+=d+o,m++,d=f=0),s[a]={left:p,top:f,col:m,width:h,height:g},d=Math.max(d,h),f+=g+o}),u+=d,c.push({width:d,height:f}),u}adjustHitBoxes(){if(!this.options.display)return;let e=this._computeTitleHeight(),{legendHitBoxes:t,options:{align:n,labels:{padding:r},rtl:i}}=this,a=jc(i,this.left,this.width);if(this.isHorizontal()){let i=0,o=$o(n,this.left+r,this.right-this.lineWidths[i]);for(let s of t)i!==s.row&&(i=s.row,o=$o(n,this.left+r,this.right-this.lineWidths[i])),s.top+=this.top+e+r,s.left=a.leftForLtr(a.x(o),s.width),o+=s.width+r}else{let i=0,o=$o(n,this.top+e+r,this.bottom-this.columnSizes[i].height);for(let s of t)s.col!==i&&(i=s.col,o=$o(n,this.top+e+r,this.bottom-this.columnSizes[i].height)),s.top=o,s.left+=this.left+r,s.left=a.leftForLtr(a.x(s.left),s.width),o+=s.height+r}}isHorizontal(){return this.options.position===`top`||this.options.position===`bottom`}draw(){if(this.options.display){let e=this.ctx;js(e,this),this._draw(),Ms(e)}}_draw(){let{options:e,columnSizes:t,lineWidths:n,ctx:r}=this,{align:i,labels:a}=e,o=Z.color,s=jc(e.rtl,this.left,this.width),c=$(a.font),{padding:l}=a,u=c.size,d=u/2,f;this.drawTitle(),r.textAlign=s.textAlign(`left`),r.textBaseline=`middle`,r.lineWidth=.5,r.font=c.string;let{boxWidth:p,boxHeight:m,itemHeight:h}=Ud(a,u),g=function(e,t,n){if(isNaN(p)||p<=0||isNaN(m)||m<0)return;r.save();let i=q(n.lineWidth,1);if(r.fillStyle=q(n.fillStyle,o),r.lineCap=q(n.lineCap,`butt`),r.lineDashOffset=q(n.lineDashOffset,0),r.lineJoin=q(n.lineJoin,`miter`),r.lineWidth=i,r.strokeStyle=q(n.strokeStyle,o),r.setLineDash(q(n.lineDash,[])),a.usePointStyle){let o={radius:m*Math.SQRT2/2,pointStyle:n.pointStyle,rotation:n.rotation,borderWidth:i},c=s.xPlus(e,p/2),l=t+d;ks(r,o,c,l,a.pointStyleWidth&&p)}else{let a=t+Math.max((u-m)/2,0),o=s.leftForLtr(e,p),c=Ws(n.borderRadius);r.beginPath(),Object.values(c).some(e=>e!==0)?Ls(r,{x:o,y:a,w:p,h:m,radius:c}):r.rect(o,a,p,m),r.fill(),i!==0&&r.stroke()}r.restore()},_=function(e,t,n){Is(r,n.text,e,t+h/2,c,{strikethrough:n.hidden,textAlign:s.textAlign(n.textAlign)})},v=this.isHorizontal(),y=this._computeTitleHeight();f=v?{x:$o(i,this.left+l,this.right-n[0]),y:this.top+l+y,line:0}:{x:this.left+l,y:$o(i,this.top+y+l,this.bottom-t[0].height),line:0},Mc(this.ctx,e.textDirection);let b=h+l;this.legendItems.forEach((o,u)=>{r.strokeStyle=o.fontColor,r.fillStyle=o.fontColor;let m=r.measureText(o.text).width,h=s.textAlign(o.textAlign||=a.textAlign),x=p+d+m,S=f.x,C=f.y;s.setWidth(this.width),v?u>0&&S+x+l>this.right&&(C=f.y+=b,f.line++,S=f.x=$o(i,this.left+l,this.right-n[f.line])):u>0&&C+b>this.bottom&&(S=f.x=S+t[f.line].width+l,f.line++,C=f.y=$o(i,this.top+y+l,this.bottom-t[f.line].height));let w=s.x(S);if(g(w,C,o),S=es(h,S+p+d,v?S+x:this.right,e.rtl),_(s.x(S),C,o),v)f.x+=x+l;else if(typeof o.text!=`string`){let e=c.lineHeight;f.y+=Yd(o,e)+l}else f.y+=b}),Nc(this.ctx,e.textDirection)}drawTitle(){let e=this.options,t=e.title,n=$(t.font),r=Q(t.padding);if(!t.display)return;let i=jc(e.rtl,this.left,this.width),a=this.ctx,o=t.position,s=n.size/2,c=r.top+s,l,u=this.left,d=this.width;if(this.isHorizontal())d=Math.max(...this.lineWidths),l=this.top+c,u=$o(e.align,u,this.right-d);else{let t=this.columnSizes.reduce((e,t)=>Math.max(e,t.height),0);l=c+$o(e.align,this.top,this.bottom-t-e.labels.padding-this._computeTitleHeight())}let f=$o(o,u,u+d);a.textAlign=i.textAlign(Qo(o)),a.textBaseline=`middle`,a.strokeStyle=t.color,a.fillStyle=t.color,a.font=n.string,Is(a,t.text,f,l,n)}_computeTitleHeight(){let e=this.options.title,t=$(e.font),n=Q(e.padding);return e.display?t.lineHeight+n.height:0}_getLegendItemAt(e,t){let n,r,i;if(Bo(e,this.left,this.right)&&Bo(t,this.top,this.bottom)){for(i=this.legendHitBoxes,n=0;n<i.length;++n)if(r=i[n],Bo(e,r.left,r.left+r.width)&&Bo(t,r.top,r.top+r.height))return this.legendItems[n]}return null}handleEvent(e){let t=this.options;if(!Xd(e.type,t))return;let n=this._getLegendItemAt(e.x,e.y);if(e.type===`mousemove`||e.type===`mouseout`){let r=this._hoveredItem,i=Wd(r,n);r&&!i&&J(t.onLeave,[e,r,this],this),this._hoveredItem=n,n&&!i&&J(t.onHover,[e,n,this],this)}else n&&J(t.onClick,[e,n,this],this)}};function Kd(e,t,n,r,i){return{itemWidth:qd(r,e,t,n),itemHeight:Jd(i,r,t.lineHeight)}}function qd(e,t,n,r){let i=e.text;return i&&typeof i!=`string`&&(i=i.reduce((e,t)=>e.length>t.length?e:t)),t+n.size/2+r.measureText(i).width}function Jd(e,t,n){let r=e;return typeof t.text!=`string`&&(r=Yd(t,n)),r}function Yd(e,t){return t*(e.text?e.text.length:0)}function Xd(e,t){return!!((e===`mousemove`||e===`mouseout`)&&(t.onHover||t.onLeave)||t.onClick&&(e===`click`||e===`mouseup`))}var Zd={id:`legend`,_element:Gd,start(e,t,n){let r=e.legend=new Gd({ctx:e.ctx,options:n,chart:e});$l.configure(e,r,n),$l.addBox(e,r)},stop(e){$l.removeBox(e,e.legend),delete e.legend},beforeUpdate(e,t,n){let r=e.legend;$l.configure(e,r,n),r.options=n},afterUpdate(e){let t=e.legend;t.buildLabels(),t.adjustHitBoxes()},afterEvent(e,t){t.replay||e.legend.handleEvent(t.event)},defaults:{display:!0,position:`top`,align:`center`,fullSize:!0,reverse:!1,weight:1e3,onClick(e,t,n){let r=t.datasetIndex,i=n.chart;i.isDatasetVisible(r)?(i.hide(r),t.hidden=!0):(i.show(r),t.hidden=!1)},onHover:null,onLeave:null,labels:{color:e=>e.chart.options.color,boxWidth:40,padding:10,generateLabels(e){let t=e.data.datasets,{labels:{usePointStyle:n,pointStyle:r,textAlign:i,color:a,useBorderRadius:o,borderRadius:s}}=e.legend.options;return e._getSortedDatasetMetas().map(e=>{let c=e.controller.getStyle(n?0:void 0),l=Q(c.borderWidth);return{text:t[e.index].label,fillStyle:c.backgroundColor,fontColor:a,hidden:!e.visible,lineCap:c.borderCapStyle,lineDash:c.borderDash,lineDashOffset:c.borderDashOffset,lineJoin:c.borderJoinStyle,lineWidth:(l.width+l.height)/4,strokeStyle:c.borderColor,pointStyle:r||c.pointStyle,rotation:c.rotation,textAlign:i||c.textAlign,borderRadius:o&&(s||c.borderRadius),datasetIndex:e.index}},this)}},title:{color:e=>e.chart.options.color,display:!1,position:`center`,text:``}},descriptors:{_scriptable:e=>!e.startsWith(`on`),labels:{_scriptable:e=>![`generateLabels`,`filter`,`sort`].includes(e)}}},Qd={average(e){if(!e.length)return!1;let t,n,r=new Set,i=0,a=0;for(t=0,n=e.length;t<n;++t){let n=e[t].element;if(n&&n.hasValue()){let e=n.tooltipPosition();r.add(e.x),i+=e.y,++a}}return a===0||r.size===0?!1:{x:[...r].reduce((e,t)=>e+t)/r.size,y:i/a}},nearest(e,t){if(!e.length)return!1;let n=t.x,r=t.y,i=1/0,a,o,s;for(a=0,o=e.length;a<o;++a){let n=e[a].element;if(n&&n.hasValue()){let e=Fo(t,n.getCenterPoint());e<i&&(i=e,s=n)}}if(s){let e=s.tooltipPosition();n=e.x,r=e.y}return{x:n,y:r}}};function $d(e,t){return t&&(W(t)?Array.prototype.push.apply(e,t):e.push(t)),e}function ef(e){return(typeof e==`string`||e instanceof String)&&e.indexOf(`
`)>-1?e.split(`
`):e}function tf(e,t){let{element:n,datasetIndex:r,index:i}=t,a=e.getDatasetMeta(r).controller,{label:o,value:s}=a.getLabelAndValue(i);return{chart:e,label:o,parsed:a.getParsed(i),raw:e.data.datasets[r].data[i],formattedValue:s,dataset:a.getDataset(),dataIndex:i,datasetIndex:r,element:n}}function nf(e,t){let n=e.chart.ctx,{body:r,footer:i,title:a}=e,{boxWidth:o,boxHeight:s}=t,c=$(t.bodyFont),l=$(t.titleFont),u=$(t.footerFont),d=a.length,f=i.length,p=r.length,m=Q(t.padding),h=m.height,g=0,_=r.reduce((e,t)=>e+t.before.length+t.lines.length+t.after.length,0);if(_+=e.beforeBody.length+e.afterBody.length,d&&(h+=d*l.lineHeight+(d-1)*t.titleSpacing+t.titleMarginBottom),_){let e=t.displayColors?Math.max(s,c.lineHeight):c.lineHeight;h+=p*e+(_-p)*c.lineHeight+(_-1)*t.bodySpacing}f&&(h+=t.footerMarginTop+f*u.lineHeight+(f-1)*t.footerSpacing);let v=0,y=function(e){g=Math.max(g,n.measureText(e).width+v)};return n.save(),n.font=l.string,Y(e.title,y),n.font=c.string,Y(e.beforeBody.concat(e.afterBody),y),v=t.displayColors?o+2+t.boxPadding:0,Y(r,e=>{Y(e.before,y),Y(e.lines,y),Y(e.after,y)}),v=0,n.font=u.string,Y(e.footer,y),n.restore(),g+=m.width,{width:g,height:h}}function rf(e,t){let{y:n,height:r}=t;return n<r/2?`top`:n>e.height-r/2?`bottom`:`center`}function af(e,t,n,r){let{x:i,width:a}=r,o=n.caretSize+n.caretPadding;if(e===`left`&&i+a+o>t.width||e===`right`&&i-a-o<0)return!0}function of(e,t,n,r){let{x:i,width:a}=n,{width:o,chartArea:{left:s,right:c}}=e,l=`center`;return r===`center`?l=i<=(s+c)/2?`left`:`right`:i<=a/2?l=`left`:i>=o-a/2&&(l=`right`),af(l,e,t,n)&&(l=`center`),l}function sf(e,t,n){let r=n.yAlign||t.yAlign||rf(e,n);return{xAlign:n.xAlign||t.xAlign||of(e,t,n,r),yAlign:r}}function cf(e,t){let{x:n,width:r}=e;return t===`right`?n-=r:t===`center`&&(n-=r/2),n}function lf(e,t,n){let{y:r,height:i}=e;return t===`top`?r+=n:r-=t===`bottom`?i+n:i/2,r}function uf(e,t,n,r){let{caretSize:i,caretPadding:a,cornerRadius:o}=e,{xAlign:s,yAlign:c}=n,l=i+a,{topLeft:u,topRight:d,bottomLeft:f,bottomRight:p}=Ws(o),m=cf(t,s),h=lf(t,c,l);return c===`center`?s===`left`?m+=l:s===`right`&&(m-=l):s===`left`?m-=Math.max(u,f)+i:s===`right`&&(m+=Math.max(d,p)+i),{x:Ro(m,0,r.width-t.width),y:Ro(h,0,r.height-t.height)}}function df(e,t,n){let r=Q(n.padding);return t===`center`?e.x+e.width/2:t===`right`?e.x+e.width-r.right:e.x+r.left}function ff(e){return $d([],ef(e))}function pf(e,t,n){return qs(e,{tooltip:t,tooltipItems:n,type:`tooltip`})}function mf(e,t){let n=t&&t.dataset&&t.dataset.tooltip&&t.dataset.tooltip.callbacks;return n?e.override(n):e}var hf={beforeTitle:Ya,title(e){if(e.length>0){let t=e[0],n=t.chart.data.labels,r=n?n.length:0;if(this&&this.options&&this.options.mode===`dataset`)return t.dataset.label||``;if(t.label)return t.label;if(r>0&&t.dataIndex<r)return n[t.dataIndex]}return``},afterTitle:Ya,beforeBody:Ya,beforeLabel:Ya,label(e){if(this&&this.options&&this.options.mode===`dataset`)return e.label+`: `+e.formattedValue||e.formattedValue;let t=e.dataset.label||``;t&&(t+=`: `);let n=e.formattedValue;return U(n)||(t+=n),t},labelColor(e){let t=e.chart.getDatasetMeta(e.datasetIndex).controller.getStyle(e.dataIndex);return{borderColor:t.borderColor,backgroundColor:t.backgroundColor,borderWidth:t.borderWidth,borderDash:t.borderDash,borderDashOffset:t.borderDashOffset,borderRadius:0}},labelTextColor(){return this.options.bodyColor},labelPointStyle(e){let t=e.chart.getDatasetMeta(e.datasetIndex).controller.getStyle(e.dataIndex);return{pointStyle:t.pointStyle,rotation:t.rotation}},afterLabel:Ya,afterBody:Ya,beforeFooter:Ya,footer:Ya,afterFooter:Ya};function gf(e,t,n,r){let i=e[t].call(n,r);return i===void 0?hf[t].call(n,r):i}var _f=class extends Cu{static positioners=Qd;constructor(e){super(),this.opacity=0,this._active=[],this._eventPosition=void 0,this._size=void 0,this._cachedAnimations=void 0,this._tooltipItems=[],this.$animations=void 0,this.$context=void 0,this.chart=e.chart,this.options=e.options,this.dataPoints=void 0,this.title=void 0,this.beforeBody=void 0,this.body=void 0,this.afterBody=void 0,this.footer=void 0,this.xAlign=void 0,this.yAlign=void 0,this.x=void 0,this.y=void 0,this.height=void 0,this.width=void 0,this.caretX=void 0,this.caretY=void 0,this.labelColors=void 0,this.labelPointStyles=void 0,this.labelTextColors=void 0}initialize(e){this.options=e,this._cachedAnimations=void 0,this.$context=void 0}_resolveAnimations(){let e=this._cachedAnimations;if(e)return e;let t=this.chart,n=this.options.setContext(this.getContext()),r=n.enabled&&t.options.animation&&n.animations,i=new Vc(this.chart,r);return r._cacheable&&(this._cachedAnimations=Object.freeze(i)),i}getContext(){return this.$context||=pf(this.chart.getContext(),this,this._tooltipItems)}getTitle(e,t){let{callbacks:n}=t,r=gf(n,`beforeTitle`,this,e),i=gf(n,`title`,this,e),a=gf(n,`afterTitle`,this,e),o=[];return o=$d(o,ef(r)),o=$d(o,ef(i)),o=$d(o,ef(a)),o}getBeforeBody(e,t){return ff(gf(t.callbacks,`beforeBody`,this,e))}getBody(e,t){let{callbacks:n}=t,r=[];return Y(e,e=>{let t={before:[],lines:[],after:[]},i=mf(n,e);$d(t.before,ef(gf(i,`beforeLabel`,this,e))),$d(t.lines,gf(i,`label`,this,e)),$d(t.after,ef(gf(i,`afterLabel`,this,e))),r.push(t)}),r}getAfterBody(e,t){return ff(gf(t.callbacks,`afterBody`,this,e))}getFooter(e,t){let{callbacks:n}=t,r=gf(n,`beforeFooter`,this,e),i=gf(n,`footer`,this,e),a=gf(n,`afterFooter`,this,e),o=[];return o=$d(o,ef(r)),o=$d(o,ef(i)),o=$d(o,ef(a)),o}_createItems(e){let t=this._active,n=this.chart.data,r=[],i=[],a=[],o=[],s,c;for(s=0,c=t.length;s<c;++s)o.push(tf(this.chart,t[s]));return e.filter&&(o=o.filter((t,r,i)=>e.filter(t,r,i,n))),e.itemSort&&(o=o.sort((t,r)=>e.itemSort(t,r,n))),Y(o,t=>{let n=mf(e.callbacks,t);r.push(gf(n,`labelColor`,this,t)),i.push(gf(n,`labelPointStyle`,this,t)),a.push(gf(n,`labelTextColor`,this,t))}),this.labelColors=r,this.labelPointStyles=i,this.labelTextColors=a,this.dataPoints=o,o}update(e,t){let n=this.options.setContext(this.getContext()),r=this._active,i,a=[];if(!r.length)this.opacity!==0&&(i={opacity:0});else{let e=Qd[n.position].call(this,r,this._eventPosition);a=this._createItems(n),this.title=this.getTitle(a,n),this.beforeBody=this.getBeforeBody(a,n),this.body=this.getBody(a,n),this.afterBody=this.getAfterBody(a,n),this.footer=this.getFooter(a,n);let t=this._size=nf(this,n),o=Object.assign({},e,t),s=sf(this.chart,n,o),c=uf(n,o,s,this.chart);this.xAlign=s.xAlign,this.yAlign=s.yAlign,i={opacity:1,x:c.x,y:c.y,width:t.width,height:t.height,caretX:e.x,caretY:e.y}}this._tooltipItems=a,this.$context=void 0,i&&this._resolveAnimations().update(this,i),e&&n.external&&n.external.call(this,{chart:this.chart,tooltip:this,replay:t})}drawCaret(e,t,n,r){let i=this.getCaretPosition(e,n,r);t.lineTo(i.x1,i.y1),t.lineTo(i.x2,i.y2),t.lineTo(i.x3,i.y3)}getCaretPosition(e,t,n){let{xAlign:r,yAlign:i}=this,{caretSize:a,cornerRadius:o}=n,{topLeft:s,topRight:c,bottomLeft:l,bottomRight:u}=Ws(o),{x:d,y:f}=e,{width:p,height:m}=t,h,g,_,v,y,b;return i===`center`?(y=f+m/2,r===`left`?(h=d,g=h-a,v=y+a,b=y-a):(h=d+p,g=h+a,v=y-a,b=y+a),_=h):(g=r===`left`?d+Math.max(s,l)+a:r===`right`?d+p-Math.max(c,u)-a:this.caretX,i===`top`?(v=f,y=v-a,h=g-a,_=g+a):(v=f+m,y=v+a,h=g+a,_=g-a),b=v),{x1:h,x2:g,x3:_,y1:v,y2:y,y3:b}}drawTitle(e,t,n){let r=this.title,i=r.length,a,o,s;if(i){let c=jc(n.rtl,this.x,this.width);for(e.x=df(this,n.titleAlign,n),t.textAlign=c.textAlign(n.titleAlign),t.textBaseline=`middle`,a=$(n.titleFont),o=n.titleSpacing,t.fillStyle=n.titleColor,t.font=a.string,s=0;s<i;++s)t.fillText(r[s],c.x(e.x),e.y+a.lineHeight/2),e.y+=a.lineHeight+o,s+1===i&&(e.y+=n.titleMarginBottom-o)}}_drawColorBox(e,t,n,r,i){let a=this.labelColors[n],o=this.labelPointStyles[n],{boxHeight:s,boxWidth:c}=i,l=$(i.bodyFont),u=df(this,`left`,i),d=r.x(u),f=s<l.lineHeight?(l.lineHeight-s)/2:0,p=t.y+f;if(i.usePointStyle){let t={radius:Math.min(c,s)/2,pointStyle:o.pointStyle,rotation:o.rotation,borderWidth:1},n=r.leftForLtr(d,c)+c/2,l=p+s/2;e.strokeStyle=i.multiKeyBackground,e.fillStyle=i.multiKeyBackground,Os(e,t,n,l),e.strokeStyle=a.borderColor,e.fillStyle=a.backgroundColor,Os(e,t,n,l)}else{e.lineWidth=G(a.borderWidth)?Math.max(...Object.values(a.borderWidth)):a.borderWidth||1,e.strokeStyle=a.borderColor,e.setLineDash(a.borderDash||[]),e.lineDashOffset=a.borderDashOffset||0;let t=r.leftForLtr(d,c),n=r.leftForLtr(r.xPlus(d,1),c-2),o=Ws(a.borderRadius);Object.values(o).some(e=>e!==0)?(e.beginPath(),e.fillStyle=i.multiKeyBackground,Ls(e,{x:t,y:p,w:c,h:s,radius:o}),e.fill(),e.stroke(),e.fillStyle=a.backgroundColor,e.beginPath(),Ls(e,{x:n,y:p+1,w:c-2,h:s-2,radius:o}),e.fill()):(e.fillStyle=i.multiKeyBackground,e.fillRect(t,p,c,s),e.strokeRect(t,p,c,s),e.fillStyle=a.backgroundColor,e.fillRect(n,p+1,c-2,s-2))}e.fillStyle=this.labelTextColors[n]}drawBody(e,t,n){let{body:r}=this,{bodySpacing:i,bodyAlign:a,displayColors:o,boxHeight:s,boxWidth:c,boxPadding:l}=n,u=$(n.bodyFont),d=u.lineHeight,f=0,p=jc(n.rtl,this.x,this.width),m=function(n){t.fillText(n,p.x(e.x+f),e.y+d/2),e.y+=d+i},h=p.textAlign(a),g,_,v,y,b,x,S;for(t.textAlign=a,t.textBaseline=`middle`,t.font=u.string,e.x=df(this,h,n),t.fillStyle=n.bodyColor,Y(this.beforeBody,m),f=o&&h!==`right`?a===`center`?c/2+l:c+2+l:0,y=0,x=r.length;y<x;++y){for(g=r[y],_=this.labelTextColors[y],t.fillStyle=_,Y(g.before,m),v=g.lines,o&&v.length&&(this._drawColorBox(t,e,y,p,n),d=Math.max(u.lineHeight,s)),b=0,S=v.length;b<S;++b)m(v[b]),d=u.lineHeight;Y(g.after,m)}f=0,d=u.lineHeight,Y(this.afterBody,m),e.y-=i}drawFooter(e,t,n){let r=this.footer,i=r.length,a,o;if(i){let s=jc(n.rtl,this.x,this.width);for(e.x=df(this,n.footerAlign,n),e.y+=n.footerMarginTop,t.textAlign=s.textAlign(n.footerAlign),t.textBaseline=`middle`,a=$(n.footerFont),t.fillStyle=n.footerColor,t.font=a.string,o=0;o<i;++o)t.fillText(r[o],s.x(e.x),e.y+a.lineHeight/2),e.y+=a.lineHeight+n.footerSpacing}}drawBackground(e,t,n,r){let{xAlign:i,yAlign:a}=this,{x:o,y:s}=e,{width:c,height:l}=n,{topLeft:u,topRight:d,bottomLeft:f,bottomRight:p}=Ws(r.cornerRadius);t.fillStyle=r.backgroundColor,t.strokeStyle=r.borderColor,t.lineWidth=r.borderWidth,t.beginPath(),t.moveTo(o+u,s),a===`top`&&this.drawCaret(e,t,n,r),t.lineTo(o+c-d,s),t.quadraticCurveTo(o+c,s,o+c,s+d),a===`center`&&i===`right`&&this.drawCaret(e,t,n,r),t.lineTo(o+c,s+l-p),t.quadraticCurveTo(o+c,s+l,o+c-p,s+l),a===`bottom`&&this.drawCaret(e,t,n,r),t.lineTo(o+f,s+l),t.quadraticCurveTo(o,s+l,o,s+l-f),a===`center`&&i===`left`&&this.drawCaret(e,t,n,r),t.lineTo(o,s+u),t.quadraticCurveTo(o,s,o+u,s),t.closePath(),t.fill(),r.borderWidth>0&&t.stroke()}_updateAnimationTarget(e){let t=this.chart,n=this.$animations,r=n&&n.x,i=n&&n.y;if(r||i){let n=Qd[e.position].call(this,this._active,this._eventPosition);if(!n)return;let a=this._size=nf(this,e),o=Object.assign({},n,this._size),s=sf(t,e,o),c=uf(e,o,s,t);(r._to!==c.x||i._to!==c.y)&&(this.xAlign=s.xAlign,this.yAlign=s.yAlign,this.width=a.width,this.height=a.height,this.caretX=n.x,this.caretY=n.y,this._resolveAnimations().update(this,c))}}_willRender(){return!!this.opacity}draw(e){let t=this.options.setContext(this.getContext()),n=this.opacity;if(!n)return;this._updateAnimationTarget(t);let r={width:this.width,height:this.height},i={x:this.x,y:this.y};n=Math.abs(n)<.001?0:n;let a=Q(t.padding),o=this.title.length||this.beforeBody.length||this.body.length||this.afterBody.length||this.footer.length;t.enabled&&o&&(e.save(),e.globalAlpha=n,this.drawBackground(i,e,r,t),Mc(e,t.textDirection),i.y+=a.top,this.drawTitle(i,e,t),this.drawBody(i,e,t),this.drawFooter(i,e,t),Nc(e,t.textDirection),e.restore())}getActiveElements(){return this._active||[]}setActiveElements(e,t){let n=this._active,r=e.map(({datasetIndex:e,index:t})=>{let n=this.chart.getDatasetMeta(e);if(!n)throw Error(`Cannot find a dataset at index `+e);return{datasetIndex:e,element:n.data[t],index:t}}),i=!$a(n,r),a=this._positionChanged(r,t);(i||a)&&(this._active=r,this._eventPosition=t,this._ignoreReplayEvents=!0,this.update(!0))}handleEvent(e,t,n=!0){if(t&&this._ignoreReplayEvents)return!1;this._ignoreReplayEvents=!1;let r=this.options,i=this._active||[],a=this._getActiveElements(e,i,t,n),o=this._positionChanged(a,e),s=t||!$a(a,i)||o;return s&&(this._active=a,(r.enabled||r.external)&&(this._eventPosition={x:e.x,y:e.y},this.update(!0,t))),s}_getActiveElements(e,t,n,r){let i=this.options;if(e.type===`mouseout`)return[];if(!r)return t.filter(e=>this.chart.data.datasets[e.datasetIndex]&&this.chart.getDatasetMeta(e.datasetIndex).controller.getParsed(e.index)!==void 0);let a=this.chart.getElementsAtEventForMode(e,i.mode,i,n);return i.reverse&&a.reverse(),a}_positionChanged(e,t){let{caretX:n,caretY:r,options:i}=this,a=Qd[i.position].call(this,e,t);return a!==!1&&(n!==a.x||r!==a.y)}},vf={id:`tooltip`,_element:_f,positioners:Qd,afterInit(e,t,n){n&&(e.tooltip=new _f({chart:e,options:n}))},beforeUpdate(e,t,n){e.tooltip&&e.tooltip.initialize(n)},reset(e,t,n){e.tooltip&&e.tooltip.initialize(n)},afterDraw(e){let t=e.tooltip;if(t&&t._willRender()){let n={tooltip:t};if(e.notifyPlugins(`beforeTooltipDraw`,{...n,cancelable:!0})===!1)return;t.draw(e.ctx),e.notifyPlugins(`afterTooltipDraw`,n)}},afterEvent(e,t){if(e.tooltip){let n=t.replay;e.tooltip.handleEvent(t.event,n,t.inChartArea)&&(t.changed=!0)}},defaults:{enabled:!0,external:null,position:`average`,backgroundColor:`rgba(0,0,0,0.8)`,titleColor:`#fff`,titleFont:{weight:`bold`},titleSpacing:2,titleMarginBottom:6,titleAlign:`left`,bodyColor:`#fff`,bodySpacing:2,bodyFont:{},bodyAlign:`left`,footerColor:`#fff`,footerSpacing:2,footerMarginTop:6,footerFont:{weight:`bold`},footerAlign:`left`,padding:6,caretPadding:2,caretSize:5,cornerRadius:6,boxHeight:(e,t)=>t.bodyFont.size,boxWidth:(e,t)=>t.bodyFont.size,multiKeyBackground:`#fff`,displayColors:!0,boxPadding:0,borderColor:`rgba(0,0,0,0)`,borderWidth:0,animation:{duration:400,easing:`easeOutQuart`},animations:{numbers:{type:`number`,properties:[`x`,`y`,`width`,`height`,`caretX`,`caretY`]},opacity:{easing:`linear`,duration:200}},callbacks:hf},defaultRoutes:{bodyFont:`font`,footerFont:`font`,titleFont:`font`},descriptors:{_scriptable:e=>e!==`filter`&&e!==`itemSort`&&e!==`external`,_indexable:!1,callbacks:{_scriptable:!1,_indexable:!1},animation:{_fallback:!1},animations:{_fallback:`animation`}},additionalOptionScopes:[`interaction`]},yf=(e,t,n,r)=>(typeof t==`string`?(n=e.push(t)-1,r.unshift({index:n,label:t})):isNaN(t)&&(n=null),n);function bf(e,t,n,r){let i=e.indexOf(t);return i===-1?yf(e,t,n,r):i===e.lastIndexOf(t)?i:n}var xf=(e,t)=>e===null?null:Ro(Math.round(e),0,t);function Sf(e){let t=this.getLabels();return e>=0&&e<t.length?t[e]:e}var Cf=class extends Uu{static id=`category`;static defaults={ticks:{callback:Sf}};constructor(e){super(e),this._startValue=void 0,this._valueRange=0,this._addedLabels=[]}init(e){let t=this._addedLabels;if(t.length){let e=this.getLabels();for(let{index:n,label:r}of t)e[n]===r&&e.splice(n,1);this._addedLabels=[]}super.init(e)}parse(e,t){if(U(e))return null;let n=this.getLabels();return t=isFinite(t)&&n[t]===e?t:bf(n,e,q(t,e),this._addedLabels),xf(t,n.length-1)}determineDataLimits(){let{minDefined:e,maxDefined:t}=this.getUserBounds(),{min:n,max:r}=this.getMinMax(!0);this.options.bounds===`ticks`&&(e||(n=0),t||(r=this.getLabels().length-1)),this.min=n,this.max=r}buildTicks(){let e=this.min,t=this.max,n=this.options.offset,r=[],i=this.getLabels();i=e===0&&t===i.length-1?i:i.slice(e,t+1),this._valueRange=Math.max(i.length-+!n,1),this._startValue=this.min-(n?.5:0);for(let n=e;n<=t;n++)r.push({value:n});return r}getLabelForValue(e){return Sf.call(this,e)}configure(){super.configure(),this.isHorizontal()||(this._reversePixels=!this._reversePixels)}getPixelForValue(e){return typeof e!=`number`&&(e=this.parse(e)),e===null?NaN:this.getPixelForDecimal((e-this._startValue)/this._valueRange)}getPixelForTick(e){let t=this.ticks;return e<0||e>t.length-1?null:this.getPixelForValue(t[e].value)}getValueForPixel(e){return Math.round(this._startValue+this.getDecimalForPixel(e)*this._valueRange)}getBasePixel(){return this.bottom}};function wf(e,t){let n=[],{bounds:r,step:i,min:a,max:o,precision:s,count:c,maxTicks:l,maxDigits:u,includeBounds:d}=e,f=i||1,p=l-1,{min:m,max:h}=t,g=!U(a),_=!U(o),v=!U(c),y=(h-m)/(u+1),b=To((h-m)/p/f)*f,x,S,C,w;if(b<1e-14&&!g&&!_)return[{value:m},{value:h}];w=Math.ceil(h/b)-Math.floor(m/b),w>p&&(b=To(w*b/p/f)*f),U(s)||(x=10**s,b=Math.ceil(b*x)/x),r===`ticks`?(S=Math.floor(m/b)*b,C=Math.ceil(h/b)*b):(S=m,C=h),g&&_&&i&&ko((o-a)/i,b/1e3)?(w=Math.round(Math.min((o-a)/b,l)),b=(o-a)/w,S=a,C=o):v?(S=g?a:S,C=_?o:C,w=c-1,b=(C-S)/w):(w=(C-S)/b,w=wo(w,Math.round(w),b/1e3)?Math.round(w):Math.ceil(w));let T=Math.max(No(b),No(S));x=10**(U(s)?T:s),S=Math.round(S*x)/x,C=Math.round(C*x)/x;let E=0;for(g&&(d&&S!==a?(n.push({value:a}),S<a&&E++,wo(Math.round((S+E*b)*x)/x,a,Tf(a,y,e))&&E++):S<a&&E++);E<w;++E){let e=Math.round((S+E*b)*x)/x;if(_&&e>o)break;n.push({value:e})}return _&&d&&C!==o?n.length&&wo(n[n.length-1].value,o,Tf(o,y,e))?n[n.length-1].value=o:n.push({value:o}):(!_||C===o)&&n.push({value:C}),n}function Tf(e,t,{horizontal:n,minRotation:r}){let i=jo(r),a=(n?Math.sin(i):Math.cos(i))||.001,o=.75*t*(``+e).length;return Math.min(t/a,o)}var Ef=class extends Uu{constructor(e){super(e),this.start=void 0,this.end=void 0,this._startValue=void 0,this._endValue=void 0,this._valueRange=0}parse(e,t){return U(e)||(typeof e==`number`||e instanceof Number)&&!isFinite(+e)?null:+e}handleTickRangeOptions(){let{beginAtZero:e}=this.options,{minDefined:t,maxDefined:n}=this.getUserBounds(),{min:r,max:i}=this,a=e=>r=t?r:e,o=e=>i=n?i:e;if(e){let e=Co(r),t=Co(i);e<0&&t<0?o(0):e>0&&t>0&&a(0)}if(r===i){let t=i===0?1:Math.abs(i*.05);o(i+t),e||a(r-t)}this.min=r,this.max=i}getTickLimit(){let{maxTicksLimit:e,stepSize:t}=this.options.ticks,n;return t?(n=Math.ceil(this.max/t)-Math.floor(this.min/t)+1,n>1e3&&(console.warn(`scales.${this.id}.ticks.stepSize: ${t} would result generating up to ${n} ticks. Limiting to 1000.`),n=1e3)):(n=this.computeTickLimit(),e||=11),e&&(n=Math.min(e,n)),n}computeTickLimit(){return 1/0}buildTicks(){let e=this.options,t=e.ticks,n=this.getTickLimit();n=Math.max(2,n);let r=wf({maxTicks:n,bounds:e.bounds,min:e.min,max:e.max,precision:t.precision,step:t.stepSize,count:t.count,maxDigits:this._maxDigits(),horizontal:this.isHorizontal(),minRotation:t.minRotation||0,includeBounds:t.includeBounds!==!1},this._range||this);return e.bounds===`ticks`&&Ao(r,this,`value`),e.reverse?(r.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),r}configure(){let e=this.ticks,t=this.min,n=this.max;if(super.configure(),this.options.offset&&e.length){let r=(n-t)/Math.max(e.length-1,1)/2;t-=r,n+=r}this._startValue=t,this._endValue=n,this._valueRange=n-t}getLabelForValue(e){return ms(e,this.chart.options.locale,this.options.ticks.format)}},Df=class extends Ef{static id=`linear`;static defaults={ticks:{callback:_s.formatters.numeric}};determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=K(e)?e:0,this.max=K(t)?t:1,this.handleTickRangeOptions()}computeTickLimit(){let e=this.isHorizontal(),t=e?this.width:this.height,n=jo(this.options.ticks.minRotation),r=(e?Math.sin(n):Math.cos(n))||.001,i=this._resolveTickFontOptions(0);return Math.ceil(t/Math.min(40,i.lineHeight/r))}getPixelForValue(e){return e===null?NaN:this.getPixelForDecimal((e-this._startValue)/this._valueRange)}getValueForPixel(e){return this._startValue+this.getDecimalForPixel(e)*this._valueRange}},Of=e=>Math.floor(So(e)),kf=(e,t)=>10**(Of(e)+t);function Af(e){return e/10**Of(e)==1}function jf(e,t,n){let r=10**n,i=Math.floor(e/r);return Math.ceil(t/r)-i}function Mf(e,t){let n=Of(t-e);for(;jf(e,t,n)>10;)n++;for(;jf(e,t,n)<10;)n--;return Math.min(n,Of(e))}function Nf(e,{min:t,max:n}){t=Za(e.min,t);let r=[],i=Of(t),a=Mf(t,n),o=a<0?10**Math.abs(a):1,s=10**a,c=i>a?10**i:0,l=Math.round((t-c)*o)/o,u=Math.floor((t-c)/s/10)*s*10,d=Math.floor((l-u)/10**a),f=Za(e.min,Math.round((c+u+d*10**a)*o)/o);for(;f<n;)r.push({value:f,major:Af(f),significand:d}),d>=10?d=d<15?15:20:d++,d>=20&&(a++,d=2,o=a>=0?1:o),f=Math.round((c+u+d*10**a)*o)/o;let p=Za(e.max,f);return r.push({value:p,major:Af(p),significand:d}),r}(class extends Uu{static id=`logarithmic`;static defaults={ticks:{callback:_s.formatters.logarithmic,major:{enabled:!0}}};constructor(e){super(e),this.start=void 0,this.end=void 0,this._startValue=void 0,this._valueRange=0}parse(e,t){let n=Ef.prototype.parse.apply(this,[e,t]);if(n===0){this._zero=!0;return}return K(n)&&n>0?n:null}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=K(e)?Math.max(0,e):null,this.max=K(t)?Math.max(0,t):null,this.options.beginAtZero&&(this._zero=!0),this._zero&&this.min!==this._suggestedMin&&!K(this._userMin)&&(this.min=e===kf(this.min,0)?kf(this.min,-1):kf(this.min,0)),this.handleTickRangeOptions()}handleTickRangeOptions(){let{minDefined:e,maxDefined:t}=this.getUserBounds(),n=this.min,r=this.max,i=t=>n=e?n:t,a=e=>r=t?r:e;n===r&&(n<=0?(i(1),a(10)):(i(kf(n,-1)),a(kf(r,1)))),n<=0&&i(kf(r,-1)),r<=0&&a(kf(n,1)),this.min=n,this.max=r}buildTicks(){let e=this.options,t=Nf({min:this._userMin,max:this._userMax},this);return e.bounds===`ticks`&&Ao(t,this,`value`),e.reverse?(t.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),t}getLabelForValue(e){return e===void 0?`0`:ms(e,this.chart.options.locale,this.options.ticks.format)}configure(){let e=this.min;super.configure(),this._startValue=So(e),this._valueRange=So(this.max)-So(e)}getPixelForValue(e){return(e===void 0||e===0)&&(e=this.min),e===null||isNaN(e)?NaN:this.getPixelForDecimal(e===this.min?0:(So(e)-this._startValue)/this._valueRange)}getValueForPixel(e){let t=this.getDecimalForPixel(e);return 10**(this._startValue+t*this._valueRange)}});function Pf(e){let t=e.ticks;if(t.display&&e.display){let e=Q(t.backdropPadding);return q(t.font&&t.font.size,Z.font.size)+e.height}return 0}function Ff(e,t,n){return n=W(n)?n:[n],{w:Ts(e,t.string,n),h:n.length*t.lineHeight}}function If(e,t,n,r,i){return e===r||e===i?{start:t-n/2,end:t+n/2}:e<r||e>i?{start:t-n,end:t}:{start:t,end:t+n}}function Lf(e){let t={l:e.left+e._padding.left,r:e.right-e._padding.right,t:e.top+e._padding.top,b:e.bottom-e._padding.bottom},n=Object.assign({},t),r=[],i=[],a=e._pointLabels.length,o=e.options.pointLabels,s=o.centerPointLabels?X/a:0;for(let c=0;c<a;c++){let a=o.setContext(e.getPointLabelContext(c));i[c]=a.padding;let l=e.getPointPosition(c,e.drawingArea+i[c],s),u=$(a.font),d=Ff(e.ctx,u,e._pointLabels[c]);r[c]=d;let f=Io(e.getIndexAngle(c)+s),p=Math.round(Mo(f));Rf(n,t,f,If(p,l.x,d.w,0,180),If(p,l.y,d.h,90,270))}e.setCenterPoint(t.l-n.l,n.r-t.r,t.t-n.t,n.b-t.b),e._pointLabelItems=Vf(e,r,i)}function Rf(e,t,n,r,i){let a=Math.abs(Math.sin(n)),o=Math.abs(Math.cos(n)),s=0,c=0;r.start<t.l?(s=(t.l-r.start)/a,e.l=Math.min(e.l,t.l-s)):r.end>t.r&&(s=(r.end-t.r)/a,e.r=Math.max(e.r,t.r+s)),i.start<t.t?(c=(t.t-i.start)/o,e.t=Math.min(e.t,t.t-c)):i.end>t.b&&(c=(i.end-t.b)/o,e.b=Math.max(e.b,t.b+c))}function zf(e,t,n){let r=e.drawingArea,{extra:i,additionalAngle:a,padding:o,size:s}=n,c=e.getPointPosition(t,r+i+o,a),l=Math.round(Mo(Io(c.angle+yo))),u=Wf(c.y,s.h,l),d=Hf(l),f=Uf(c.x,s.w,d);return{visible:!0,x:c.x,y:u,textAlign:d,left:f,top:u,right:f+s.w,bottom:u+s.h}}function Bf(e,t){if(!t)return!0;let{left:n,top:r,right:i,bottom:a}=e;return!(As({x:n,y:r},t)||As({x:n,y:a},t)||As({x:i,y:r},t)||As({x:i,y:a},t))}function Vf(e,t,n){let r=[],i=e._pointLabels.length,a=e.options,{centerPointLabels:o,display:s}=a.pointLabels,c={extra:Pf(a)/2,additionalAngle:o?X/i:0},l;for(let a=0;a<i;a++){c.padding=n[a],c.size=t[a];let i=zf(e,a,c);r.push(i),s===`auto`&&(i.visible=Bf(i,l),i.visible&&(l=i))}return r}function Hf(e){return e===0||e===180?`center`:e<180?`left`:`right`}function Uf(e,t,n){return n===`right`?e-=t:n===`center`&&(e-=t/2),e}function Wf(e,t,n){return n===90||n===270?e-=t/2:(n>270||n<90)&&(e-=t),e}function Gf(e,t,n){let{left:r,top:i,right:a,bottom:o}=n,{backdropColor:s}=t;if(!U(s)){let n=Ws(t.borderRadius),c=Q(t.backdropPadding);e.fillStyle=s;let l=r-c.left,u=i-c.top,d=a-r+c.width,f=o-i+c.height;Object.values(n).some(e=>e!==0)?(e.beginPath(),Ls(e,{x:l,y:u,w:d,h:f,radius:n}),e.fill()):e.fillRect(l,u,d,f)}}function Kf(e,t){let{ctx:n,options:{pointLabels:r}}=e;for(let i=t-1;i>=0;i--){let t=e._pointLabelItems[i];if(!t.visible)continue;let a=r.setContext(e.getPointLabelContext(i));Gf(n,a,t);let o=$(a.font),{x:s,y:c,textAlign:l}=t;Is(n,e._pointLabels[i],s,c+o.lineHeight/2,o,{color:a.color,textAlign:l,textBaseline:`middle`})}}function qf(e,t,n,r){let{ctx:i}=e;if(n)i.arc(e.xCenter,e.yCenter,t,0,go);else{let n=e.getPointPosition(0,t);i.moveTo(n.x,n.y);for(let a=1;a<r;a++)n=e.getPointPosition(a,t),i.lineTo(n.x,n.y)}}function Jf(e,t,n,r,i){let a=e.ctx,o=t.circular,{color:s,lineWidth:c}=t;!o&&!r||!s||!c||n<0||(a.save(),a.strokeStyle=s,a.lineWidth=c,a.setLineDash(i.dash||[]),a.lineDashOffset=i.dashOffset,a.beginPath(),qf(e,n,o,r),a.closePath(),a.stroke(),a.restore())}function Yf(e,t,n){return qs(e,{label:n,index:t,type:`pointLabel`})}(class extends Ef{static id=`radialLinear`;static defaults={display:!0,animate:!0,position:`chartArea`,angleLines:{display:!0,lineWidth:1,borderDash:[],borderDashOffset:0},grid:{circular:!1},startAngle:0,ticks:{showLabelBackdrop:!0,callback:_s.formatters.numeric},pointLabels:{backdropColor:void 0,backdropPadding:2,display:!0,font:{size:10},callback(e){return e},padding:5,centerPointLabels:!1}};static defaultRoutes={"angleLines.color":`borderColor`,"pointLabels.color":`color`,"ticks.color":`color`};static descriptors={angleLines:{_fallback:`grid`}};constructor(e){super(e),this.xCenter=void 0,this.yCenter=void 0,this.drawingArea=void 0,this._pointLabels=[],this._pointLabelItems=[]}setDimensions(){let e=this._padding=Q(Pf(this.options)/2),t=this.width=this.maxWidth-e.width,n=this.height=this.maxHeight-e.height;this.xCenter=Math.floor(this.left+t/2+e.left),this.yCenter=Math.floor(this.top+n/2+e.top),this.drawingArea=Math.floor(Math.min(t,n)/2)}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!1);this.min=K(e)&&!isNaN(e)?e:0,this.max=K(t)&&!isNaN(t)?t:0,this.handleTickRangeOptions()}computeTickLimit(){return Math.ceil(this.drawingArea/Pf(this.options))}generateTickLabels(e){Ef.prototype.generateTickLabels.call(this,e),this._pointLabels=this.getLabels().map((e,t)=>{let n=J(this.options.pointLabels.callback,[e,t],this);return n||n===0?n:``}).filter((e,t)=>this.chart.getDataVisibility(t))}fit(){let e=this.options;e.display&&e.pointLabels.display?Lf(this):this.setCenterPoint(0,0,0,0)}setCenterPoint(e,t,n,r){this.xCenter+=Math.floor((e-t)/2),this.yCenter+=Math.floor((n-r)/2),this.drawingArea-=Math.min(this.drawingArea/2,Math.max(e,t,n,r))}getIndexAngle(e){let t=go/(this._pointLabels.length||1),n=this.options.startAngle||0;return Io(e*t+jo(n))}getDistanceFromCenterForValue(e){if(U(e))return NaN;let t=this.drawingArea/(this.max-this.min);return this.options.reverse?(this.max-e)*t:(e-this.min)*t}getValueForDistanceFromCenter(e){if(U(e))return NaN;let t=e/(this.drawingArea/(this.max-this.min));return this.options.reverse?this.max-t:this.min+t}getPointLabelContext(e){let t=this._pointLabels||[];if(e>=0&&e<t.length){let n=t[e];return Yf(this.getContext(),e,n)}}getPointPosition(e,t,n=0){let r=this.getIndexAngle(e)-yo+n;return{x:Math.cos(r)*t+this.xCenter,y:Math.sin(r)*t+this.yCenter,angle:r}}getPointPositionForValue(e,t){return this.getPointPosition(e,this.getDistanceFromCenterForValue(t))}getBasePosition(e){return this.getPointPositionForValue(e||0,this.getBaseValue())}getPointLabelPosition(e){let{left:t,top:n,right:r,bottom:i}=this._pointLabelItems[e];return{left:t,top:n,right:r,bottom:i}}drawBackground(){let{backgroundColor:e,grid:{circular:t}}=this.options;if(e){let n=this.ctx;n.save(),n.beginPath(),qf(this,this.getDistanceFromCenterForValue(this._endValue),t,this._pointLabels.length),n.closePath(),n.fillStyle=e,n.fill(),n.restore()}}drawGrid(){let e=this.ctx,t=this.options,{angleLines:n,grid:r,border:i}=t,a=this._pointLabels.length,o,s,c;if(t.pointLabels.display&&Kf(this,a),r.display&&this.ticks.forEach((e,t)=>{if(t!==0||t===0&&this.min<0){s=this.getDistanceFromCenterForValue(e.value);let n=this.getContext(t),o=r.setContext(n),c=i.setContext(n);Jf(this,o,s,a,c)}}),n.display){for(e.save(),o=a-1;o>=0;o--){let r=n.setContext(this.getPointLabelContext(o)),{color:i,lineWidth:a}=r;!a||!i||(e.lineWidth=a,e.strokeStyle=i,e.setLineDash(r.borderDash),e.lineDashOffset=r.borderDashOffset,s=this.getDistanceFromCenterForValue(t.reverse?this.min:this.max),c=this.getPointPosition(o,s),e.beginPath(),e.moveTo(this.xCenter,this.yCenter),e.lineTo(c.x,c.y),e.stroke())}e.restore()}}drawBorder(){}drawLabels(){let e=this.ctx,t=this.options,n=t.ticks;if(!n.display)return;let r=this.getIndexAngle(0),i,a;e.save(),e.translate(this.xCenter,this.yCenter),e.rotate(r),e.textAlign=`center`,e.textBaseline=`middle`,this.ticks.forEach((r,o)=>{if(o===0&&this.min>=0&&!t.reverse)return;let s=n.setContext(this.getContext(o)),c=$(s.font);if(i=this.getDistanceFromCenterForValue(this.ticks[o].value),s.showLabelBackdrop){e.font=c.string,a=e.measureText(r.label).width,e.fillStyle=s.backdropColor;let t=Q(s.backdropPadding);e.fillRect(-a/2-t.left,-i-c.size/2-t.top,a+t.width,c.size+t.height)}Is(e,r.label,0,-i,c,{color:s.color,strokeColor:s.textStrokeColor,strokeWidth:s.textStrokeWidth})}),e.restore()}drawTitle(){}});var Xf={millisecond:{common:!0,size:1,steps:1e3},second:{common:!0,size:1e3,steps:60},minute:{common:!0,size:6e4,steps:60},hour:{common:!0,size:36e5,steps:24},day:{common:!0,size:864e5,steps:30},week:{common:!1,size:6048e5,steps:4},month:{common:!0,size:2628e6,steps:12},quarter:{common:!1,size:7884e6,steps:4},year:{common:!0,size:3154e7}},Zf=Object.keys(Xf);function Qf(e,t){return e-t}function $f(e,t){if(U(t))return null;let n=e._adapter,{parser:r,round:i,isoWeekday:a}=e._parseOpts,o=t;return typeof r==`function`&&(o=r(o)),K(o)||(o=typeof r==`string`?n.parse(o,r):n.parse(o)),o===null?null:(i&&(o=i===`week`&&(Oo(a)||a===!0)?n.startOf(o,`isoWeek`,a):n.startOf(o,i)),+o)}function ep(e,t,n,r){let i=Zf.length;for(let a=Zf.indexOf(e);a<i-1;++a){let e=Xf[Zf[a]],i=e.steps?e.steps:2**53-1;if(e.common&&Math.ceil((n-t)/(i*e.size))<=r)return Zf[a]}return Zf[i-1]}function tp(e,t,n,r,i){for(let a=Zf.length-1;a>=Zf.indexOf(n);a--){let n=Zf[a];if(Xf[n].common&&e._adapter.diff(i,r,n)>=t-1)return n}return Zf[n?Zf.indexOf(n):0]}function np(e){for(let t=Zf.indexOf(e)+1,n=Zf.length;t<n;++t)if(Xf[Zf[t]].common)return Zf[t]}function rp(e,t,n){if(!n)e[t]=!0;else if(n.length){let{lo:r,hi:i}=Vo(n,t),a=n[r]>=t?n[r]:n[i];e[a]=!0}}function ip(e,t,n,r){let i=e._adapter,a=+i.startOf(t[0].value,r),o=t[t.length-1].value,s,c;for(s=a;s<=o;s=+i.add(s,1,r))c=n[s],c>=0&&(t[c].major=!0);return t}function ap(e,t,n){let r=[],i={},a=t.length,o,s;for(o=0;o<a;++o)s=t[o],i[s]=o,r.push({value:s,major:!1});return a===0||!n?r:ip(e,r,i,n)}var op=class extends Uu{static id=`time`;static defaults={bounds:`data`,adapters:{},time:{parser:!1,unit:!1,round:!1,isoWeekday:!1,minUnit:`millisecond`,displayFormats:{}},ticks:{source:`auto`,callback:!1,major:{enabled:!1}}};constructor(e){super(e),this._cache={data:[],labels:[],all:[]},this._unit=`day`,this._majorUnit=void 0,this._offsets={},this._normalized=!1,this._parseOpts=void 0}init(e,t={}){let n=e.time||={},r=this._adapter=new Dl._date(e.adapters.date);r.init(t),io(n.displayFormats,r.formats()),this._parseOpts={parser:n.parser,round:n.round,isoWeekday:n.isoWeekday},super.init(e),this._normalized=t.normalized}parse(e,t){return e===void 0?null:$f(this,e)}beforeLayout(){super.beforeLayout(),this._cache={data:[],labels:[],all:[]}}determineDataLimits(){let e=this.options,t=this._adapter,n=e.time.unit||`day`,{min:r,max:i,minDefined:a,maxDefined:o}=this.getUserBounds();function s(e){!a&&!isNaN(e.min)&&(r=Math.min(r,e.min)),!o&&!isNaN(e.max)&&(i=Math.max(i,e.max))}(!a||!o)&&(s(this._getLabelBounds()),(e.bounds!==`ticks`||e.ticks.source!==`labels`)&&s(this.getMinMax(!1))),r=K(r)&&!isNaN(r)?r:+t.startOf(Date.now(),n),i=K(i)&&!isNaN(i)?i:+t.endOf(Date.now(),n)+1,this.min=Math.min(r,i-1),this.max=Math.max(r+1,i)}_getLabelBounds(){let e=this.getLabelTimestamps(),t=1/0,n=-1/0;return e.length&&(t=e[0],n=e[e.length-1]),{min:t,max:n}}buildTicks(){let e=this.options,t=e.time,n=e.ticks,r=n.source===`labels`?this.getLabelTimestamps():this._generate();e.bounds===`ticks`&&r.length&&(this.min=this._userMin||r[0],this.max=this._userMax||r[r.length-1]);let i=this.min,a=this.max,o=Wo(r,i,a);return this._unit=t.unit||(n.autoSkip?ep(t.minUnit,this.min,this.max,this._getLabelCapacity(i)):tp(this,o.length,t.minUnit,this.min,this.max)),this._majorUnit=!n.major.enabled||this._unit===`year`?void 0:np(this._unit),this.initOffsets(r),e.reverse&&o.reverse(),ap(this,o,this._majorUnit)}afterAutoSkip(){this.options.offsetAfterAutoskip&&this.initOffsets(this.ticks.map(e=>+e.value))}initOffsets(e=[]){let t=0,n=0,r,i;this.options.offset&&e.length&&(r=this.getDecimalForValue(e[0]),t=e.length===1?1-r:(this.getDecimalForValue(e[1])-r)/2,i=this.getDecimalForValue(e[e.length-1]),n=e.length===1?i:(i-this.getDecimalForValue(e[e.length-2]))/2);let a=e.length<3?.5:.25;t=Ro(t,0,a),n=Ro(n,0,a),this._offsets={start:t,end:n,factor:1/(t+1+n)}}_generate(){let e=this._adapter,t=this.min,n=this.max,r=this.options,i=r.time,a=i.unit||ep(i.minUnit,t,n,this._getLabelCapacity(t)),o=q(r.ticks.stepSize,1),s=a===`week`&&i.isoWeekday,c=Oo(s)||s===!0,l={},u=t,d,f;if(c&&(u=+e.startOf(u,`isoWeek`,s)),u=+e.startOf(u,c?`day`:a),e.diff(n,t,a)>1e5*o)throw Error(t+` and `+n+` are too far apart with stepSize of `+o+` `+a);let p=r.ticks.source===`data`&&this.getDataTimestamps();for(d=u,f=0;d<n;d=+e.add(d,o,a),f++)rp(l,d,p);return(d===n||r.bounds===`ticks`||f===1)&&rp(l,d,p),Object.keys(l).sort(Qf).map(e=>+e)}getLabelForValue(e){let t=this._adapter,n=this.options.time;return n.tooltipFormat?t.format(e,n.tooltipFormat):t.format(e,n.displayFormats.datetime)}format(e,t){let n=this.options.time.displayFormats,r=this._unit,i=t||n[r];return this._adapter.format(e,i)}_tickFormatFunction(e,t,n,r){let i=this.options,a=i.ticks.callback;if(a)return J(a,[e,t,n],this);let o=i.time.displayFormats,s=this._unit,c=this._majorUnit,l=s&&o[s],u=c&&o[c],d=n[t],f=c&&u&&d&&d.major;return this._adapter.format(e,r||(f?u:l))}generateTickLabels(e){let t,n,r;for(t=0,n=e.length;t<n;++t)r=e[t],r.label=this._tickFormatFunction(r.value,t,e)}getDecimalForValue(e){return e===null?NaN:(e-this.min)/(this.max-this.min)}getPixelForValue(e){let t=this._offsets,n=this.getDecimalForValue(e);return this.getPixelForDecimal((t.start+n)*t.factor)}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return this.min+n*(this.max-this.min)}_getLabelSize(e){let t=this.options.ticks,n=this.ctx.measureText(e).width,r=jo(this.isHorizontal()?t.maxRotation:t.minRotation),i=Math.cos(r),a=Math.sin(r),o=this._resolveTickFontOptions(0).size;return{w:n*i+o*a,h:n*a+o*i}}_getLabelCapacity(e){let t=this.options.time,n=t.displayFormats,r=n[t.unit]||n.millisecond,i=this._tickFormatFunction(e,0,ap(this,[e],this._majorUnit),r),a=this._getLabelSize(i),o=Math.floor(this.isHorizontal()?this.width/a.w:this.height/a.h)-1;return o>0?o:1}getDataTimestamps(){let e=this._cache.data||[],t,n;if(e.length)return e;let r=this.getMatchingVisibleMetas();if(this._normalized&&r.length)return this._cache.data=r[0].controller.getAllParsedValues(this);for(t=0,n=r.length;t<n;++t)e=e.concat(r[t].controller.getAllParsedValues(this));return this._cache.data=this.normalize(e)}getLabelTimestamps(){let e=this._cache.labels||[],t,n;if(e.length)return e;let r=this.getLabels();for(t=0,n=r.length;t<n;++t)e.push($f(this,r[t]));return this._cache.labels=this._normalized?e:this.normalize(e)}normalize(e){return Jo(e.sort(Qf))}};function sp(e,t,n){let r=0,i=e.length-1,a,o,s,c;n?(t>=e[r].pos&&t<=e[i].pos&&({lo:r,hi:i}=Ho(e,`pos`,t)),{pos:a,time:s}=e[r],{pos:o,time:c}=e[i]):(t>=e[r].time&&t<=e[i].time&&({lo:r,hi:i}=Ho(e,`time`,t)),{time:a,pos:s}=e[r],{time:o,pos:c}=e[i]);let l=o-a;return l?s+(c-s)*(t-a)/l:s}(class extends op{static id=`timeseries`;static defaults=op.defaults;constructor(e){super(e),this._table=[],this._minPos=void 0,this._tableRange=void 0}initOffsets(){let e=this._getTimestampsForTable(),t=this._table=this.buildLookupTable(e);this._minPos=sp(t,this.min),this._tableRange=sp(t,this.max)-this._minPos,super.initOffsets(e)}buildLookupTable(e){let{min:t,max:n}=this,r=[],i=[],a,o,s,c,l;for(a=0,o=e.length;a<o;++a)c=e[a],c>=t&&c<=n&&r.push(c);if(r.length<2)return[{time:t,pos:0},{time:n,pos:1}];for(a=0,o=r.length;a<o;++a)l=r[a+1],s=r[a-1],c=r[a],Math.round((l+s)/2)!==c&&i.push({time:c,pos:a/(o-1)});return i}_generate(){let e=this.min,t=this.max,n=super.getDataTimestamps();return(!n.includes(e)||!n.length)&&n.splice(0,0,e),(!n.includes(t)||n.length===1)&&n.push(t),n.sort((e,t)=>e-t)}_getTimestampsForTable(){let e=this._cache.all||[];if(e.length)return e;let t=this.getDataTimestamps(),n=this.getLabelTimestamps();return e=t.length&&n.length?this.normalize(t.concat(n)):t.length?t:n,e=this._cache.all=e,e}getDecimalForValue(e){return(sp(this._table,e)-this._minPos)/this._tableRange}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return sp(this._table,n*this._tableRange+this._minPos,!0)}});var cp={data:{type:Object,required:!0},options:{type:Object,default:()=>({})},plugins:{type:Array,default:()=>[]},datasetIdKey:{type:String,default:`label`},updateMode:{type:String,default:void 0}},lp={ariaLabel:{type:String},ariaDescribedby:{type:String}},up={type:{type:String,required:!0},destroyDelay:{type:Number,default:0},...cp,...lp},dp=(e,t)=>Object.assign(e,t);function fp(e){return c(e)?O(e):e}function pp(e){let t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:e;return c(t)?new Proxy(e,{}):e}function mp(e,t){let n=e.options;n&&t&&Object.assign(n,t)}function hp(e,t){e.labels=t}function gp(e,t,n){let r=[];e.datasets=t.map(t=>{let i=e.datasets.find(e=>e[n]===t[n]);return!i||!t.data||r.includes(i)?{...t}:(r.push(i),Object.assign(i,t),i)})}function _p(e,t){let n={labels:[],datasets:[]};return hp(n,e.labels),gp(n,e.datasets,t),n}var vp=R({props:up,setup(e,t){let{expose:n,slots:r}=t,i=F(null),a=w(null);n({chart:a});let o=()=>{if(!i.value)return;let{type:t,data:n,options:r,plugins:o,datasetIdKey:s}=e,c=pp(_p(n,s),n);a.value=new jd(i.value,{type:t,data:c,options:{...r},plugins:o})},s=()=>{let t=O(a.value);t&&(e.destroyDelay>0?setTimeout(()=>{t.destroy(),a.value=null},e.destroyDelay):(t.destroy(),a.value=null))},c=t=>{t.update(e.updateMode)};return Me(o),we(s),V([()=>e.options,()=>e.data],(t,n)=>{let[r,i]=t,[o,s]=n,l=O(a.value);if(!l)return;let u=!1;if(r){let e=fp(r),t=fp(o);e&&e!==t&&(mp(l,e),u=!0)}if(i){let t=fp(i.labels),n=fp(s.labels),r=fp(i.datasets),a=fp(s.datasets);t!==n&&(hp(l.config.data,t),u=!0),r&&r!==a&&(gp(l.config.data,r,e.datasetIdKey),u=!0)}u&&xe(()=>{c(l)})},{deep:!0}),()=>Ae(`canvas`,{role:`img`,"aria-label":e.ariaLabel,"aria-describedby":e.ariaDescribedby,ref:i},[Ae(`p`,{},[r.default?r.default():``])])}});function yp(e,t){return jd.register(t),R({props:cp,setup(t,n){let{expose:r}=n,i=w(null),a=w(null);V(()=>a.value?.chart??null,e=>{i.value=e},{flush:`sync`}),r({chart:i});let o=e=>{a.value=e};return()=>Ae(vp,dp({ref:o},{type:e,...t}))}})}var bp=yp(`bar`,Tl);jd.register(Tl,Hd,Cf,Df,Zd,vf);function xp(){let e=F(``),t=F(``),n=F(``);function r(){let r=getComputedStyle(document.documentElement);e.value=r.getPropertyValue(`--foreground`).trim(),t.value=r.getPropertyValue(`--muted-foreground`).trim(),n.value=r.getPropertyValue(`--border`).trim()}let i;return Me(()=>{r(),i=window.matchMedia(`(prefers-color-scheme: dark)`),i.addEventListener(`change`,r)}),Ie(()=>{i?.removeEventListener(`change`,r)}),{foreground:e,mutedForeground:t,border:n}}var Sp={cost:`Cost`,req:`Requests`,tokin:`Tokens in`,tokout:`Tokens out`},Cp=20,wp=100,Tp=3e4,Ep={hour:24,day:30,month:12},Dp={hour:`24h`,day:`30d`,month:`12mo`};function Op(e){switch(e){case`requests`:return[`req`];case`tokens`:return[`tokin`,`tokout`];case`cost`:return[`cost`];case`models`:return[]}}var kp=de(`history`,{state:()=>({scope:`total`,window:`hour`,tab:`requests`,modelMetric:`cost`,seriesByMetric:{},modelRanking:[],modelOptions:[],loading:!1,error:``,timer:void 0}),actions:{setScope(e){e!==this.scope&&(this.scope=e,this.refresh())},setWindow(e){e!==this.window&&(this.window=e,this.refresh())},setTab(e){e!==this.tab&&(this.tab=e,this.refresh())},setModelMetric(e){e!==this.modelMetric&&(this.modelMetric=e,this.refresh())},async refresh(){await Promise.all([this.tab===`models`?this.fetchModelRanking():this.fetchSeries(),this.fetchModelOptions()])},async fetchSeries(){if(je().isAuthenticated){this.loading=!0;try{let e=Ep[this.window],t=Op(this.tab),n=await Promise.all(t.map(t=>Fe(`/admin/api/usage/history?scope=${encodeURIComponent(this.scope)}&metric=${t}&window=${this.window}&span=${e}`))),r={};t.forEach((e,t)=>{r[e]=n[t].points}),this.seriesByMetric=r,this.error=``}catch(e){if(e instanceof be&&(e.status===401||e.status===403))return;this.error=e instanceof Error?e.message:String(e)}finally{this.loading=!1}}},async fetchModelRanking(){if(je().isAuthenticated){this.loading=!0;try{let e=await Fe(`/admin/api/usage/models?metric=${this.modelMetric}&window=${this.window}&limit=${Cp}`);this.modelRanking=e.models,this.error=``}catch(e){if(e instanceof be&&(e.status===401||e.status===403))return;this.error=e instanceof Error?e.message:String(e)}finally{this.loading=!1}}},async fetchModelOptions(){if(je().isAuthenticated)try{let e=await Fe(`/admin/api/usage/models?metric=req&window=${this.window}&limit=${wp}`);this.modelOptions=e.models}catch{}},startAutoRefresh(){this.timer===void 0&&(this.timer=setInterval(()=>void this.refresh(),Tp))},stopAutoRefresh(){this.timer!==void 0&&(clearInterval(this.timer),this.timer=void 0)}}}),Ap={key:0,class:`py-8 text-center text-sm text-muted-foreground`},jp=R({__name:`ModelUsageChart`,props:{metric:{},models:{}},setup(e){let t=e,{foreground:n,mutedForeground:r,border:a}=xp(),o={req:`--chart-requests`,tokin:`--chart-tokens-in`,tokout:`--chart-tokens-out`,cost:`--chart-cost`};function s(e,t){return e===`cost`?t/1e6:t}function c(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let l=M(()=>(n.value,{labels:t.models.map(e=>e.id),datasets:[{label:Sp[t.metric],backgroundColor:c(o[t.metric]),data:t.models.map(e=>s(t.metric,e.value))}]})),u=M(()=>`${Math.max(180,t.models.length*28+60)}px`),d=M(()=>({indexAxis:`y`,responsive:!0,maintainAspectRatio:!1,animation:!1,scales:{x:{beginAtZero:!0,grid:{color:a.value},ticks:{color:r.value,callback:e=>t.metric===`cost`?`$${e}`:ke(Number(e))}},y:{grid:{display:!1},ticks:{color:r.value,autoSkip:!1}}},plugins:{legend:{display:!1},tooltip:{callbacks:{label:e=>{let n=e.parsed.x??0;return t.metric===`cost`?`${Sp[t.metric]}: $${n.toFixed(4)}`:`${Sp[t.metric]}: ${ke(n)} (${Ue(n)})`}}}}}));return(t,n)=>e.models.length===0?(N(),P(`p`,Ap,` No model recorded any usage in this window. `)):(N(),P(`div`,{key:1,class:`w-full`,style:i({height:u.value})},[L(b(bp),{data:l.value,options:d.value},null,8,[`data`,`options`])],4))}}),Mp={class:`h-72 w-full`},Np=R({__name:`UsageChart`,props:{tab:{},window:{},seriesByMetric:{}},setup(e){let t=e,{foreground:n,mutedForeground:r,border:i}=xp(),a={requests:[{metric:`req`,label:`Requests`,color:`--chart-requests`}],tokens:[{metric:`tokin`,label:`Tokens in`,color:`--chart-tokens-in`},{metric:`tokout`,label:`Tokens out`,color:`--chart-tokens-out`}],cost:[{metric:`cost`,label:`Cost (USD)`,color:`--chart-cost`}]};function o(e,t){return e===`cost`?t/1e6:t}let s=M(()=>{let e=a[t.tab],n=new Set;for(let r of e)for(let e of t.seriesByMetric[r.metric]??[])n.add(e.bucket);return Array.from(n).sort()}),c=M(()=>s.value.map(e=>_e(e,t.window)));function l(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let u=M(()=>{n.value;let e=s.value;return{labels:c.value,datasets:a[t.tab].map(n=>{let r=new Map((t.seriesByMetric[n.metric]??[]).map(e=>[e.bucket,e.value]));return{label:n.label,backgroundColor:l(n.color),data:e.map(e=>o(n.metric,r.get(e)??0))}})}}),d=M(()=>a[t.tab].length>1),f=M(()=>({responsive:!0,maintainAspectRatio:!1,animation:!1,scales:{x:{stacked:d.value,grid:{color:i.value,display:!1},ticks:{color:r.value}},y:{stacked:d.value,beginAtZero:!0,grid:{color:i.value},ticks:{color:r.value,callback:e=>t.tab===`cost`?`$${e}`:ke(Number(e))}}},plugins:{legend:{display:d.value,labels:{color:n.value}},tooltip:{callbacks:{label:e=>{let n=e.parsed.y??0;return t.tab===`cost`?`${e.dataset.label}: $${n.toFixed(4)}`:`${e.dataset.label}: ${ke(n)} (${Ue(n)})`}}}}}));return(e,t)=>(N(),P(`div`,Mp,[L(b(bp),{data:u.value,options:f.value},null,8,[`data`,`options`])]))}}),Pp={class:`flex flex-wrap items-center gap-3`},Fp={key:0,class:`text-sm text-destructive`},Ip={class:`text-sm text-muted-foreground`},Lp=R({__name:`ChartsView`,setup(e){let t=ye(),n=kp(),{query:r,normalized:i,hasQuery:a}=Pe(),o=M(()=>{let e=t.usage?.users??[],r=t.usage?.groups??[],o=e.filter(e=>!a.value||Ne(e,i.value)||`user:${e.id}`===n.scope).map(e=>({value:`user:${e.id}`,label:e.id})),s=r.filter(t=>!a.value||Ve(t,e,i.value)||`group:${t.id}`===n.scope).map(e=>({value:`group:${e.id}`,label:e.id})),c=(n.modelOptions??[]).filter(e=>!a.value||e.id.toLowerCase().includes(i.value)||`model:${e.id}`===n.scope).map(e=>({value:`model:${e.id}`,label:e.id}));return n.scope.startsWith(`model:`)&&!c.some(e=>e.value===n.scope)&&c.push({value:n.scope,label:n.scope.slice(6)}),[{value:`total`,label:`Total (all traffic)`},...s,...o,...c]}),s=[`hour`,`day`,`month`],c=[`cost`,`req`,`tokin`,`tokout`],l=M(()=>n.tab===`models`?`requests`:n.tab);function u(e){n.setTab(e)}function d(e){typeof e==`string`&&n.setScope(e)}function f(e){typeof e==`string`&&n.setModelMetric(e)}return Me(()=>{n.refresh(),n.startAutoRefresh()}),we(()=>{n.stopAutoRefresh()}),V(o,e=>{e.some(e=>e.value===n.scope)||n.setScope(`total`)}),(e,t)=>(N(),I(b(Ge),null,{default:B(()=>[L(b(Se),{class:`flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between`},{default:B(()=>[L(b(Ce),null,{default:B(()=>[...t[2]||=[ge(`Usage charts`,-1)]]),_:1}),He(`div`,Pp,[L(Be,{modelValue:b(r),"onUpdate:modelValue":t[0]||=e=>E(r)?r.value=e:null,placeholder:`Filter users, groups or models`,class:`w-56`},null,8,[`modelValue`]),b(n).tab===`models`?(N(),I(b(Xi),{key:0,"model-value":b(n).modelMetric,"onUpdate:modelValue":f},{default:B(()=>[L(b(na),{class:`w-40`,"aria-label":`Rank models by`},{default:B(()=>[L(b(ra),{placeholder:`Rank by`})]),_:1}),L(b(Zi),null,{default:B(()=>[(N(),P(k,null,me(c,e=>L(b($i),{key:e,value:e},{default:B(()=>[ge(ce(b(Sp)[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`])):(N(),I(b(Xi),{key:1,"model-value":b(n).scope,"onUpdate:modelValue":d},{default:B(()=>[L(b(na),{class:`w-56`},{default:B(()=>[L(b(ra),{placeholder:`Scope`})]),_:1}),L(b(Zi),null,{default:B(()=>[(N(!0),P(k,null,me(o.value,e=>(N(),I(b($i),{key:e.value,value:e.value},{default:B(()=>[ge(ce(e.label),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])),L(b(he),{"model-value":b(n).window,"onUpdate:modelValue":t[1]||=e=>b(n).setWindow(e)},{default:B(()=>[L(b(Te),null,{default:B(()=>[(N(),P(k,null,me(s,e=>L(b(Re),{key:e,value:e},{default:B(()=>[ge(ce(b(Dp)[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`])])]),_:1}),L(b(pe),{class:`flex flex-col gap-4`},{default:B(()=>[L(b(he),{"model-value":b(n).tab,"onUpdate:modelValue":u},{default:B(()=>[L(b(Te),null,{default:B(()=>[L(b(Re),{value:`requests`},{default:B(()=>[...t[3]||=[ge(`Requests`,-1)]]),_:1}),L(b(Re),{value:`tokens`},{default:B(()=>[...t[4]||=[ge(`Tokens`,-1)]]),_:1}),L(b(Re),{value:`cost`},{default:B(()=>[...t[5]||=[ge(`Cost`,-1)]]),_:1}),L(b(Re),{value:`models`},{default:B(()=>[...t[6]||=[ge(`Models`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`]),b(n).error?(N(),P(`p`,Fp,ce(b(n).error),1)):ze(``,!0),b(n).tab===`models`?(N(),P(k,{key:1},[He(`p`,Ip,` Models with usage in the selected window, ranked by `+ce(b(Sp)[b(n).modelMetric].toLowerCase())+`. Each row is the provider that served the traffic, so a model reached through more than one provider appears once per provider. `,1),L(jp,{metric:b(n).modelMetric,models:b(n).modelRanking},null,8,[`metric`,`models`])],64)):(N(),I(Np,{key:2,tab:l.value,window:b(n).window,"series-by-metric":b(n).seriesByMetric},null,8,[`tab`,`window`,`series-by-metric`]))]),_:1})]),_:1}))}});export{Lp as default};", + "import{$ as e,A as t,At as n,B as r,Bt as i,C as a,Ct as o,D as s,Dt as c,E as l,Et as u,F as d,Ft as f,G as p,H as m,I as h,It as g,J as _,K as v,L as y,Lt as b,M as x,Mt as S,N as C,Nt as w,O as T,Ot as E,P as D,Pt as O,Q as k,R as ee,Rt as te,S as ne,St as re,T as ie,Tt as ae,U as oe,V as se,Vt as ce,W as le,X as ue,Y as de,Z as fe,_ as pe,_t as me,a as he,at as ge,b as A,c as _e,ct as ve,d as ye,dt as j,et as M,f as be,ft as xe,g as Se,gt as N,h as Ce,ht as we,i as Te,it as P,j as Ee,jt as F,k as De,kt as Oe,l as ke,lt as Ae,m as je,mt as Me,n as Ne,nt as I,o as Pe,ot as L,p as Fe,pt as Ie,q as Le,r as Re,rt as ze,s as Be,st as R,t as Ve,tt as He,u as Ue,ut as We,v as Ge,vt as z,w as Ke,wt as B,x as qe,xt as V,y as Je,yt as Ye,z as Xe,zt as Ze}from"./index-Cn6vEAjP.js";function Qe(e,t=-1/0,n=1/0){return Math.min(n,Math.max(t,e))}function $e(e,t,n){let r=n.originalEvent.target,i=new CustomEvent(e,{bubbles:!1,cancelable:!0,detail:n});t&&r.addEventListener(e,t,{once:!0}),r.dispatchEvent(i)}var et=n({layersRoot:new Set,layersWithOutsidePointerEventsDisabled:new Set,originalBodyPointerEvents:void 0,branches:new Set});function tt(e){if(typeof e!=`object`||!e)return!1;let t=Object.getPrototypeOf(e);return t!==null&&t!==Object.prototype&&Object.getPrototypeOf(t)!==null||Symbol.iterator in e?!1:Symbol.toStringTag in e?Object.prototype.toString.call(e)===`[object Module]`:!0}function nt(e,t,n=`.`,r){if(!tt(t))return nt(e,{},n,r);let i={...t};for(let t of Object.keys(e)){if(t===`__proto__`||t===`constructor`)continue;let a=e[t];a!=null&&(r&&r(i,t,a,n)||(i[t]=Array.isArray(a)&&Array.isArray(i[t])?[...a,...i[t]]:tt(a)&&tt(i[t])?nt(a,i[t],(n?`${n}.`:``)+t.toString(),r):a))}return i}function rt(e){return(...t)=>t.reduce((t,n)=>nt(t,n,``,e),{})}var it=rt(),at=d(()=>{let e=F(new Map),n=F(),r=M(()=>{for(let t of e.value.values())if(t)return!0;return!1}),i=s({scrollBody:F(!0)}),a=null,o=()=>{document.body.style.paddingRight=``,document.body.style.marginRight=``,et.layersWithOutsidePointerEventsDisabled.size===0&&(document.body.style.pointerEvents=``),document.documentElement.style.removeProperty(`--scrollbar-width`),document.body.style.overflow=n.value??``,y&&a?.(),n.value=void 0};return V(r,(e,s)=>{if(!h)return;if(!e){s&&o();return}n.value===void 0&&(n.value=document.body.style.overflow);let c=window.innerWidth-document.documentElement.clientWidth,l={padding:c,margin:0},u=i.scrollBody?.value?typeof i.scrollBody.value==`object`?it({padding:i.scrollBody.value.padding===!0?c:i.scrollBody.value.padding,margin:i.scrollBody.value.margin===!0?c:i.scrollBody.value.margin},l):l:{padding:0,margin:0};c>0&&(document.body.style.paddingRight=typeof u.padding==`number`?`${u.padding}px`:String(u.padding),document.body.style.marginRight=typeof u.margin==`number`?`${u.margin}px`:String(u.margin),document.documentElement.style.setProperty(`--scrollbar-width`,`${c}px`),document.body.style.overflow=`hidden`),y&&(a=t(document,`touchmove`,e=>ct(e),{passive:!1})),xe(()=>{r.value&&(document.body.style.pointerEvents=`none`,document.body.style.overflow=`hidden`)})},{immediate:!0,flush:`sync`}),e});function ot(e){let t=Math.random().toString(36).substring(2,7),n=at();n.value.set(t,e??!1);let i=M({get:()=>n.value.get(t)??!1,set:e=>n.value.set(t,e)});return r(()=>{n.value.delete(t)}),i}function st(e){let t=window.getComputedStyle(e);if(t.overflowX===`scroll`||t.overflowY===`scroll`||t.overflowX===`auto`&&e.clientWidth<e.scrollWidth||t.overflowY===`auto`&&e.clientHeight<e.scrollHeight)return!0;{let t=e.parentNode;return!(t instanceof Element)||t.tagName===`BODY`?!1:st(t)}}function ct(e){let t=e||window.event,n=t.target;return n instanceof Element&&st(n)?!1:t.touches.length>1||(t.preventDefault&&t.cancelable&&t.preventDefault(),!1)}var lt=0;function ut(){re(e=>{if(!h)return;let t=document.querySelectorAll(`[data-reka-focus-guard]`);document.body.insertAdjacentElement(`afterbegin`,t[0]??dt()),document.body.insertAdjacentElement(`beforeend`,t[1]??dt()),lt++,e(()=>{lt===1&&document.querySelectorAll(`[data-reka-focus-guard]`).forEach(e=>e.remove()),lt--})})}function dt(){let e=document.createElement(`span`);return e.setAttribute(`data-reka-focus-guard`,``),e.tabIndex=0,e.style.outline=`none`,e.style.opacity=`0`,e.style.position=`fixed`,e.style.pointerEvents=`none`,e}function ft(e){return M(()=>!g(e)||!!De(e)?.closest(`form`))}var pt=function(e){return typeof document>`u`?null:(Array.isArray(e)?e[0]:e).ownerDocument.body},mt=new WeakMap,ht=new WeakMap,gt={},_t=0,vt=function(e){return e&&(e.host||vt(e.parentNode))},yt=function(e,t){return t.map(function(t){if(e.contains(t))return t;var n=vt(t);return n&&e.contains(n)?n:(console.error(`aria-hidden`,t,`in not contained inside`,e,`. Doing nothing`),null)}).filter(function(e){return!!e})},bt=function(e,t,n,r){var i=yt(t,Array.isArray(e)?e:[e]);gt[n]||(gt[n]=new WeakMap);var a=gt[n],o=[],s=new Set,c=new Set(i),l=function(e){!e||s.has(e)||(s.add(e),l(e.parentNode))};i.forEach(l);var u=function(e){!e||c.has(e)||Array.prototype.forEach.call(e.children,function(e){if(s.has(e))u(e);else try{var t=e.getAttribute(r),i=t!==null&&t!==`false`,c=(mt.get(e)||0)+1,l=(a.get(e)||0)+1;mt.set(e,c),a.set(e,l),o.push(e),c===1&&i&&ht.set(e,!0),l===1&&e.setAttribute(n,`true`),i||e.setAttribute(r,`true`)}catch(t){console.error(`aria-hidden: cannot operate on `,e,t)}})};return u(t),s.clear(),_t++,function(){o.forEach(function(e){var t=mt.get(e)-1,i=a.get(e)-1;mt.set(e,t),a.set(e,i),t||(ht.has(e)||e.removeAttribute(r),ht.delete(e)),i||e.removeAttribute(n)}),_t--,_t||(mt=new WeakMap,mt=new WeakMap,ht=new WeakMap,gt={})}},xt=function(e,t,n){n===void 0&&(n=`data-aria-hidden`);var r=Array.from(Array.isArray(e)?e:[e]),i=t||pt(e);return i?(r.push.apply(r,Array.from(i.querySelectorAll(`[aria-live], script`))),bt(r,i,n,`aria-hidden`)):function(){return null}};function St(e){let t;V(()=>De(e),e=>{let n=!1;try{n=!!e?.closest(`[popover]:not(:popover-open)`)}catch{}e&&!n?t=xt(e):t&&t()}),we(()=>{t&&t()})}function Ct(e){let t=F(),n=M(()=>t.value?.width??0),r=M(()=>t.value?.height??0),i;return Me(()=>{let n=De(e);n?(t.value={width:n.offsetWidth,height:n.offsetHeight},i=new ResizeObserver(e=>{if(!Array.isArray(e)||!e.length)return;let r=e[0],i,a;if(`borderBoxSize`in r){let e=r.borderBoxSize,t=Array.isArray(e)?e[0]:e;i=t.inlineSize,a=t.blockSize}else i=n.offsetWidth,a=n.offsetHeight;t.value={width:i,height:a}}),i.observe(n,{box:`border-box`})):t.value=void 0}),we(()=>{i?.disconnect(),i=void 0}),{width:n,height:r}}function wt(e){let t=Xe(``,1e3);return{search:t,handleTypeaheadSearch:(n,r)=>{if(t.value+=n,e)e(n);else{let e=m(),n=r.map(e=>({...e,textValue:e.value?.textValue??e.ref.textContent?.trim()??``})),i=n.find(t=>t.ref===e),a=Et(n.map(e=>e.textValue),t.value,i?.textValue),o=n.find(e=>e.textValue===a);return o&&o.ref.focus(),o?.ref}},resetTypeahead:()=>{t.value=``}}}function Tt(e,t){return e.map((n,r)=>e[(t+r)%e.length])}function Et(e,t,n){let r=t.length>1&&Array.from(t).every(e=>e===t[0])?t[0]:t,i=n?e.indexOf(n):-1,a=Tt(e,Math.max(i,0));r.length===1&&(a=a.filter(e=>e!==n));let o=a.find(e=>e.toLowerCase().startsWith(r.toLowerCase()));return o===n?void 0:o}var Dt=`dismissableLayer.pointerDownOutside`,Ot=`dismissableLayer.focusOutside`;function kt(e,t){if(!(t instanceof Element))return!1;let n=t.closest(`[data-dismissable-layer]`),r=e.dataset.dismissableLayer===``?e:e.querySelector(`[data-dismissable-layer]`),i=Array.from(e.ownerDocument.querySelectorAll(`[data-dismissable-layer]`));return!!(n&&(r===n||i.indexOf(r)<i.indexOf(n)))}function At(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=F(!1),a=F(()=>{});return re(o=>{if(!h||!g(n))return;let s=async n=>{let o=n.target;if(!(!t?.value||!o)){if(kt(t.value,o)){i.value=!1;return}if(n.target&&!i.value){let t={originalEvent:n};function i(){$e(Dt,e,t)}n.pointerType===`touch`?(r.removeEventListener(`click`,a.value),a.value=i,r.addEventListener(`click`,a.value,{once:!0})):i()}else r.removeEventListener(`click`,a.value);i.value=!1}},c=window.setTimeout(()=>{r.addEventListener(`pointerdown`,s)},0);o(()=>{window.clearTimeout(c),r.removeEventListener(`pointerdown`,s),r.removeEventListener(`click`,a.value)})}),{onPointerDownCapture:()=>{g(n)&&(i.value=!0)}}}function jt(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=F(!1);return re(a=>{if(!h||!g(n))return;let o=async n=>{if(!t?.value)return;await xe(),await xe();let r=n.target;!t.value||!r||kt(t.value,r)||n.target&&!i.value&&$e(Ot,e,{originalEvent:n})};r.addEventListener(`focusin`,o),a(()=>r.removeEventListener(`focusin`,o))}),{onFocusCapture:()=>{g(n)&&(i.value=!0)},onBlurCapture:()=>{g(n)&&(i.value=!1)}}}var Mt=R({__name:`DismissableLayer`,props:{disableOutsidePointerEvents:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},present:{type:Boolean,required:!1,default:!0}},emits:[`escapeKeyDown`,`pointerDownOutside`,`focusOutside`,`interactOutside`,`dismiss`],setup(e,{emit:t}){let n=e,r=t,{forwardRef:a,currentElement:o}=ie(),s=M(()=>o.value?.ownerDocument??globalThis.document),c=M(()=>et.layersRoot),l=M(()=>o.value?Array.from(c.value).indexOf(o.value):-1),u=M(()=>et.layersWithOutsidePointerEventsDisabled.size>0),d=M(()=>{let e=Array.from(c.value),[t]=[...et.layersWithOutsidePointerEventsDisabled].slice(-1),n=e.indexOf(t);return l.value>=n}),f=At(async e=>{let t=[...et.branches].some(t=>t?.contains(e.target));!n.present||!d.value||t||(r(`pointerDownOutside`,e),r(`interactOutside`,e),await xe(),e.defaultPrevented||r(`dismiss`))},o),p=jt(e=>{let t=[...et.branches].some(t=>t?.contains(e.target));!n.present||t||(r(`focusOutside`,e),r(`interactOutside`,e),e.defaultPrevented||r(`dismiss`))},o);return T(`Escape`,e=>{n.present&&l.value===c.value.size-1&&(r(`escapeKeyDown`,e),e.defaultPrevented||r(`dismiss`))}),V([o,()=>n.disableOutsidePointerEvents,()=>n.present],([e,t,n],r,i)=>{!e||!n||t&&(et.layersWithOutsidePointerEventsDisabled.size===0&&(et.originalBodyPointerEvents=s.value.body.style.pointerEvents,s.value.body.style.pointerEvents=`none`),et.layersWithOutsidePointerEventsDisabled.add(e),i(()=>{et.layersWithOutsidePointerEventsDisabled.delete(e),et.layersWithOutsidePointerEventsDisabled.size===0&&!se(et.originalBodyPointerEvents)&&(s.value.body.style.pointerEvents=et.originalBodyPointerEvents)}))},{immediate:!0}),V([o,()=>n.present],([e,t],n,r)=>{!e||!t||(c.value.add(e),r(()=>{c.value.delete(e)}))},{immediate:!0}),re(e=>{e(()=>{o.value&&(c.value.delete(o.value),et.layersWithOutsidePointerEventsDisabled.delete(o.value))})}),(e,t)=>(N(),I(b(A),{ref:b(a),"as-child":e.asChild,as:e.as,"data-dismissable-layer":``,style:i({pointerEvents:u.value?d.value?`auto`:`none`:void 0}),onFocusCapture:b(p).onFocusCapture,onBlurCapture:b(p).onBlurCapture,onPointerdownCapture:b(f).onPointerDownCapture},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`style`,`onFocusCapture`,`onBlurCapture`,`onPointerdownCapture`]))}}),Nt=D(()=>F([]));function Pt(){let e=Nt();return{add(t){let n=e.value[0];t!==n&&n?.pause(),e.value=Ft(e.value,t),e.value.unshift(t)},remove(t){e.value=Ft(e.value,t),e.value[0]?.resume()}}}function Ft(e,t){let n=[...e],r=n.indexOf(t);return r!==-1&&n.splice(r,1),n}var It=`focusScope.autoFocusOnMount`,Lt=`focusScope.autoFocusOnUnmount`,Rt={bubbles:!1,cancelable:!0};function zt(e,{select:t=!1}={}){let n=m();for(let r of e)if(Gt(r,{select:t}),m()!==n)return!0}function Bt(e){let t=Vt(e);return[Ht(t,e),Ht(t.reverse(),e)]}function Vt(e){let t=[],n=document.createTreeWalker(e,NodeFilter.SHOW_ELEMENT,{acceptNode:e=>{let t=e.tagName===`INPUT`&&e.type===`hidden`;return e.disabled||e.hidden||t?NodeFilter.FILTER_SKIP:e.tabIndex>=0?NodeFilter.FILTER_ACCEPT:NodeFilter.FILTER_SKIP}});for(;n.nextNode();)t.push(n.currentNode);return t}function Ht(e,t){for(let n of e)if(!Ut(n,{upTo:t}))return n}function Ut(e,{upTo:t}){if(getComputedStyle(e).visibility===`hidden`)return!0;for(;e;){if(t!==void 0&&e===t)return!1;if(getComputedStyle(e).display===`none`)return!0;e=e.parentElement}return!1}function Wt(e){return e instanceof HTMLInputElement&&`select`in e}function Gt(e,{select:t=!1}={}){if(e&&e.focus){let n=m();e.focus({preventScroll:!0}),e!==n&&Wt(e)&&t&&e.select()}}var Kt=R({__name:`FocusScope`,props:{loop:{type:Boolean,required:!1,default:!1},trapped:{type:Boolean,required:!1,default:!1},present:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`mountAutoFocus`,`unmountAutoFocus`],setup(e,{emit:t}){let r=e,i=t,{currentRef:a,currentElement:o}=ie(),s=F(null),c=Pt(),l=n({paused:!1,pause(){this.paused=!0},resume(){this.paused=!1}});re(e=>{if(!h)return;let t=o.value;if(!r.trapped)return;function n(e){if(l.paused||!t)return;let n=e.target;t.contains(n)?s.value=n:Gt(s.value,{select:!0})}function i(e){if(l.paused||!t)return;let n=e.relatedTarget;n!==null&&(t.contains(n)||Gt(s.value,{select:!0}))}function a(e){let n=s.value;n!==null&&e.some(e=>e.removedNodes.length>0)&&(t.contains(n)||Gt(t))}document.addEventListener(`focusin`,n),document.addEventListener(`focusout`,i);let c=new MutationObserver(a);t&&c.observe(t,{childList:!0,subtree:!0}),e(()=>{document.removeEventListener(`focusin`,n),document.removeEventListener(`focusout`,i),c.disconnect()})});function u(e,t){let n=new CustomEvent(It,Rt),r=e=>i(`mountAutoFocus`,e);e.addEventListener(It,r),e.dispatchEvent(n),e.removeEventListener(It,r),n.defaultPrevented||(zt(Vt(e),{select:!0}),m()===t&&Gt(e))}re(async e=>{let t=o.value;if(await xe(),!t)return;r.present!==!1&&c.add(l);let n=m();!t.contains(n)&&r.present!==!1&&u(t,n),e(()=>{let e=new CustomEvent(Lt,Rt),r=e=>{i(`unmountAutoFocus`,e)};t.addEventListener(Lt,r),t.dispatchEvent(e),t.setAttribute(`data-focus-scope-unmounting`,``),setTimeout(()=>{e.defaultPrevented||Gt(n??document.body,{select:!0}),t.removeEventListener(Lt,r),c.remove(l),t.removeAttribute(`data-focus-scope-unmounting`)},0)})}),V(()=>r.present,async(e,t)=>{if(!h)return;if(e===!1&&t===!0){c.remove(l);return}if(e!==!0||t!==!1)return;c.add(l),await xe();let n=o.value;if(!n)return;let r=m();n.contains(r)||u(n,r)});function d(e){if(!r.loop&&!r.trapped||l.paused)return;let t=e.key===`Tab`&&!e.altKey&&!e.ctrlKey&&!e.metaKey,n=m();if(t&&n){let t=e.currentTarget,[i,a]=Bt(t);i&&a?!e.shiftKey&&n===a?(e.preventDefault(),r.loop&&Gt(i,{select:!0})):e.shiftKey&&n===i&&(e.preventDefault(),r.loop&&Gt(a,{select:!0})):n===t&&e.preventDefault()}}return(e,t)=>(N(),I(b(A),{ref_key:`currentRef`,ref:a,tabindex:`-1`,"as-child":e.asChild,as:e.as,onKeydown:d},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as-child`,`as`]))}}),qt=[`Enter`,` `],Jt=[`ArrowDown`,`PageUp`,`Home`],Yt=[`ArrowUp`,`PageDown`,`End`];[...Jt,...Yt],[...qt],[...qt];function Xt(e){let t=m();for(let n of e)if(n===t||(n.focus(),m()!==t))return}var Zt=R({__name:`Teleport`,props:{to:{type:null,required:!1},disabled:{type:Boolean,required:!1},defer:{type:Boolean,required:!1},forceMount:{type:Boolean,required:!1}},setup(t){let n=t,r=s({}),i=M(()=>n.to??r.teleportTo?.value??`body`),a=Ee();return(t,n)=>b(a)||t.forceMount?(N(),I(e,{key:0,to:i.value,disabled:t.disabled,defer:t.defer},[z(t.$slots,`default`)],8,[`to`,`disabled`,`defer`])):ze(`v-if`,!0)}}),Qt=R({__name:`VisuallyHidden`,props:{feature:{type:String,required:!1,default:`focusable`},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(N(),I(b(A),{as:e.as,"as-child":e.asChild,"aria-hidden":e.feature===`focusable`||e.feature===`fully-hidden`?`true`:void 0,"data-hidden":e.feature===`fully-hidden`?``:void 0,tabindex:e.feature===`fully-hidden`?`-1`:void 0,style:{position:`absolute`,border:0,width:`1px`,height:`1px`,padding:0,margin:`-1px`,overflow:`hidden`,clip:`rect(0, 0, 0, 0)`,clipPath:`inset(50%)`,whiteSpace:`nowrap`,wordWrap:`normal`,top:`-1px`,left:`-1px`}},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`aria-hidden`,`data-hidden`,`tabindex`]))}}),[$t,en]=oe(`PopperRoot`),tn=R({inheritAttrs:!1,__name:`PopperRoot`,setup(e){let t=F();return en({anchor:t,onAnchorChange:e=>t.value=e}),(e,t)=>z(e.$slots,`default`)}}),nn=R({__name:`PopperAnchor`,props:{reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{forwardRef:n,currentElement:r}=ie(),i=$t();return o(()=>{i.onAnchorChange(t.reference??r.value)}),(e,t)=>(N(),I(b(A),{ref:b(n),as:e.as,"as-child":e.asChild},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`as`,`as-child`]))}});function rn(e){return e!==null}function an(e){return{name:`transformOrigin`,options:e,fn(t){let{placement:n,rects:r,middlewareData:i}=t,a=i.arrow?.centerOffset!==0,o=a?0:e.arrowWidth,s=a?0:e.arrowHeight,[c,l]=on(n),u={start:e.dir===`rtl`?`100%`:`0%`,center:`50%`,end:e.dir===`rtl`?`0%`:`100%`}[l],d={start:`0%`,center:`50%`,end:`100%`}[l],f=(i.arrow?.x??0)+o/2,p=(i.arrow?.y??0)+s/2,m=``,h=``;return c===`bottom`?(m=a?u:`${f}px`,h=`${-s}px`):c===`top`?(m=a?u:`${f}px`,h=`${r.floating.height+s}px`):c===`right`?(m=`${-s}px`,h=a?d:`${p}px`):c===`left`&&(m=`${r.floating.width+s}px`,h=a?d:`${p}px`),{data:{x:m,y:h}}}}}function on(e){let[t,n=`center`]=e.split(`-`);return[t,n]}var sn=[`top`,`right`,`bottom`,`left`],cn=Math.min,ln=Math.max,un=Math.round,dn=Math.floor,fn=e=>({x:e,y:e}),pn={left:`right`,right:`left`,bottom:`top`,top:`bottom`};function mn(e,t,n){return ln(e,cn(t,n))}function hn(e,t){return typeof e==`function`?e(t):e}function gn(e){return e.split(`-`)[0]}function _n(e){return e.split(`-`)[1]}function vn(e){return e===`x`?`y`:`x`}function yn(e){return e===`y`?`height`:`width`}function bn(e){let t=e[0];return t===`t`||t===`b`?`y`:`x`}function xn(e){return vn(bn(e))}function Sn(e,t,n){n===void 0&&(n=!1);let r=_n(e),i=xn(e),a=yn(i),o=i===`x`?r===(n?`end`:`start`)?`right`:`left`:r===`start`?`bottom`:`top`;return t.reference[a]>t.floating[a]&&(o=jn(o)),[o,jn(o)]}function Cn(e){let t=jn(e);return[wn(e),t,wn(t)]}function wn(e){return e.includes(`start`)?e.replace(`start`,`end`):e.replace(`end`,`start`)}var Tn=[`left`,`right`],En=[`right`,`left`],Dn=[`top`,`bottom`],On=[`bottom`,`top`];function kn(e,t,n){switch(e){case`top`:case`bottom`:return n?t?En:Tn:t?Tn:En;case`left`:case`right`:return t?Dn:On;default:return[]}}function An(e,t,n,r){let i=_n(e),a=kn(gn(e),n===`start`,r);return i&&(a=a.map(e=>e+`-`+i),t&&(a=a.concat(a.map(wn)))),a}function jn(e){let t=gn(e);return pn[t]+e.slice(t.length)}function Mn(e){return{top:e.top??0,right:e.right??0,bottom:e.bottom??0,left:e.left??0}}function Nn(e){return typeof e==`number`?{top:e,right:e,bottom:e,left:e}:Mn(e)}function Pn(e){let{x:t,y:n,width:r,height:i}=e;return{width:r,height:i,top:n,left:t,right:t+r,bottom:n+i,x:t,y:n}}function Fn(e,t,n){let{reference:r,floating:i}=e,a=bn(t),o=xn(t),s=yn(o),c=gn(t),l=a===`y`,u=r.x+r.width/2-i.width/2,d=r.y+r.height/2-i.height/2,f=r[s]/2-i[s]/2,p;switch(c){case`top`:p={x:u,y:r.y-i.height};break;case`bottom`:p={x:u,y:r.y+r.height};break;case`right`:p={x:r.x+r.width,y:d};break;case`left`:p={x:r.x-i.width,y:d};break;default:p={x:r.x,y:r.y}}let m=_n(t);return m&&(p[o]+=f*(m===`end`?1:-1)*(n&&l?-1:1)),p}async function In(e,t){t===void 0&&(t={});let{x:n,y:r,platform:i,rects:a,elements:o,strategy:s}=e,{boundary:c=`clippingAncestors`,rootBoundary:l=`viewport`,elementContext:u=`floating`,altBoundary:d=!1,padding:f=0}=hn(t,e),p=Nn(f),m=o[d?u===`floating`?`reference`:`floating`:u],h=Pn(await i.getClippingRect({element:await(i.isElement==null?void 0:i.isElement(m))??!0?m:m.contextElement||await(i.getDocumentElement==null?void 0:i.getDocumentElement(o.floating)),boundary:c,rootBoundary:l,strategy:s})),g=u===`floating`?{x:n,y:r,width:a.floating.width,height:a.floating.height}:a.reference,_=await(i.getOffsetParent==null?void 0:i.getOffsetParent(o.floating)),v=await(i.isElement==null?void 0:i.isElement(_))&&await(i.getScale==null?void 0:i.getScale(_))||{x:1,y:1},y=Pn(i.convertOffsetParentRelativeRectToViewportRelativeRect?await i.convertOffsetParentRelativeRectToViewportRelativeRect({elements:o,rect:g,offsetParent:_,strategy:s}):g);return{top:(h.top-y.top+p.top)/v.y,bottom:(y.bottom-h.bottom+p.bottom)/v.y,left:(h.left-y.left+p.left)/v.x,right:(y.right-h.right+p.right)/v.x}}var Ln=50,Rn=async(e,t,n)=>{let{placement:r=`bottom`,strategy:i=`absolute`,middleware:a=[],platform:o}=n,s=o.detectOverflow?o:{...o,detectOverflow:In},c=await(o.isRTL==null?void 0:o.isRTL(t)),l=await o.getElementRects({reference:e,floating:t,strategy:i}),{x:u,y:d}=Fn(l,r,c),f=r,p=0,m={};for(let n=0;n<a.length;n++){let h=a[n];if(!h)continue;let{name:g,fn:_}=h,{x:v,y,data:b,reset:x}=await _({x:u,y:d,initialPlacement:r,placement:f,strategy:i,middlewareData:m,rects:l,platform:s,elements:{reference:e,floating:t}});u=v??u,d=y??d,m[g]={...m[g],...b},x&&p<Ln&&(p++,typeof x==`object`&&(x.placement&&(f=x.placement),x.rects&&(l=x.rects===!0?await o.getElementRects({reference:e,floating:t,strategy:i}):x.rects),{x:u,y:d}=Fn(l,f,c)),n=-1)}return{x:u,y:d,placement:f,strategy:i,middlewareData:m}},zn=e=>({name:`arrow`,options:e,async fn(t){let{x:n,y:r,placement:i,rects:a,platform:o,elements:s,middlewareData:c}=t,{element:l,padding:u=0}=hn(e,t)||{};if(l==null)return{};let d=Nn(u),f={x:n,y:r},p=xn(i),m=yn(p),h=await o.getDimensions(l),g=p===`y`,_=g?`top`:`left`,v=g?`bottom`:`right`,y=g?`clientHeight`:`clientWidth`,b=a.reference[m]+a.reference[p]-f[p]-a.floating[m],x=f[p]-a.reference[p],S=await(o.getOffsetParent==null?void 0:o.getOffsetParent(l)),C=S?S[y]:0;(!C||!await(o.isElement==null?void 0:o.isElement(S)))&&(C=s.floating[y]||a.floating[m]);let w=b/2-x/2,T=C/2-h[m]/2-1,E=cn(d[_],T),D=cn(d[v],T),O=C-h[m]-D,k=C/2-h[m]/2+w,ee=mn(E,k,O),te=!c.arrow&&_n(i)!=null&&k!==ee&&a.reference[m]/2-(k<E?E:D)-h[m]/2<0,ne=te?k<E?k-E:k-O:0;return{[p]:f[p]+ne,data:{[p]:ee,centerOffset:k-ee-ne,...te&&{alignmentOffset:ne}},reset:te}}}),Bn=function(e){return e===void 0&&(e={}),{name:`flip`,options:e,async fn(t){var n;let{placement:r,middlewareData:i,rects:a,initialPlacement:o,platform:s,elements:c}=t,{mainAxis:l=!0,crossAxis:u=!0,fallbackPlacements:d,fallbackStrategy:f=`bestFit`,fallbackAxisSideDirection:p=`none`,flipAlignment:m=!0,...h}=hn(e,t);if((n=i.arrow)!=null&&n.alignmentOffset)return{};let g=gn(r),_=bn(o),v=gn(o)===o,y=await(s.isRTL==null?void 0:s.isRTL(c.floating)),b=d||(v||!m?[jn(o)]:Cn(o)),x=p!==`none`;!d&&x&&b.push(...An(o,m,p,y));let S=[o,...b],C=await s.detectOverflow(t,h),w=[],T=i.flip?.overflows||[];if(l&&w.push(C[g]),u){let e=Sn(r,a,y);w.push(C[e[0]],C[e[1]])}if(T=[...T,{placement:r,overflows:w}],!w.every(e=>e<=0)){let e=(i.flip?.index||0)+1,t=S[e];if(t&&(u!==`alignment`||_===bn(t)||T.every(e=>bn(e.placement)!==_||e.overflows[0]>0)))return{data:{index:e,overflows:T},reset:{placement:t}};let n=T.filter(e=>e.overflows[0]<=0).sort((e,t)=>e.overflows[1]-t.overflows[1])[0]?.placement;if(!n)switch(f){case`bestFit`:{let e=T.filter(e=>{if(x){let t=bn(e.placement);return t===_||t===`y`}return!0}).map(e=>[e.placement,e.overflows.filter(e=>e>0).reduce((e,t)=>e+t,0)]).sort((e,t)=>e[1]-t[1])[0]?.[0];e&&(n=e);break}case`initialPlacement`:n=o}if(r!==n)return{reset:{placement:n}}}return{}}}};function Vn(e,t){return{top:e.top-t.height,right:e.right-t.width,bottom:e.bottom-t.height,left:e.left-t.width}}function Hn(e){return sn.some(t=>e[t]>=0)}var Un=function(e){return e===void 0&&(e={}),{name:`hide`,options:e,async fn(t){let{rects:n,platform:r}=t,{strategy:i=`referenceHidden`,...a}=hn(e,t);switch(i){case`referenceHidden`:{let e=Vn(await r.detectOverflow(t,{...a,elementContext:`reference`}),n.reference);return{data:{referenceHiddenOffsets:e,referenceHidden:Hn(e)}}}case`escaped`:{let e=Vn(await r.detectOverflow(t,{...a,altBoundary:!0}),n.floating);return{data:{escapedOffsets:e,escaped:Hn(e)}}}default:return{}}}}},Wn=new Set([`left`,`top`]);async function Gn(e,t){let{placement:n,platform:r,elements:i}=e,a=await(r.isRTL==null?void 0:r.isRTL(i.floating)),o=gn(n),s=_n(n),c=bn(n)===`y`,l=Wn.has(o)?-1:1,u=a&&c?-1:1,d=hn(t,e),{mainAxis:f,crossAxis:p,alignmentAxis:m}=typeof d==`number`?{mainAxis:d,crossAxis:0,alignmentAxis:null}:{mainAxis:d.mainAxis||0,crossAxis:d.crossAxis||0,alignmentAxis:d.alignmentAxis};return s&&typeof m==`number`&&(p=s===`end`?m*-1:m),c?{x:p*u,y:f*l}:{x:f*l,y:p*u}}var Kn=function(e){return e===void 0&&(e=0),{name:`offset`,options:e,async fn(t){var n;let{x:r,y:i,placement:a,middlewareData:o}=t,s=await Gn(t,e);return a===o.offset?.placement&&(n=o.arrow)!=null&&n.alignmentOffset?{}:{x:r+s.x,y:i+s.y,data:{...s,placement:a}}}}},qn=function(e){return e===void 0&&(e={}),{name:`shift`,options:e,async fn(t){let{x:n,y:r,placement:i,platform:a}=t,{mainAxis:o=!0,crossAxis:s=!1,limiter:c={fn:e=>{let{x:t,y:n}=e;return{x:t,y:n}}},...l}=hn(e,t),u={x:n,y:r},d=await a.detectOverflow(t,l),f=bn(i),p=vn(f),m=u[p],h=u[f],g=(e,t)=>mn(t+d[e===`y`?`top`:`left`],t,t-d[e===`y`?`bottom`:`right`]);o&&(m=g(p,m)),s&&(h=g(f,h));let _=c.fn({...t,[p]:m,[f]:h});return{..._,data:{x:_.x-n,y:_.y-r,enabled:{[p]:o,[f]:s}}}}}},Jn=function(e){return e===void 0&&(e={}),{options:e,fn(t){let{x:n,y:r,placement:i,rects:a,middlewareData:o}=t,{offset:s=0,mainAxis:c=!0,crossAxis:l=!0}=hn(e,t),u={x:n,y:r},d=bn(i),f=vn(d),p=u[f],m=u[d],h=hn(s,t),g=typeof h==`number`?{mainAxis:h,crossAxis:0}:{mainAxis:h.mainAxis??0,crossAxis:h.crossAxis??0};if(c){let e=f===`y`?`height`:`width`,t=a.reference[f]-a.floating[e]+g.mainAxis,n=a.reference[f]+a.reference[e]-g.mainAxis;p<t?p=t:p>n&&(p=n)}if(l){let e=f===`y`?`width`:`height`,t=Wn.has(gn(i)),n=a.reference[d]-a.floating[e]+(t&&o.offset?.[d]||0)+(t?0:g.crossAxis),r=a.reference[d]+a.reference[e]+(t?0:o.offset?.[d]||0)-(t?g.crossAxis:0);m<n?m=n:m>r&&(m=r)}return{[f]:p,[d]:m}}}},Yn=function(e){return e===void 0&&(e={}),{name:`size`,options:e,async fn(t){let{placement:n,rects:r,platform:i,elements:a}=t,{apply:o=()=>{},...s}=hn(e,t),c=await i.detectOverflow(t,s),l=gn(n),u=_n(n),d=bn(n)===`y`,{width:f,height:p}=r.floating,m,h;l===`top`||l===`bottom`?(m=l,h=u===(await(i.isRTL==null?void 0:i.isRTL(a.floating))?`start`:`end`)?`left`:`right`):(h=l,m=u===`end`?`top`:`bottom`);let g=p-c.top-c.bottom,_=f-c.left-c.right,v=cn(p-c[m],g),y=cn(f-c[h],_),b=t.middlewareData.shift,x=!b,S=v,C=y;b!=null&&b.enabled.x&&(C=_),b!=null&&b.enabled.y&&(S=g),x&&!u&&(d?C=f-2*ln(c.left,c.right):S=p-2*ln(c.top,c.bottom)),await o({...t,availableWidth:C,availableHeight:S});let w=await i.getDimensions(a.floating);return f!==w.width||p!==w.height?{reset:{rects:!0}}:{}}}};function Xn(){return typeof window<`u`}function Zn(e){return $n(e)?(e.nodeName||``).toLowerCase():`#document`}function H(e){var t;return(e==null||(t=e.ownerDocument)==null?void 0:t.defaultView)||window}function Qn(e){return(($n(e)?e.ownerDocument:e.document)||window.document)?.documentElement}function $n(e){return Xn()?e instanceof Node||e instanceof H(e).Node:!1}function er(e){return Xn()?e instanceof Element||e instanceof H(e).Element:!1}function tr(e){return Xn()?e instanceof HTMLElement||e instanceof H(e).HTMLElement:!1}function nr(e){return!Xn()||typeof ShadowRoot>`u`?!1:e instanceof ShadowRoot||e instanceof H(e).ShadowRoot}function rr(e){let{overflow:t,overflowX:n,overflowY:r,display:i}=mr(e);return/auto|scroll|overlay|hidden|clip/.test(t+r+n)&&i!==`inline`&&i!==`contents`}function ir(e){return/^(table|td|th)$/.test(Zn(e))}function ar(e){try{if(e.matches(`:popover-open`))return!0}catch{}try{return e.matches(`:modal`)}catch{return!1}}var or=/transform|translate|scale|rotate|perspective|filter/,sr=/paint|layout|strict|content/,cr=e=>!!e&&e!==`none`,lr;function ur(e){let t=er(e)?mr(e):e;return cr(t.transform)||cr(t.translate)||cr(t.scale)||cr(t.rotate)||cr(t.perspective)||!fr()&&(cr(t.backdropFilter)||cr(t.filter))||or.test(t.willChange||``)||sr.test(t.contain||``)}function dr(e){let t=gr(e);for(;tr(t)&&!pr(t);){if(ur(t))return t;if(ar(t))return null;t=gr(t)}return null}function fr(){return lr??=typeof CSS<`u`&&CSS.supports&&CSS.supports(`-webkit-backdrop-filter`,`none`),lr}function pr(e){return/^(html|body|#document)$/.test(Zn(e))}function mr(e){return H(e).getComputedStyle(e)}function hr(e){return er(e)?{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}:{scrollLeft:e.scrollX,scrollTop:e.scrollY}}function gr(e){if(Zn(e)===`html`)return e;let t=e.assignedSlot||e.parentNode||nr(e)&&e.host||Qn(e);return nr(t)?t.host:t}function _r(e){let t=gr(e);return pr(t)?(e.ownerDocument||e).body:tr(t)&&rr(t)?t:_r(t)}function vr(e,t,n){t===void 0&&(t=[]),n===void 0&&(n=!0);let r=_r(e),i=r===e.ownerDocument?.body,a=H(r);if(i){let e=yr(a);return t.concat(a,a.visualViewport||[],rr(r)?r:[],e&&n?vr(e):[])}return t.concat(r,vr(r,[],n))}function yr(e){return e.parent&&Object.getPrototypeOf(e.parent)?e.frameElement:null}function br(e){let t=mr(e),n=parseFloat(t.width)||0,r=parseFloat(t.height)||0,i=tr(e),a=i?e.offsetWidth:n,o=i?e.offsetHeight:r,s=un(n)!==a||un(r)!==o;return s&&(n=a,r=o),{width:n,height:r,$:s}}function xr(e){return er(e)?e:e.contextElement}function Sr(e){let t=xr(e);if(!tr(t))return fn(1);let n=t.getBoundingClientRect(),{width:r,height:i,$:a}=br(t),o=(a?un(n.width):n.width)/r,s=(a?un(n.height):n.height)/i;return(!o||!Number.isFinite(o))&&(o=1),(!s||!Number.isFinite(s))&&(s=1),{x:o,y:s}}var Cr=fn(0);function wr(e){let t=H(e);return!fr()||!t.visualViewport?Cr:{x:t.visualViewport.offsetLeft,y:t.visualViewport.offsetTop}}function Tr(e,t,n){return t===void 0&&(t=!1),!!n&&t&&n===H(e)}function Er(e,t,n,r){t===void 0&&(t=!1),n===void 0&&(n=!1);let i=e.getBoundingClientRect(),a=xr(e),o=fn(1);t&&(r?er(r)&&(o=Sr(r)):o=Sr(e));let s=Tr(a,n,r)?wr(a):fn(0),c=(i.left+s.x)/o.x,l=(i.top+s.y)/o.y,u=i.width/o.x,d=i.height/o.y;if(a&&r){let e=H(a),t=er(r)?H(r):r,n=e,i=yr(n);for(;i&&t!==n;){let e=Sr(i),t=i.getBoundingClientRect(),r=mr(i),a=t.left+(i.clientLeft+parseFloat(r.paddingLeft))*e.x,o=t.top+(i.clientTop+parseFloat(r.paddingTop))*e.y;c*=e.x,l*=e.y,u*=e.x,d*=e.y,c+=a,l+=o,n=H(i),i=yr(n)}}return Pn({width:u,height:d,x:c,y:l})}function Dr(e,t){let n=hr(e).scrollLeft;return t?t.left+n:Er(Qn(e)).left+n}function Or(e,t){let n=e.getBoundingClientRect();return{x:n.left+t.scrollLeft-Dr(e,n),y:n.top+t.scrollTop}}function kr(e){let{elements:t,rect:n,offsetParent:r,strategy:i}=e,a=i===`fixed`,o=Qn(r),s=t?ar(t.floating):!1;if(r===o||s&&a)return n;let c={scrollLeft:0,scrollTop:0},l=fn(1),u=fn(0),d=tr(r);if((d||!a)&&((Zn(r)!==`body`||rr(o))&&(c=hr(r)),d)){let e=Er(r);l=Sr(r),u.x=e.x+r.clientLeft,u.y=e.y+r.clientTop}let f=o&&!d&&!a?Or(o,c):fn(0);return{width:n.width*l.x,height:n.height*l.y,x:n.x*l.x-c.scrollLeft*l.x+u.x+f.x,y:n.y*l.y-c.scrollTop*l.y+u.y+f.y}}function Ar(e){return e.getClientRects?Array.from(e.getClientRects()):[]}function jr(e){let t=hr(e),n=e.ownerDocument.body,r=ln(e.scrollWidth,e.clientWidth,n.scrollWidth,n.clientWidth),i=ln(e.scrollHeight,e.clientHeight,n.scrollHeight,n.clientHeight),a=-t.scrollLeft+Dr(e),o=-t.scrollTop;return mr(n).direction===`rtl`&&(a+=ln(e.clientWidth,n.clientWidth)-r),{width:r,height:i,x:a,y:o}}var Mr=25;function Nr(e,t,n){n===void 0&&(n=`viewport`);let r=n===`layoutViewport`,i=H(e),a=Qn(e),o=i.visualViewport,s=a.clientWidth,c=a.clientHeight,l=0,u=0;if(o){let e=!fr()||t===`fixed`;r?e||(l=-o.offsetLeft,u=-o.offsetTop):(s=o.width,c=o.height,e&&(l=o.offsetLeft,u=o.offsetTop))}if(Dr(a)<=0){let e=a.ownerDocument,t=e.body,n=getComputedStyle(t),r=e.compatMode===`CSS1Compat`&&parseFloat(n.marginLeft)+parseFloat(n.marginRight)||0,i=Math.abs(a.clientWidth-t.clientWidth-r),o=getComputedStyle(a).scrollbarGutter===`stable both-edges`?i/2:i;o<=Mr&&(s-=o)}return{width:s,height:c,x:l,y:u}}function Pr(e,t){let n=Er(e,!0,t===`fixed`),r=n.top+e.clientTop,i=n.left+e.clientLeft,a=Sr(e);return{width:e.clientWidth*a.x,height:e.clientHeight*a.y,x:i*a.x,y:r*a.y}}function Fr(e,t,n){let r;if(t===`viewport`||t===`layoutViewport`)r=Nr(e,n,t);else if(t===`document`)r=jr(Qn(e));else if(er(t))r=Pr(t,n);else{let n=wr(e);r={x:t.x-n.x,y:t.y-n.y,width:t.width,height:t.height}}return Pn(r)}function Ir(e,t){let n=t.get(e);if(n)return n;let r=vr(e,[],!1).filter(e=>er(e)&&Zn(e)!==`body`),i=null,a=mr(e).position===`fixed`,o=a?gr(e):e;for(;er(o)&&!pr(o);){let e=mr(o),t=ur(o),n=i?i.position:a?`fixed`:``;!t&&(n===`fixed`||n===`absolute`&&e.position===`static`)?r=r.filter(e=>e!==o):i=e,o=gr(o)}return t.set(e,r),r}function Lr(e){let{element:t,boundary:n,rootBoundary:r,strategy:i}=e,a=[...n===`clippingAncestors`?ar(t)?[]:Ir(t,this._c):[].concat(n),r],o=Fr(t,a[0],i),s=o.top,c=o.right,l=o.bottom,u=o.left;for(let e=1;e<a.length;e++){let n=Fr(t,a[e],i);s=ln(n.top,s),c=cn(n.right,c),l=cn(n.bottom,l),u=ln(n.left,u)}return{width:c-u,height:l-s,x:u,y:s}}function Rr(e){let{width:t,height:n}=br(e);return{width:t,height:n}}function zr(e,t,n){let r=tr(t),i=Qn(t),a=n===`fixed`,o=Er(e,!0,a,t),s={scrollLeft:0,scrollTop:0},c=fn(0);if((r||!a)&&((Zn(t)!==`body`||rr(i))&&(s=hr(t)),r)){let e=Er(t,!0,a,t);c.x=e.x+t.clientLeft,c.y=e.y+t.clientTop}!r&&i&&(c.x=Dr(i));let l=i&&!r&&!a?Or(i,s):fn(0);return{x:o.left+s.scrollLeft-c.x-l.x,y:o.top+s.scrollTop-c.y-l.y,width:o.width,height:o.height}}function Br(e){return mr(e).position===`static`}function Vr(e,t){if(!tr(e)||mr(e).position===`fixed`)return null;if(t)return t(e);let n=e.offsetParent;return Qn(e)===n&&(n=n.ownerDocument.body),n}function Hr(e,t){let n=H(e);if(ar(e))return n;if(!tr(e)){let t=gr(e);for(;t&&!pr(t);){if(er(t)&&!Br(t))return t;t=gr(t)}return n}let r=Vr(e,t);for(;r&&ir(r)&&Br(r);)r=Vr(r,t);return r&&pr(r)&&Br(r)&&!ur(r)?n:r||dr(e)||n}var Ur=async function(e){let t=this.getOffsetParent||Hr,n=this.getDimensions,r=await n(e.floating);return{reference:zr(e.reference,await t(e.floating),e.strategy),floating:{x:0,y:0,width:r.width,height:r.height}}};function Wr(e){return mr(e).direction===`rtl`}var Gr={convertOffsetParentRelativeRectToViewportRelativeRect:kr,getDocumentElement:Qn,getClippingRect:Lr,getOffsetParent:Hr,getElementRects:Ur,getClientRects:Ar,getDimensions:Rr,getScale:Sr,isElement:er,isRTL:Wr};function Kr(e,t){return e.x===t.x&&e.y===t.y&&e.width===t.width&&e.height===t.height}function qr(e,t,n){let r=null,i,a=Qn(e);function o(){var e;clearTimeout(i),(e=r)==null||e.disconnect(),r=null}function s(n,c){n===void 0&&(n=!1),c===void 0&&(c=1),o();let l=e.getBoundingClientRect(),{left:u,top:d,width:f,height:p}=l;if(n||t(),!f||!p)return;let m=dn(d),h=dn(a.clientWidth-(u+f)),g=dn(a.clientHeight-(d+p)),_=dn(u),v={rootMargin:-m+`px `+-h+`px `+-g+`px `+-_+`px`,threshold:ln(0,cn(1,c))||1},y=!0;function b(t){let n=t[0].intersectionRatio;if(!Kr(l,e.getBoundingClientRect()))return s();if(n!==c){if(!y)return s();n?s(!1,n):i=setTimeout(()=>{s(!1,1e-7)},1e3)}y=!1}try{r=new IntersectionObserver(b,{...v,root:a.ownerDocument})}catch{r=new IntersectionObserver(b,v)}r.observe(e)}let c=H(e),l=()=>s(n);return c.addEventListener(`resize`,l),s(!0),()=>{c.removeEventListener(`resize`,l),o()}}function Jr(e,t,n,r){r===void 0&&(r={});let{ancestorScroll:i=!0,ancestorResize:a=!0,elementResize:o=typeof ResizeObserver==`function`,layoutShift:s=typeof IntersectionObserver==`function`,animationFrame:c=!1}=r,l=xr(e),u=i||a?[...l?vr(l):[],...t?vr(t):[]]:[];u.forEach(e=>{i&&e.addEventListener(`scroll`,n),a&&e.addEventListener(`resize`,n)});let d=l&&s?qr(l,n,a):null,f=-1,p=null;o&&(p=new ResizeObserver(e=>{let[r]=e;r&&r.target===l&&p&&t&&(p.unobserve(t),cancelAnimationFrame(f),f=requestAnimationFrame(()=>{var e;(e=p)==null||e.observe(t)})),n()}),l&&!c&&p.observe(l),t&&p.observe(t));let m,h=c?Er(e):null;c&&g();function g(){let t=Er(e);h&&!Kr(h,t)&&n(),h=t,m=requestAnimationFrame(g)}return n(),()=>{var e;u.forEach(e=>{i&&e.removeEventListener(`scroll`,n),a&&e.removeEventListener(`resize`,n)}),d?.(),(e=p)==null||e.disconnect(),p=null,c&&cancelAnimationFrame(m)}}var Yr=Kn,Xr=qn,Zr=Bn,Qr=Yn,$r=Un,ei=zn,ti=Jn,ni=(e,t,n)=>{let r=new Map,i=n??{},a={...Gr,...i.platform,_c:r};return Rn(e,t,{...i,platform:a})};function ri(e){return typeof e==`object`&&!!e&&`$el`in e}function ii(e){if(ri(e)){let t=e.$el;return $n(t)&&Zn(t)===`#comment`?null:t}return e}function ai(e){return typeof e==`function`?e():b(e)}function oi(e){return{name:`arrow`,options:e,fn(t){let n=ii(ai(e.element));return n==null?{}:ei({element:n,padding:e.padding}).fn(t)}}}function si(e){return typeof window>`u`?1:(e.ownerDocument.defaultView||window).devicePixelRatio||1}function ci(e,t){let n=si(e);return Math.round(t*n)/n}function li(e,t,n){n===void 0&&(n={});let r=n.whileElementsMounted,i=M(()=>ai(n.open)??!0),a=M(()=>ai(n.middleware)),o=M(()=>ai(n.placement)??`bottom`),s=M(()=>ai(n.strategy)??`absolute`),c=M(()=>ai(n.transform)??!0),l=M(()=>ii(e.value)),d=M(()=>ii(t.value)),f=F(0),p=F(0),m=F(s.value),h=F(o.value),g=w({}),_=F(!1),v=M(()=>{let e={position:m.value,left:`0`,top:`0`};if(!d.value)return e;let t=ci(d.value,f.value),n=ci(d.value,p.value);return c.value?{...e,transform:`translate(`+t+`px, `+n+`px)`,...si(d.value)>=1.5&&{willChange:`transform`}}:{position:m.value,left:t+`px`,top:n+`px`}}),y;function b(){if(l.value==null||d.value==null)return;let e=i.value;ni(l.value,d.value,{middleware:a.value,placement:o.value,strategy:s.value}).then(t=>{f.value=t.x,p.value=t.y,m.value=t.strategy,h.value=t.placement,g.value=t.middlewareData,_.value=e!==!1})}function x(){typeof y==`function`&&(y(),y=void 0)}function C(){if(x(),r===void 0){b();return}if(l.value!=null&&d.value!=null){y=r(l.value,d.value,b);return}}function T(){i.value||(_.value=!1)}return V([a,o,s,i],b,{flush:`sync`}),V([l,d],C,{flush:`sync`}),V(i,T,{flush:`sync`}),u()&&Oe(x),{x:S(f),y:S(p),strategy:S(m),placement:S(h),middlewareData:S(g),isPositioned:S(_),floatingStyles:v,update:b}}var ui=[`dir`],di={side:`bottom`,sideOffset:0,sideFlip:!0,align:`center`,alignOffset:0,alignFlip:!0,arrowPadding:0,hideShiftedArrow:!0,avoidCollisions:!0,collisionBoundary:()=>[],collisionPadding:0,sticky:`partial`,hideWhenDetached:!1,positionStrategy:`fixed`,updatePositionStrategy:`optimized`,prioritizePosition:!1},[fi,pi]=oe(`PopperContent`),mi=R({inheritAttrs:!1,__name:`PopperContent`,props:We({memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},{...di}),emits:[`placed`],setup(e,{emit:t}){let n=e,r=t,a=$t(),{forwardRef:s,currentElement:c}=ie(),u=l(M(()=>n.dir)),d=F(),f=F(),{width:p,height:m}=Ct(f),h=M(()=>n.side+(n.align===`center`?``:`-${n.align}`)),g=M(()=>typeof n.collisionPadding==`number`?n.collisionPadding:{top:0,right:0,bottom:0,left:0,...n.collisionPadding}),_=M(()=>Array.isArray(n.collisionBoundary)?n.collisionBoundary:[n.collisionBoundary]),v=M(()=>({padding:g.value,boundary:_.value.filter(rn),altBoundary:_.value.length>0})),y=M(()=>({mainAxis:n.sideFlip,crossAxis:n.alignFlip})),x=M(()=>[Yr({mainAxis:n.sideOffset+m.value,alignmentAxis:n.alignOffset}),n.prioritizePosition&&n.avoidCollisions&&Zr({...v.value,...y.value}),n.avoidCollisions&&Xr({mainAxis:!0,crossAxis:!!n.prioritizePosition,limiter:n.sticky===`partial`?ti():void 0,...v.value}),!n.prioritizePosition&&n.avoidCollisions&&Zr({...v.value,...y.value}),Qr({...v.value,apply:({elements:e,rects:t,availableWidth:n,availableHeight:r})=>{let{width:i,height:a}=t.reference,o=e.floating.style;o.setProperty(`--reka-popper-available-width`,`${n}px`),o.setProperty(`--reka-popper-available-height`,`${r}px`),o.setProperty(`--reka-popper-anchor-width`,`${i}px`),o.setProperty(`--reka-popper-anchor-height`,`${a}px`)}}),f.value&&oi({element:f.value,padding:n.arrowPadding}),an({arrowWidth:p.value,arrowHeight:m.value,dir:u.value}),n.hideWhenDetached&&$r({strategy:`referenceHidden`,...v.value})]),{floatingStyles:S,placement:C,isPositioned:w,middlewareData:T,update:E}=li(M(()=>n.reference??a.anchor.value),d,{strategy:n.positionStrategy,placement:h,whileElementsMounted:(...e)=>Jr(...e,{layoutShift:!n.disableUpdateOnLayoutShift,animationFrame:n.updatePositionStrategy===`always`}),middleware:x}),D=M(()=>on(C.value)[0]),O=M(()=>on(C.value)[1]);o(()=>{w.value&&r(`placed`)});let k=M(()=>{let e=T.value.arrow?.centerOffset!==0;return n.hideShiftedArrow&&e}),ee=F(``);return re(()=>{c.value&&(ee.value=window.getComputedStyle(c.value).zIndex)}),pi({placedSide:D,onArrowChange:e=>f.value=e,arrowX:M(()=>T.value.arrow?.x??0),arrowY:M(()=>T.value.arrow?.y??0),shouldHideArrow:k}),(e,t)=>(N(),P(`div`,{ref_key:`floatingRef`,ref:d,"data-reka-popper-content-wrapper":``,dir:b(u),style:i({...b(S),transform:b(w)?b(S).transform:`translate(0, -200%)`,minWidth:`max-content`,zIndex:ee.value,"--reka-popper-transform-origin":[b(T).transformOrigin?.x,b(T).transformOrigin?.y].join(` `),...b(T).hide?.referenceHidden&&{visibility:`hidden`,pointerEvents:`none`}})},[n.memoDependencies?ae([n.asChild,n.as,D.value,O.value,b(w),...Object.values(e.$attrs),...n.memoDependencies],()=>(N(),I(b(A),j({key:0,ref:b(s)},e.$attrs,{"as-child":n.asChild,as:n.as,"data-side":D.value,"data-align":O.value,style:{animation:b(w)?void 0:`none`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`style`])),t,0):(N(),I(b(A),j({key:1,ref:b(s)},e.$attrs,{"as-child":n.asChild,as:n.as,"data-side":D.value,"data-align":O.value,dir:b(u),style:{animation:b(w)?void 0:`none`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`dir`,`style`]))],12,ui))}});function hi(e){let t=s({nonce:F()});return M(()=>e?.value||t.nonce?.value)}var gi=[` `,`Enter`,`ArrowUp`,`ArrowDown`],_i=[` `,`Enter`];function vi(e,t,n){return e===void 0?!1:Array.isArray(e)?e.some(e=>yi(e,t,n)):yi(e,t,n)}function yi(e,t,n){return e===void 0||t===void 0?!1:typeof e==`string`?e===t:typeof n==`function`?n(e,t):typeof n==`string`?e?.[n]===t?.[n]:le(e,t)}function bi(e){return e==null||e===``||Array.isArray(e)&&e.length===0}var xi=[`value`],[Si,Ci]=oe(`SelectRoot`),wi=R({inheritAttrs:!1,__name:`SelectRoot`,props:{open:{type:Boolean,required:!1,default:void 0},defaultOpen:{type:Boolean,required:!1},defaultValue:{type:null,required:!1},modelValue:{type:null,required:!1,default:void 0},nullableValue:{type:String,required:!1,default:``},by:{type:[String,Function],required:!1},dir:{type:String,required:!1},multiple:{type:Boolean,required:!1},autocomplete:{type:String,required:!1},disabled:{type:Boolean,required:!1},name:{type:String,required:!1},required:{type:Boolean,required:!1}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=e,r=t,{required:i,disabled:a,multiple:o,dir:s}=f(n),c=C(n,`modelValue`,r,{defaultValue:n.defaultValue??(o.value?[]:void 0),passive:n.modelValue===void 0,deep:!0}),u=C(n,`open`,r,{defaultValue:n.defaultOpen,passive:n.open===void 0}),d=F(),p=F(),m=F({x:0,y:0}),h=M(()=>o.value&&Array.isArray(c.value)?c.value?.length===0:se(c.value));Je({isProvider:!0});let g=l(s),_=ft(d),v=F(new Set),y=M(()=>Array.from(v.value).map(e=>e.value).join(`;`));function x(e){if(o.value){let t=Array.isArray(c.value)?[...c.value]:[],r=t.findIndex(t=>yi(t,e,n.by));r===-1?t.push(e):t.splice(r,1),c.value=[...t]}else c.value=e}function S(e){return Array.from(v.value).find(t=>vi(e,t.value,n.by))}return Ci({triggerElement:d,onTriggerChange:e=>{d.value=e},valueElement:p,onValueElementChange:e=>{p.value=e},contentId:``,modelValue:c,onValueChange:x,by:n.by,open:u,multiple:o,required:i,onOpenChange:e=>{u.value=e},dir:g,triggerPointerDownPosRef:m,disabled:a,isEmptyModelValue:h,optionsSet:v,onOptionAdd:e=>{let t=S(e.value);t&&v.value.delete(t),v.value.add(e)},onOptionRemove:e=>{let t=S(e.value);t&&v.value.delete(t)}}),(e,t)=>(N(),I(b(tn),null,{default:B(()=>[z(e.$slots,`default`,{modelValue:b(c),open:b(u)}),b(_)&&e.name?(N(),I(Ti,{key:y.value,"aria-hidden":`true`,tabindex:`-1`,multiple:b(o),required:b(i),name:e.name,autocomplete:e.autocomplete,disabled:b(a),value:b(c)},{default:B(()=>[b(se)(b(c))?(N(),P(`option`,{key:0,value:e.nullableValue},null,8,xi)):ze(`v-if`,!0),(N(!0),P(k,null,me(Array.from(v.value),e=>(N(),P(`option`,j({key:e.value??``},{ref_for:!0},e),null,16))),128))]),_:1},8,[`multiple`,`required`,`name`,`autocomplete`,`disabled`,`value`])):ze(`v-if`,!0)]),_:3}))}}),Ti=R({__name:`BubbleSelect`,props:{autocomplete:{type:String,required:!1},autofocus:{type:Boolean,required:!1},disabled:{type:Boolean,required:!1},form:{type:String,required:!1},multiple:{type:Boolean,required:!1},name:{type:String,required:!1},required:{type:Boolean,required:!1},size:{type:Number,required:!1},value:{type:null,required:!1}},setup(e){let t=e,n=F(),r=Si();V(()=>t.value,(e,t)=>{let r=window.HTMLSelectElement.prototype,i=Object.getOwnPropertyDescriptor(r,`value`).set;if(e!==t&&i&&n.value){let t=new Event(`change`,{bubbles:!0});i.call(n.value,e),n.value.dispatchEvent(t)}});function i(e){r.onValueChange(e.target.value)}return(e,r)=>(N(),I(b(Qt),{"as-child":``},{default:B(()=>[He(`select`,j({ref_key:`selectElement`,ref:n},t,{onInput:i}),[z(e.$slots,`default`)],16)]),_:3}))}}),Ei=R({__name:`SelectPopperPosition`,props:{memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1,default:`start`},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1,default:10},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Ke(e);return(e,n)=>(N(),I(b(mi),j(b(t),{style:{boxSizing:`border-box`,"--reka-select-content-transform-origin":`var(--reka-popper-transform-origin)`,"--reka-select-content-available-width":`var(--reka-popper-available-width)`,"--reka-select-content-available-height":`var(--reka-popper-available-height)`,"--reka-select-trigger-width":`var(--reka-popper-anchor-width)`,"--reka-select-trigger-height":`var(--reka-popper-anchor-height)`}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Di={onViewportChange:()=>{},itemTextRefCallback:()=>{},itemRefCallback:()=>{}},[Oi,ki]=oe(`SelectContent`),Ai=R({__name:`SelectContentImpl`,props:{position:{type:String,required:!1,default:`item-aligned`},bodyLock:{type:Boolean,required:!1,default:!0},memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1,default:`start`},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},disableOutsidePointerEvents:{type:Boolean,required:!1,default:!0}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=Si();ut(),ot(n.bodyLock);let{CollectionSlot:a,getItems:o}=Je(),s=F();St(s);let{search:c,handleTypeaheadSearch:l}=wt(),u=F(),d=F(),f=F(),p=F(!1),m=F(!1),h=F(!1);function g(){d.value&&s.value&&Xt([d.value,s.value])}V(p,()=>{g()});let{onOpenChange:_,triggerPointerDownPosRef:v}=i;re(e=>{if(!s.value)return;let t={x:0,y:0},n=e=>{t={x:Math.abs(Math.round(e.pageX)-(v.value?.x??0)),y:Math.abs(Math.round(e.pageY)-(v.value?.y??0))}},r=e=>{e.pointerType!==`touch`&&(t.x<=10&&t.y<=10?e.preventDefault():s.value?.contains(e.target)||_(!1),document.removeEventListener(`pointermove`,n),v.value=null)};v.value!==null&&(document.addEventListener(`pointermove`,n),document.addEventListener(`pointerup`,r,{capture:!0,once:!0})),e(()=>{document.removeEventListener(`pointermove`,n),document.removeEventListener(`pointerup`,r,{capture:!0})})});function y(e){let t=e.ctrlKey||e.altKey||e.metaKey;if(e.key===`Tab`&&e.preventDefault(),!t&&e.key.length===1&&l(e.key,o()),[`ArrowUp`,`ArrowDown`,`Home`,`End`].includes(e.key)){let t=[...o().map(e=>e.ref)];if([`ArrowUp`,`End`].includes(e.key)&&(t=t.slice().reverse()),[`ArrowUp`,`ArrowDown`].includes(e.key)){let n=e.target,r=t.indexOf(n);t=t.slice(r+1)}setTimeout(()=>Xt(t)),e.preventDefault()}}let x=M(()=>n.position===`popper`?n:{}),S=Ke(x.value);return ki({content:s,viewport:u,onViewportChange:e=>{u.value=e},itemRefCallback:(e,t,n)=>{let r=!m.value&&!n,a=vi(i.modelValue.value,t,i.by);if(i.multiple.value){if(h.value)return;(a||r)&&(d.value=e,a&&(h.value=!0))}else(a||r)&&(d.value=e);r&&(m.value=!0)},selectedItem:d,selectedItemText:f,onItemLeave:()=>{s.value?.focus()},itemTextRefCallback:(e,t,n)=>{let r=!m.value&&!n;(vi(i.modelValue.value,t,i.by)||r)&&(f.value=e)},focusSelectedItem:g,position:n.position,isPositioned:p,searchRef:c}),(e,t)=>(N(),I(b(a),null,{default:B(()=>[L(b(Kt),{"as-child":``,onMountAutoFocus:t[6]||=fe(()=>{},[`prevent`]),onUnmountAutoFocus:t[7]||=e=>{r(`closeAutoFocus`,e),!e.defaultPrevented&&(b(i).triggerElement.value?.focus({preventScroll:!0}),e.preventDefault())}},{default:B(()=>[L(b(Mt),{"as-child":``,"disable-outside-pointer-events":e.disableOutsidePointerEvents,onFocusOutside:t[2]||=fe(()=>{},[`prevent`]),onDismiss:t[3]||=e=>b(i).onOpenChange(!1),onEscapeKeyDown:t[4]||=e=>r(`escapeKeyDown`,e),onPointerDownOutside:t[5]||=e=>r(`pointerDownOutside`,e)},{default:B(()=>[(N(),I(Ye(e.position===`popper`?Ei:Ni),j({...e.$attrs,...b(S)},{id:b(i).contentId,ref:e=>{if(!e)return;let t=b(De)(e);t?.hasAttribute(`data-reka-popper-content-wrapper`)?s.value=t.firstElementChild:s.value=t},role:`listbox`,"data-state":b(i).open.value?`open`:`closed`,dir:b(i).dir.value,style:{display:`flex`,flexDirection:`column`,outline:`none`},onContextmenu:t[0]||=fe(()=>{},[`prevent`]),onPlaced:t[1]||=e=>p.value=!0,onKeydown:y}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`id`,`data-state`,`dir`,`onKeydown`]))]),_:3},8,[`disable-outside-pointer-events`])]),_:3})]),_:3}))}}),[ji,Mi]=oe(`SelectItemAlignedPosition`),Ni=R({inheritAttrs:!1,__name:`SelectItemAlignedPosition`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`placed`],setup(e,{emit:t}){let n=e,r=t,{getItems:a}=Je(),o=Si(),s=Oi(),c=F(!1),l=F(!0),u=F(),{forwardRef:d,currentElement:f}=ie(),{viewport:p,selectedItem:m,selectedItemText:h,focusSelectedItem:g}=s;function _(){if(o.triggerElement.value&&o.valueElement.value&&u.value&&f.value&&p?.value&&m?.value&&h?.value){let e=o.triggerElement.value.getBoundingClientRect(),t=f.value.getBoundingClientRect(),n=o.valueElement.value.getBoundingClientRect(),i=h.value.getBoundingClientRect();if(o.dir.value!==`rtl`){let r=i.left-t.left,a=n.left-r,o=e.left-a,s=e.width+o,c=Math.max(s,t.width),l=window.innerWidth-10,d=Qe(a,10,Math.max(10,l-c));u.value.style.minWidth=`${s}px`,u.value.style.left=`${d}px`}else{let r=t.right-i.right,a=window.innerWidth-n.right-r,o=window.innerWidth-e.right-a,s=e.width+o,c=Math.max(s,t.width),l=window.innerWidth-10,d=Qe(a,10,Math.max(10,l-c));u.value.style.minWidth=`${s}px`,u.value.style.right=`${d}px`}let s=a().map(e=>e.ref),l=window.innerHeight-20,d=p.value.scrollHeight,g=window.getComputedStyle(f.value),_=Number.parseInt(g.borderTopWidth,10),v=Number.parseInt(g.paddingTop,10),y=Number.parseInt(g.borderBottomWidth,10),b=Number.parseInt(g.paddingBottom,10),x=_+v+d+b+y,S=Math.min(m.value.offsetHeight*5,x),C=window.getComputedStyle(p.value),w=Number.parseInt(C.paddingTop,10),T=Number.parseInt(C.paddingBottom,10),E=e.top+e.height/2-10,D=l-E,O=m.value.offsetHeight/2,k=m.value.offsetTop+O,ee=_+v+k,te=x-ee;if(ee<=E){let e=m.value===s.at(-1);u.value.style.bottom=`0px`;let t=f.value.clientHeight-p.value.offsetTop-p.value.offsetHeight,n=ee+Math.max(D,O+(e?T:0)+t+y);u.value.style.height=`${n}px`}else{let e=m.value===s[0];u.value.style.top=`0px`;let t=Math.max(E,_+p.value.offsetTop+(e?w:0)+O)+te;u.value.style.height=`${t}px`,p.value.scrollTop=ee-E+p.value.offsetTop}u.value.style.margin=`10px 0`,u.value.style.minHeight=`${S}px`,u.value.style.maxHeight=`${l}px`,r(`placed`),requestAnimationFrame(()=>c.value=!0)}}let v=F(``);Me(async()=>{await xe(),_(),f.value&&(v.value=window.getComputedStyle(f.value).zIndex)});function y(e){e&&l.value===!0&&(_(),g?.(),l.value=!1)}return x(o.triggerElement,()=>{_()}),Mi({contentWrapper:u,shouldExpandOnScrollRef:c,onScrollButtonChange:y}),(e,t)=>(N(),P(`div`,{ref_key:`contentWrapperElement`,ref:u,style:i({display:`flex`,flexDirection:`column`,position:`fixed`,zIndex:v.value})},[L(b(A),j({ref:b(d),style:{boxSizing:`border-box`,maxHeight:`100%`}},{...e.$attrs,...n}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16)],4))}}),Pi=R({inheritAttrs:!1,__name:`SelectProvider`,props:{context:{type:Object,required:!0}},setup(e){return Ci(e.context),ki(Di),(e,t)=>z(e.$slots,`default`)}}),Fi={key:1},Ii=R({inheritAttrs:!1,__name:`SelectContent`,props:{forceMount:{type:Boolean,required:!1},position:{type:String,required:!1},bodyLock:{type:Boolean,required:!1},memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},disableOutsidePointerEvents:{type:Boolean,required:!1}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(t,{emit:n}){let r=t,i=a(r,n),o=Si(),s=F();Me(()=>{s.value=new DocumentFragment});let c=F(),l=M(()=>r.forceMount||o.open.value),u=F(l.value),d;function f(){d&&=(clearTimeout(d),void 0)}return V(l,(e,t,n)=>{f(),d=setTimeout(()=>{u.value=l.value,d=void 0}),n(f)}),we(f),(t,n)=>l.value||u.value||c.value?.present?(N(),I(b(qe),{key:0,ref_key:`presenceRef`,ref:c,present:l.value},{default:B(()=>[L(Ai,Ze(ve({...b(i),...t.$attrs})),{default:B(()=>[z(t.$slots,`default`)]),_:3},16)]),_:3},8,[`present`])):s.value?(N(),P(`div`,Fi,[(N(),I(e,{to:s.value},[L(Pi,{context:b(o)},{default:B(()=>[z(t.$slots,`default`)]),_:3},8,[`context`])],8,[`to`]))])):ze(`v-if`,!0)}}),Li=R({__name:`SelectIcon`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(N(),I(b(A),{"aria-hidden":`true`,as:e.as,"as-child":e.asChild},{default:B(()=>[z(e.$slots,`default`,{},()=>[t[0]||=ge(`▼`)])]),_:3},8,[`as`,`as-child`]))}}),[Ri,zi]=oe(`SelectItem`),Bi=R({__name:`SelectItem`,props:{value:{type:null,required:!0},disabled:{type:Boolean,required:!1},textValue:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`select`],setup(e,{emit:t}){let n=e,r=t,{disabled:i}=f(n),a=Si(),o=Oi(),{forwardRef:s,currentElement:c}=ie(),{CollectionItem:l}=Je(),u=M(()=>vi(a.modelValue?.value,n.value,a.by)),d=F(!1),p=F(n.textValue??``),h=ne(void 0,`reka-select-item-text`);async function g(e){e.defaultPrevented||$e(`select.select`,_,{originalEvent:e,value:n.value})}async function _(e){await xe(),r(`select`,e),!e.defaultPrevented&&(i.value||(a.onValueChange(n.value),a.multiple.value||a.onOpenChange(!1)))}async function v(e){await xe(),!e.defaultPrevented&&(i.value?o.onItemLeave?.():e.currentTarget?.focus({preventScroll:!0}))}async function y(e){await xe(),!e.defaultPrevented&&e.currentTarget===m()&&o.onItemLeave?.()}async function x(e){await xe(),!e.defaultPrevented&&(o.searchRef?.value===``||e.key!==` `)&&(_i.includes(e.key)&&g(e),e.key===` `&&e.preventDefault())}if(n.value===``)throw Error(`A <SelectItem /> must have a value prop that is not an empty string. This is because the Select value can be set to an empty string to clear the selection and show the placeholder.`);return Me(()=>{c.value&&o.itemRefCallback(c.value,n.value,n.disabled)}),zi({value:n.value,disabled:i,textId:h,isSelected:u,onItemTextChange:e=>{p.value=((p.value||e?.textContent)??``).trim()}}),(e,t)=>(N(),I(b(l),{value:{textValue:p.value}},{default:B(()=>[L(b(A),{ref:b(s),role:`option`,"aria-labelledby":b(h),"data-highlighted":d.value?``:void 0,"aria-selected":u.value,"data-state":u.value?`checked`:`unchecked`,"aria-disabled":b(i)||void 0,"data-disabled":b(i)?``:void 0,tabindex:b(i)?void 0:-1,as:e.as,"as-child":e.asChild,onFocus:t[0]||=e=>d.value=!0,onBlur:t[1]||=e=>d.value=!1,onPointerup:g,onPointerdown:t[2]||=e=>{e.currentTarget.focus({preventScroll:!0})},onTouchend:t[3]||=fe(()=>{},[`prevent`,`stop`]),onPointermove:v,onPointerleave:y,onKeydown:x},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`aria-labelledby`,`data-highlighted`,`aria-selected`,`data-state`,`aria-disabled`,`data-disabled`,`tabindex`,`as`,`as-child`])]),_:3},8,[`value`]))}}),Vi=R({__name:`SelectItemIndicator`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Ri();return(e,r)=>b(n).isSelected.value?(N(),I(b(A),j({key:0,"aria-hidden":`true`},t),{default:B(()=>[z(e.$slots,`default`)]),_:3},16)):ze(`v-if`,!0)}}),Hi=R({inheritAttrs:!1,__name:`SelectItemText`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Si(),r=Oi(),i=Ri(),{forwardRef:a,currentElement:o}=ie(),s=M(()=>({value:i.value,disabled:i.disabled.value,textContent:o.value?.textContent??i.value?.toString()??``}));return Me(()=>{o.value&&(i.onItemTextChange(o.value),r.itemTextRefCallback(o.value,i.value,i.disabled.value),n.onOptionAdd(s.value))}),we(()=>{n.onOptionRemove(s.value)}),(e,n)=>(N(),I(b(A),j({id:b(i).textId,ref:b(a)},{...t,...e.$attrs}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16,[`id`]))}}),Ui=R({__name:`SelectPortal`,props:{to:{type:null,required:!1},disabled:{type:Boolean,required:!1},defer:{type:Boolean,required:!1},forceMount:{type:Boolean,required:!1}},setup(e){let t=e;return(e,n)=>(N(),I(b(Zt),Ze(ve(t)),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Wi=R({__name:`SelectScrollButtonImpl`,emits:[`autoScroll`],setup(e,{emit:t}){let n=t,{getItems:r}=Je(),i=Oi(),a=F(null);function o(){a.value!==null&&(window.clearInterval(a.value),a.value=null)}re(()=>{r().map(e=>e.ref).find(e=>e===m())?.scrollIntoView({block:`nearest`})});function s(){a.value===null&&(a.value=window.setInterval(()=>{n(`autoScroll`)},50))}function c(){i.onItemLeave?.(),a.value===null&&(a.value=window.setInterval(()=>{n(`autoScroll`)},50))}return Ie(()=>o()),(e,t)=>(N(),I(b(A),j({"aria-hidden":`true`,style:{flexShrink:0}},e.$parent?.$props,{onPointerdown:s,onPointermove:c,onPointerleave:t[0]||=()=>{o()}}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}}),Gi=R({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Oi(),n=t.position===`item-aligned`?ji():void 0,{forwardRef:r,currentElement:i}=ie(),a=F(!1);return re(e=>{if(t.viewport?.value&&t.isPositioned?.value){let n=t.viewport.value;function r(){let e=n.scrollHeight-n.clientHeight;a.value=Math.ceil(n.scrollTop)<e}r(),n.addEventListener(`scroll`,r),e(()=>n.removeEventListener(`scroll`,r))}}),V(i,()=>{i.value&&n?.onScrollButtonChange(i.value)}),(e,n)=>a.value?(N(),I(Wi,{key:0,ref:b(r),onAutoScroll:n[0]||=()=>{let{viewport:e,selectedItem:n}=b(t);e?.value&&n?.value&&(e.value.scrollTop=e.value.scrollTop+n.value.offsetHeight)}},{default:B(()=>[z(e.$slots,`default`)]),_:3},512)):ze(`v-if`,!0)}}),Ki=R({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=Oi(),n=t.position===`item-aligned`?ji():void 0,{forwardRef:r,currentElement:i}=ie(),a=F(!1);return re(e=>{if(t.viewport?.value&&t.isPositioned?.value){let n=t.viewport.value;function r(){a.value=n.scrollTop>0}r(),n.addEventListener(`scroll`,r),e(()=>n.removeEventListener(`scroll`,r))}}),V(i,()=>{i.value&&n?.onScrollButtonChange(i.value)}),(e,n)=>a.value?(N(),I(Wi,{key:0,ref:b(r),onAutoScroll:n[0]||=()=>{let{viewport:e,selectedItem:n}=b(t);e?.value&&n?.value&&(e.value.scrollTop=e.value.scrollTop-n.value.offsetHeight)}},{default:B(()=>[z(e.$slots,`default`)]),_:3},512)):ze(`v-if`,!0)}}),qi=R({__name:`SelectTrigger`,props:{disabled:{type:Boolean,required:!1},reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e,n=Si(),{forwardRef:r,currentElement:i}=ie(),a=M(()=>n.disabled?.value||t.disabled);n.contentId||=ne(void 0,`reka-select-content`),Me(()=>{n.onTriggerChange(i.value)});let{getItems:o}=Je(),{search:s,handleTypeaheadSearch:c,resetTypeahead:l}=wt();function u(){a.value||(n.onOpenChange(!0),l())}function d(e){u(),n.triggerPointerDownPosRef.value={x:Math.round(e.pageX),y:Math.round(e.pageY)}}function f(e){return e.button===0&&e.ctrlKey===!1}let p=!1;function m(e){if(e.pointerType===`touch`)return e.preventDefault();let t=e.target;t.hasPointerCapture(e.pointerId)&&t.releasePointerCapture(e.pointerId),f(e)&&(d(e),p=!0)}function h(e){f(e)&&e.preventDefault()}function g(e){p||e.currentTarget?.focus(),p=!1}return(e,t)=>(N(),I(b(nn),{"as-child":``,reference:e.reference},{default:B(()=>[L(b(A),{ref:b(r),role:`combobox`,type:e.as===`button`?`button`:void 0,"aria-controls":b(n).contentId,"aria-expanded":b(n).open.value||!1,"aria-required":b(n).required?.value,"aria-autocomplete":`none`,disabled:a.value,dir:b(n)?.dir.value,"data-state":b(n)?.open.value?`open`:`closed`,"data-disabled":a.value?``:void 0,"data-placeholder":b(bi)(b(n).modelValue?.value)?``:void 0,"as-child":e.asChild,as:e.as,onClick:g,onPointerdown:m,onMousedown:h,onPointerup:t[0]||=fe(e=>{e.pointerType===`touch`&&d(e)},[`prevent`]),onKeydown:t[1]||=e=>{let t=b(s)!==``;!(e.ctrlKey||e.altKey||e.metaKey)&&e.key.length===1&&t&&e.key===` `||(b(c)(e.key,b(o)()),b(gi).includes(e.key)&&(u(),e.preventDefault()))}},{default:B(()=>[z(e.$slots,`default`)]),_:3},8,[`type`,`aria-controls`,`aria-expanded`,`aria-required`,`disabled`,`dir`,`data-state`,`data-disabled`,`data-placeholder`,`as-child`,`as`])]),_:3},8,[`reference`]))}}),Ji=R({__name:`SelectValue`,props:{placeholder:{type:String,required:!1,default:``},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,{forwardRef:n,currentElement:r}=ie(),i=Si();Me(()=>{i.valueElement=r});let a=M(()=>{let e=[],t=Array.from(i.optionsSet.value),n=e=>t.find(t=>vi(e,t.value,i.by));return e=Array.isArray(i.modelValue.value)?i.modelValue.value.map(e=>n(e)?.textContent??``):[n(i.modelValue.value)?.textContent??``],e.filter(Boolean)}),o=M(()=>a.value.length?a.value.join(`, `):t.placeholder);return(e,r)=>(N(),I(b(A),{ref:b(n),as:e.as,"as-child":e.asChild,style:{pointerEvents:`none`},"data-placeholder":a.value.length?void 0:t.placeholder},{default:B(()=>[z(e.$slots,`default`,{selectedLabel:a.value,modelValue:b(i).modelValue.value},()=>[ge(ce(o.value),1)])]),_:3},8,[`as`,`as-child`,`data-placeholder`]))}}),Yi=R({__name:`SelectViewport`,props:{nonce:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{nonce:n}=f(t),r=hi(n),i=Oi(),a=i.position===`item-aligned`?ji():void 0,{forwardRef:o,currentElement:s}=ie();Me(()=>{i?.onViewportChange(s.value)});let c=F(0);function l(e){let t=e.currentTarget,{shouldExpandOnScrollRef:n,contentWrapper:r}=a??{};if(n?.value&&r?.value){let e=Math.abs(c.value-t.scrollTop);if(e>0){let n=window.innerHeight-20,i=Number.parseFloat(r.value.style.minHeight),a=Number.parseFloat(r.value.style.height),o=Math.max(i,a);if(o<n){let i=o+e,a=Math.min(n,i),s=i-a;r.value.style.height=`${a}px`,r.value.style.bottom===`0px`&&(t.scrollTop=s>0?s:0,r.value.style.justifyContent=`flex-end`)}}}c.value=t.scrollTop}return(e,n)=>(N(),P(k,null,[L(b(A),j({ref:b(o),"data-reka-select-viewport":``,role:`presentation`},{...e.$attrs,...t},{style:{position:`relative`,flex:1,overflow:`hidden auto`},onScroll:l}),{default:B(()=>[z(e.$slots,`default`)]),_:3},16),L(b(A),{as:`style`,nonce:b(r)},{default:B(()=>n[0]||=[ge(` /* Hide scrollbars cross-browser and enable momentum scroll for touch devices */ [data-reka-select-viewport] { scrollbar-width:none; -ms-overflow-style: none; -webkit-overflow-scrolling: touch; } [data-reka-select-viewport]::-webkit-scrollbar { display: none; } `)]),_:1,__:[0]},8,[`nonce`])],64))}}),Xi=R({__name:`Select`,props:{open:{type:Boolean},defaultOpen:{type:Boolean},defaultValue:{},modelValue:{},nullableValue:{},by:{type:[String,Function]},dir:{},multiple:{type:Boolean},autocomplete:{},disabled:{type:Boolean},name:{},required:{type:Boolean}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=a(e,t);return(e,t)=>(N(),I(b(wi),j({"data-slot":`select`},b(n)),{default:B(t=>[z(e.$slots,`default`,Ze(ve(t)))]),_:3},16))}}),Zi=R({inheritAttrs:!1,__name:`SelectContent`,props:{forceMount:{type:Boolean},position:{default:`item-aligned`},bodyLock:{type:Boolean},memoDependencies:{},side:{},sideOffset:{},sideFlip:{type:Boolean},align:{default:`center`},alignOffset:{},alignFlip:{type:Boolean},avoidCollisions:{type:Boolean},collisionBoundary:{},collisionPadding:{},arrowPadding:{},hideShiftedArrow:{type:Boolean},sticky:{},hideWhenDetached:{type:Boolean},positionStrategy:{},updatePositionStrategy:{},disableUpdateOnLayoutShift:{type:Boolean},prioritizePosition:{type:Boolean},reference:{},dir:{},asChild:{type:Boolean},as:{},disableOutsidePointerEvents:{type:Boolean},class:{type:[Boolean,null,String,Object,Array]}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=ee(n,`class`),o=a(i,r);return(t,r)=>(N(),I(b(Ui),null,{default:B(()=>[L(b(Ii),j({"data-slot":`select-content`,"data-align-trigger":e.position===`item-aligned`},{...t.$attrs,...b(o)},{class:b(p)(`bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 min-w-36 rounded-lg shadow-md ring-1 duration-100 data-[side=inline-start]:slide-in-from-right-2 data-[side=inline-end]:slide-in-from-left-2 cn-menu-translucent relative z-50 max-h-(--reka-select-content-available-height) origin-(--reka-select-content-transform-origin) overflow-x-hidden overflow-y-auto data-[align-trigger=true]:animate-none`,e.position===`popper`&&`data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1`,n.class)}),{default:B(()=>[L(b(ta)),L(b(Yi),{"data-position":e.position,class:te(b(p)(`data-[position=popper]:h-(--reka-select-trigger-height) data-[position=popper]:w-full data-[position=popper]:min-w-(--reka-select-trigger-width)`))},{default:B(()=>[z(t.$slots,`default`)]),_:3},8,[`data-position`,`class`]),L(b(ea))]),_:3},16,[`data-align-trigger`,`class`])]),_:3}))}}),Qi={class:`pointer-events-none absolute right-2 flex size-4 items-center justify-center`},$i=R({__name:`SelectItem`,props:{value:{},disabled:{type:Boolean},textValue:{},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Bi),j({"data-slot":`select-item`},b(r),{class:b(p)(`focus:bg-accent focus:text-accent-foreground not-data-[variant=destructive]:focus:**:text-accent-foreground gap-1.5 rounded-md py-1 pr-8 pl-1.5 text-sm [&_svg:not([class*=size-])]:size-4 *:[span]:last:flex *:[span]:last:items-center *:[span]:last:gap-2 relative flex w-full cursor-default items-center outline-hidden select-none data-[disabled]:pointer-events-none data-[disabled]:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0`,t.class)}),{default:B(()=>[He(`span`,Qi,[L(b(Vi),null,{default:B(()=>[z(e.$slots,`indicator-icon`,{},()=>[L(b(ue),{icon:b(v),class:`pointer-events-none size-3.5`},null,8,[`icon`])])]),_:3})]),L(b(Hi),null,{default:B(()=>[z(e.$slots,`default`)]),_:3})]),_:3},16,[`class`]))}}),ea=R({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Gi),j({"data-slot":`select-scroll-down-button`},b(r),{class:b(p)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:B(()=>[z(e.$slots,`default`,{},()=>[L(b(ue),{icon:b(Le),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),ta=R({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ee(t,`class`),r=Ke(n);return(e,n)=>(N(),I(b(Ki),j({"data-slot":`select-scroll-up-button`},b(r),{class:b(p)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:B(()=>[z(e.$slots,`default`,{},()=>[L(b(ue),{icon:b(_),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),na=R({__name:`SelectTrigger`,props:{disabled:{type:Boolean},reference:{},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e,n=ee(t,`class`,`size`),r=Ke(n);return(n,i)=>(N(),I(b(qi),j({"data-slot":`select-trigger`,"data-size":e.size},b(r),{class:b(p)(`border-input data-placeholder:text-muted-foreground dark:bg-input/30 dark:hover:bg-input/50 focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 gap-1.5 rounded-lg border bg-transparent py-2 pr-2 pl-2.5 text-sm transition-colors select-none focus-visible:ring-3 aria-invalid:ring-3 data-[size=default]:h-8 data-[size=sm]:h-7 data-[size=sm]:rounded-[min(var(--radius-md),10px)] *:data-[slot=select-value]:gap-1.5 [&_svg:not([class*=size-])]:size-4 flex w-fit items-center justify-between whitespace-nowrap outline-none disabled:cursor-not-allowed disabled:opacity-50 *:data-[slot=select-value]:line-clamp-1 *:data-[slot=select-value]:flex *:data-[slot=select-value]:items-center [&_svg]:pointer-events-none [&_svg]:shrink-0`,t.class)}),{default:B(()=>[z(n.$slots,`default`),L(b(Li),{"as-child":``},{default:B(()=>[L(b(ue),{icon:b(Le),class:`text-muted-foreground size-4 pointer-events-none`},null,8,[`icon`])]),_:1})]),_:3},16,[`data-size`,`class`]))}}),ra=R({__name:`SelectValue`,props:{placeholder:{},asChild:{type:Boolean},as:{}},setup(e){let t=e;return(e,n)=>(N(),I(b(Ji),j({"data-slot":`select-value`},t),{default:B(()=>[z(e.$slots,`default`)]),_:3},16))}});function ia(e){return e+.5|0}var aa=(e,t,n)=>Math.max(Math.min(e,n),t);function oa(e){return aa(ia(e*2.55),0,255)}function sa(e){return aa(ia(e*255),0,255)}function ca(e){return aa(ia(e/2.55)/100,0,1)}function la(e){return aa(ia(e*100),0,100)}var ua={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,A:10,B:11,C:12,D:13,E:14,F:15,a:10,b:11,c:12,d:13,e:14,f:15},da=[...`0123456789ABCDEF`],fa=e=>da[e&15],pa=e=>da[(e&240)>>4]+da[e&15],ma=e=>(e&240)>>4==(e&15),ha=e=>ma(e.r)&&ma(e.g)&&ma(e.b)&&ma(e.a);function ga(e){var t=e.length,n;return e[0]===`#`&&(t===4||t===5?n={r:255&ua[e[1]]*17,g:255&ua[e[2]]*17,b:255&ua[e[3]]*17,a:t===5?ua[e[4]]*17:255}:(t===7||t===9)&&(n={r:ua[e[1]]<<4|ua[e[2]],g:ua[e[3]]<<4|ua[e[4]],b:ua[e[5]]<<4|ua[e[6]],a:t===9?ua[e[7]]<<4|ua[e[8]]:255})),n}var _a=(e,t)=>e<255?t(e):``;function va(e){var t=ha(e)?fa:pa;return e?`#`+t(e.r)+t(e.g)+t(e.b)+_a(e.a,t):void 0}var ya=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function ba(e,t,n){let r=t*Math.min(n,1-n),i=(t,i=(t+e/30)%12)=>n-r*Math.max(Math.min(i-3,9-i,1),-1);return[i(0),i(8),i(4)]}function xa(e,t,n){let r=(r,i=(r+e/60)%6)=>n-n*t*Math.max(Math.min(i,4-i,1),0);return[r(5),r(3),r(1)]}function Sa(e,t,n){let r=ba(e,1,.5),i;for(t+n>1&&(i=1/(t+n),t*=i,n*=i),i=0;i<3;i++)r[i]*=1-t-n,r[i]+=t;return r}function Ca(e,t,n,r,i){return e===i?(t-n)/r+(t<n?6:0):t===i?(n-e)/r+2:(e-t)/r+4}function wa(e){let t=e.r/255,n=e.g/255,r=e.b/255,i=Math.max(t,n,r),a=Math.min(t,n,r),o=(i+a)/2,s,c,l;return i!==a&&(l=i-a,c=o>.5?l/(2-i-a):l/(i+a),s=Ca(t,n,r,l,i),s=s*60+.5),[s|0,c||0,o]}function Ta(e,t,n,r){return(Array.isArray(t)?e(t[0],t[1],t[2]):e(t,n,r)).map(sa)}function Ea(e,t,n){return Ta(ba,e,t,n)}function Da(e,t,n){return Ta(Sa,e,t,n)}function Oa(e,t,n){return Ta(xa,e,t,n)}function ka(e){return(e%360+360)%360}function Aa(e){let t=ya.exec(e),n=255,r;if(!t)return;t[5]!==r&&(n=t[6]?oa(+t[5]):sa(+t[5]));let i=ka(+t[2]),a=t[3]/100,o=t[4]/100;return r=t[1]===`hwb`?Da(i,a,o):t[1]===`hsv`?Oa(i,a,o):Ea(i,a,o),{r:r[0],g:r[1],b:r[2],a:n}}function ja(e,t){var n=wa(e);n[0]=ka(n[0]+t),n=Ea(n),e.r=n[0],e.g=n[1],e.b=n[2]}function Ma(e){if(!e)return;let t=wa(e),n=t[0],r=la(t[1]),i=la(t[2]);return e.a<255?`hsla(${n}, ${r}%, ${i}%, ${ca(e.a)})`:`hsl(${n}, ${r}%, ${i}%)`}var Na={x:`dark`,Z:`light`,Y:`re`,X:`blu`,W:`gr`,V:`medium`,U:`slate`,A:`ee`,T:`ol`,S:`or`,B:`ra`,C:`lateg`,D:`ights`,R:`in`,Q:`turquois`,E:`hi`,P:`ro`,O:`al`,N:`le`,M:`de`,L:`yello`,F:`en`,K:`ch`,G:`arks`,H:`ea`,I:`ightg`,J:`wh`},Pa={OiceXe:`f0f8ff`,antiquewEte:`faebd7`,aqua:`ffff`,aquamarRe:`7fffd4`,azuY:`f0ffff`,beige:`f5f5dc`,bisque:`ffe4c4`,black:`0`,blanKedOmond:`ffebcd`,Xe:`ff`,XeviTet:`8a2be2`,bPwn:`a52a2a`,burlywood:`deb887`,caMtXe:`5f9ea0`,KartYuse:`7fff00`,KocTate:`d2691e`,cSO:`ff7f50`,cSnflowerXe:`6495ed`,cSnsilk:`fff8dc`,crimson:`dc143c`,cyan:`ffff`,xXe:`8b`,xcyan:`8b8b`,xgTMnPd:`b8860b`,xWay:`a9a9a9`,xgYF:`6400`,xgYy:`a9a9a9`,xkhaki:`bdb76b`,xmagFta:`8b008b`,xTivegYF:`556b2f`,xSange:`ff8c00`,xScEd:`9932cc`,xYd:`8b0000`,xsOmon:`e9967a`,xsHgYF:`8fbc8f`,xUXe:`483d8b`,xUWay:`2f4f4f`,xUgYy:`2f4f4f`,xQe:`ced1`,xviTet:`9400d3`,dAppRk:`ff1493`,dApskyXe:`bfff`,dimWay:`696969`,dimgYy:`696969`,dodgerXe:`1e90ff`,fiYbrick:`b22222`,flSOwEte:`fffaf0`,foYstWAn:`228b22`,fuKsia:`ff00ff`,gaRsbSo:`dcdcdc`,ghostwEte:`f8f8ff`,gTd:`ffd700`,gTMnPd:`daa520`,Way:`808080`,gYF:`8000`,gYFLw:`adff2f`,gYy:`808080`,honeyMw:`f0fff0`,hotpRk:`ff69b4`,RdianYd:`cd5c5c`,Rdigo:`4b0082`,ivSy:`fffff0`,khaki:`f0e68c`,lavFMr:`e6e6fa`,lavFMrXsh:`fff0f5`,lawngYF:`7cfc00`,NmoncEffon:`fffacd`,ZXe:`add8e6`,ZcSO:`f08080`,Zcyan:`e0ffff`,ZgTMnPdLw:`fafad2`,ZWay:`d3d3d3`,ZgYF:`90ee90`,ZgYy:`d3d3d3`,ZpRk:`ffb6c1`,ZsOmon:`ffa07a`,ZsHgYF:`20b2aa`,ZskyXe:`87cefa`,ZUWay:`778899`,ZUgYy:`778899`,ZstAlXe:`b0c4de`,ZLw:`ffffe0`,lime:`ff00`,limegYF:`32cd32`,lRF:`faf0e6`,magFta:`ff00ff`,maPon:`800000`,VaquamarRe:`66cdaa`,VXe:`cd`,VScEd:`ba55d3`,VpurpN:`9370db`,VsHgYF:`3cb371`,VUXe:`7b68ee`,VsprRggYF:`fa9a`,VQe:`48d1cc`,VviTetYd:`c71585`,midnightXe:`191970`,mRtcYam:`f5fffa`,mistyPse:`ffe4e1`,moccasR:`ffe4b5`,navajowEte:`ffdead`,navy:`80`,Tdlace:`fdf5e6`,Tive:`808000`,TivedBb:`6b8e23`,Sange:`ffa500`,SangeYd:`ff4500`,ScEd:`da70d6`,pOegTMnPd:`eee8aa`,pOegYF:`98fb98`,pOeQe:`afeeee`,pOeviTetYd:`db7093`,papayawEp:`ffefd5`,pHKpuff:`ffdab9`,peru:`cd853f`,pRk:`ffc0cb`,plum:`dda0dd`,powMrXe:`b0e0e6`,purpN:`800080`,YbeccapurpN:`663399`,Yd:`ff0000`,Psybrown:`bc8f8f`,PyOXe:`4169e1`,saddNbPwn:`8b4513`,sOmon:`fa8072`,sandybPwn:`f4a460`,sHgYF:`2e8b57`,sHshell:`fff5ee`,siFna:`a0522d`,silver:`c0c0c0`,skyXe:`87ceeb`,UXe:`6a5acd`,UWay:`708090`,UgYy:`708090`,snow:`fffafa`,sprRggYF:`ff7f`,stAlXe:`4682b4`,tan:`d2b48c`,teO:`8080`,tEstN:`d8bfd8`,tomato:`ff6347`,Qe:`40e0d0`,viTet:`ee82ee`,JHt:`f5deb3`,wEte:`ffffff`,wEtesmoke:`f5f5f5`,Lw:`ffff00`,LwgYF:`9acd32`};function Fa(){let e={},t=Object.keys(Pa),n=Object.keys(Na),r,i,a,o,s;for(r=0;r<t.length;r++){for(o=s=t[r],i=0;i<n.length;i++)a=n[i],s=s.replace(a,Na[a]);a=parseInt(Pa[o],16),e[s]=[a>>16&255,a>>8&255,a&255]}return e}var Ia;function La(e){Ia||(Ia=Fa(),Ia.transparent=[0,0,0,0]);let t=Ia[e.toLowerCase()];return t&&{r:t[0],g:t[1],b:t[2],a:t.length===4?t[3]:255}}var Ra=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;function za(e){let t=Ra.exec(e),n=255,r,i,a;if(t){if(t[7]!==r){let e=+t[7];n=t[8]?oa(e):aa(e*255,0,255)}return r=+t[1],i=+t[3],a=+t[5],r=255&(t[2]?oa(r):aa(r,0,255)),i=255&(t[4]?oa(i):aa(i,0,255)),a=255&(t[6]?oa(a):aa(a,0,255)),{r,g:i,b:a,a:n}}}function Ba(e){return e&&(e.a<255?`rgba(${e.r}, ${e.g}, ${e.b}, ${ca(e.a)})`:`rgb(${e.r}, ${e.g}, ${e.b})`)}var Va=e=>e<=.0031308?e*12.92:e**(1/2.4)*1.055-.055,Ha=e=>e<=.04045?e/12.92:((e+.055)/1.055)**2.4;function Ua(e,t,n){let r=Ha(ca(e.r)),i=Ha(ca(e.g)),a=Ha(ca(e.b));return{r:sa(Va(r+n*(Ha(ca(t.r))-r))),g:sa(Va(i+n*(Ha(ca(t.g))-i))),b:sa(Va(a+n*(Ha(ca(t.b))-a))),a:e.a+n*(t.a-e.a)}}function Wa(e,t,n){if(e){let r=wa(e);r[t]=Math.max(0,Math.min(r[t]+r[t]*n,t===0?360:1)),r=Ea(r),e.r=r[0],e.g=r[1],e.b=r[2]}}function Ga(e,t){return e&&Object.assign(t||{},e)}function Ka(e){var t={r:0,g:0,b:0,a:255};return Array.isArray(e)?e.length>=3&&(t={r:e[0],g:e[1],b:e[2],a:255},e.length>3&&(t.a=sa(e[3]))):(t=Ga(e,{r:0,g:0,b:0,a:1}),t.a=sa(t.a)),t}function qa(e){return e.charAt(0)===`r`?za(e):Aa(e)}var Ja=class e{constructor(t){if(t instanceof e)return t;let n=typeof t,r;n===`object`?r=Ka(t):n===`string`&&(r=ga(t)||La(t)||qa(t)),this._rgb=r,this._valid=!!r}get valid(){return this._valid}get rgb(){var e=Ga(this._rgb);return e&&(e.a=ca(e.a)),e}set rgb(e){this._rgb=Ka(e)}rgbString(){return this._valid?Ba(this._rgb):void 0}hexString(){return this._valid?va(this._rgb):void 0}hslString(){return this._valid?Ma(this._rgb):void 0}mix(e,t){if(e){let n=this.rgb,r=e.rgb,i,a=t===i?.5:t,o=2*a-1,s=n.a-r.a,c=((o*s===-1?o:(o+s)/(1+o*s))+1)/2;i=1-c,n.r=255&c*n.r+i*r.r+.5,n.g=255&c*n.g+i*r.g+.5,n.b=255&c*n.b+i*r.b+.5,n.a=a*n.a+(1-a)*r.a,this.rgb=n}return this}interpolate(e,t){return e&&(this._rgb=Ua(this._rgb,e._rgb,t)),this}clone(){return new e(this.rgb)}alpha(e){return this._rgb.a=sa(e),this}clearer(e){let t=this._rgb;return t.a*=1-e,this}greyscale(){let e=this._rgb;return e.r=e.g=e.b=ia(e.r*.3+e.g*.59+e.b*.11),this}opaquer(e){let t=this._rgb;return t.a*=1+e,this}negate(){let e=this._rgb;return e.r=255-e.r,e.g=255-e.g,e.b=255-e.b,this}lighten(e){return Wa(this._rgb,2,e),this}darken(e){return Wa(this._rgb,2,-e),this}saturate(e){return Wa(this._rgb,1,e),this}desaturate(e){return Wa(this._rgb,1,-e),this}rotate(e){return ja(this._rgb,e),this}};function Ya(){}var Xa=(()=>{let e=0;return()=>e++})();function U(e){return e==null}function W(e){if(Array.isArray&&Array.isArray(e))return!0;let t=Object.prototype.toString.call(e);return t.slice(0,7)===`[object`&&t.slice(-6)===`Array]`}function G(e){return e!==null&&Object.prototype.toString.call(e)===`[object Object]`}function K(e){return(typeof e==`number`||e instanceof Number)&&isFinite(+e)}function Za(e,t){return K(e)?e:t}function q(e,t){return e===void 0?t:e}var Qa=(e,t)=>typeof e==`string`&&e.endsWith(`%`)?parseFloat(e)/100*t:+e;function J(e,t,n){if(e&&typeof e.call==`function`)return e.apply(n,t)}function Y(e,t,n,r){let i,a,o;if(W(e)){if(a=e.length,r)for(i=a-1;i>=0;i--)t.call(n,e[i],i);else for(i=0;i<a;i++)t.call(n,e[i],i)}else if(G(e))for(o=Object.keys(e),a=o.length,i=0;i<a;i++)t.call(n,e[o[i]],o[i])}function $a(e,t){let n,r,i,a;if(!e||!t||e.length!==t.length)return!1;for(n=0,r=e.length;n<r;++n)if(i=e[n],a=t[n],i.datasetIndex!==a.datasetIndex||i.index!==a.index)return!1;return!0}function eo(e){if(W(e))return e.map(eo);if(G(e)){let t=Object.create(null),n=Object.keys(e),r=n.length,i=0;for(;i<r;++i)t[n[i]]=eo(e[n[i]]);return t}return e}function to(e){return[`__proto__`,`prototype`,`constructor`].indexOf(e)===-1}function no(e,t,n,r){if(!to(e))return;let i=t[e],a=n[e];G(i)&&G(a)?ro(i,a,r):t[e]=eo(a)}function ro(e,t,n){let r=W(t)?t:[t],i=r.length;if(!G(e))return e;n||={};let a=n.merger||no,o;for(let t=0;t<i;++t){if(o=r[t],!G(o))continue;let i=Object.keys(o);for(let t=0,r=i.length;t<r;++t)a(i[t],e,o,n)}return e}function io(e,t){return ro(e,t,{merger:ao})}function ao(e,t,n){if(!to(e))return;let r=t[e],i=n[e];G(r)&&G(i)?io(r,i):Object.prototype.hasOwnProperty.call(t,e)||(t[e]=eo(i))}var oo={"":e=>e,x:e=>e.x,y:e=>e.y};function so(e){let t=e.split(`.`),n=[],r=``;for(let e of t)r+=e,r.endsWith(`\\`)?r=r.slice(0,-1)+`.`:(n.push(r),r=``);return n}function co(e){let t=so(e);return e=>{for(let n of t){if(n===``)break;e&&=e[n]}return e}}function lo(e,t){return(oo[t]||(oo[t]=co(t)))(e)}function uo(e){return e.charAt(0).toUpperCase()+e.slice(1)}var fo=e=>e!==void 0,po=e=>typeof e==`function`,mo=(e,t)=>{if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0};function ho(e){return e.type===`mouseup`||e.type===`click`||e.type===`contextmenu`}var X=Math.PI,go=2*X;go+X;var _o=1/0,vo=X/180,yo=X/2,bo=X/4,xo=X*2/3,So=Math.log10,Co=Math.sign;function wo(e,t,n){return Math.abs(e-t)<n}function To(e){let t=Math.round(e);e=wo(e,t,e/1e3)?t:e;let n=10**Math.floor(So(e)),r=e/n;return(r<=1?1:r<=2?2:r<=5?5:10)*n}function Eo(e){let t=[],n=Math.sqrt(e),r;for(r=1;r<n;r++)e%r===0&&(t.push(r),t.push(e/r));return n===(n|0)&&t.push(n),t.sort((e,t)=>e-t).pop(),t}function Do(e){return typeof e==`symbol`||typeof e==`object`&&!!e&&!(Symbol.toPrimitive in e||`toString`in e||`valueOf`in e)}function Oo(e){return!Do(e)&&!isNaN(parseFloat(e))&&isFinite(e)}function ko(e,t){let n=Math.round(e);return n-t<=e&&n+t>=e}function Ao(e,t,n){let r,i,a;for(r=0,i=e.length;r<i;r++)a=e[r][n],isNaN(a)||(t.min=Math.min(t.min,a),t.max=Math.max(t.max,a))}function jo(e){return X/180*e}function Mo(e){return 180/X*e}function No(e){if(!K(e))return;let t=1,n=0;for(;Math.round(e*t)/t!==e;)t*=10,n++;return n}function Po(e,t){let n=t.x-e.x,r=t.y-e.y,i=Math.sqrt(n*n+r*r),a=Math.atan2(r,n);return a<-.5*X&&(a+=go),{angle:a,distance:i}}function Fo(e,t){return Math.sqrt((t.x-e.x)**2+(t.y-e.y)**2)}function Io(e){return(e%go+go)%go}function Lo(e,t,n,r){let i=Io(e),a=Io(t),o=Io(n),s=Io(a-i),c=Io(o-i),l=Io(i-a),u=Io(i-o);return i===a||i===o||r&&a===o||s>c&&l<u}function Ro(e,t,n){return Math.max(t,Math.min(n,e))}function zo(e){return Ro(e,-32768,32767)}function Bo(e,t,n,r=1e-6){return e>=Math.min(t,n)-r&&e<=Math.max(t,n)+r}function Vo(e,t,n){n||=(n=>e[n]<t);let r=e.length-1,i=0,a;for(;r-i>1;)a=i+r>>1,n(a)?i=a:r=a;return{lo:i,hi:r}}var Ho=(e,t,n,r)=>Vo(e,n,r?r=>{let i=e[r][t];return i<n||i===n&&e[r+1][t]===n}:r=>e[r][t]<n),Uo=(e,t,n)=>Vo(e,n,r=>e[r][t]>=n);function Wo(e,t,n){let r=0,i=e.length;for(;r<i&&e[r]<t;)r++;for(;i>r&&e[i-1]>n;)i--;return r>0||i<e.length?e.slice(r,i):e}var Go=[`push`,`pop`,`shift`,`splice`,`unshift`];function Ko(e,t){if(e._chartjs){e._chartjs.listeners.push(t);return}Object.defineProperty(e,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[t]}}),Go.forEach(t=>{let n=`_onData`+uo(t),r=e[t];Object.defineProperty(e,t,{configurable:!0,enumerable:!1,value(...t){let i=r.apply(this,t);return e._chartjs.listeners.forEach(e=>{typeof e[n]==`function`&&e[n](...t)}),i}})})}function qo(e,t){let n=e._chartjs;if(!n)return;let r=n.listeners,i=r.indexOf(t);i!==-1&&r.splice(i,1),!(r.length>0)&&(Go.forEach(t=>{delete e[t]}),delete e._chartjs)}function Jo(e){let t=new Set(e);return t.size===e.length?e:Array.from(t)}var Yo=function(){return typeof window>`u`?function(e){return e()}:window.requestAnimationFrame}();function Xo(e,t){let n=[],r=!1;return function(...i){n=i,r||(r=!0,Yo.call(window,()=>{r=!1,e.apply(t,n)}))}}function Zo(e,t){let n;return function(...r){return t?(clearTimeout(n),n=setTimeout(e,t,r)):e.apply(this,r),t}}var Qo=e=>e===`start`?`left`:e===`end`?`right`:`center`,$o=(e,t,n)=>e===`start`?t:e===`end`?n:(t+n)/2,es=(e,t,n,r)=>e===(r?`left`:`right`)?n:e===`center`?(t+n)/2:t,ts=e=>e===0||e===1,ns=(e,t,n)=>-(2**(10*--e)*Math.sin((e-t)*go/n)),rs=(e,t,n)=>2**(-10*e)*Math.sin((e-t)*go/n)+1,is={linear:e=>e,easeInQuad:e=>e*e,easeOutQuad:e=>-e*(e-2),easeInOutQuad:e=>(e/=.5)<1?.5*e*e:-.5*(--e*(e-2)-1),easeInCubic:e=>e*e*e,easeOutCubic:e=>--e*e*e+1,easeInOutCubic:e=>(e/=.5)<1?.5*e*e*e:.5*((e-=2)*e*e+2),easeInQuart:e=>e*e*e*e,easeOutQuart:e=>-(--e*e*e*e-1),easeInOutQuart:e=>(e/=.5)<1?.5*e*e*e*e:-.5*((e-=2)*e*e*e-2),easeInQuint:e=>e*e*e*e*e,easeOutQuint:e=>--e*e*e*e*e+1,easeInOutQuint:e=>(e/=.5)<1?.5*e*e*e*e*e:.5*((e-=2)*e*e*e*e+2),easeInSine:e=>-Math.cos(e*yo)+1,easeOutSine:e=>Math.sin(e*yo),easeInOutSine:e=>-.5*(Math.cos(X*e)-1),easeInExpo:e=>e===0?0:2**(10*(e-1)),easeOutExpo:e=>e===1?1:-(2**(-10*e))+1,easeInOutExpo:e=>ts(e)?e:e<.5?.5*2**(10*(e*2-1)):.5*(-(2**(-10*(e*2-1)))+2),easeInCirc:e=>e>=1?e:-(Math.sqrt(1-e*e)-1),easeOutCirc:e=>Math.sqrt(1- --e*e),easeInOutCirc:e=>(e/=.5)<1?-.5*(Math.sqrt(1-e*e)-1):.5*(Math.sqrt(1-(e-=2)*e)+1),easeInElastic:e=>ts(e)?e:ns(e,.075,.3),easeOutElastic:e=>ts(e)?e:rs(e,.075,.3),easeInOutElastic(e){let t=.1125,n=.45;return ts(e)?e:e<.5?.5*ns(e*2,t,n):.5+.5*rs(e*2-1,t,n)},easeInBack(e){return e*e*(2.70158*e-1.70158)},easeOutBack(e){return--e*e*(2.70158*e+1.70158)+1},easeInOutBack(e){let t=1.70158;return(e/=.5)<1?.5*(e*e*(((t*=1.525)+1)*e-t)):.5*((e-=2)*e*(((t*=1.525)+1)*e+t)+2)},easeInBounce:e=>1-is.easeOutBounce(1-e),easeOutBounce(e){let t=7.5625,n=2.75;return e<1/n?t*e*e:e<2/n?t*(e-=1.5/n)*e+.75:e<2.5/n?t*(e-=2.25/n)*e+.9375:t*(e-=2.625/n)*e+.984375},easeInOutBounce:e=>e<.5?is.easeInBounce(e*2)*.5:is.easeOutBounce(e*2-1)*.5+.5};function as(e){if(e&&typeof e==`object`){let t=e.toString();return t===`[object CanvasPattern]`||t===`[object CanvasGradient]`}return!1}function os(e){return as(e)?e:new Ja(e)}function ss(e){return as(e)?e:new Ja(e).saturate(.5).darken(.1).hexString()}var cs=[`x`,`y`,`borderWidth`,`radius`,`tension`],ls=[`color`,`borderColor`,`backgroundColor`];function us(e){e.set(`animation`,{delay:void 0,duration:1e3,easing:`easeOutQuart`,fn:void 0,from:void 0,loop:void 0,to:void 0,type:void 0}),e.describe(`animation`,{_fallback:!1,_indexable:!1,_scriptable:e=>e!==`onProgress`&&e!==`onComplete`&&e!==`fn`}),e.set(`animations`,{colors:{type:`color`,properties:ls},numbers:{type:`number`,properties:cs}}),e.describe(`animations`,{_fallback:`animation`}),e.set(`transitions`,{active:{animation:{duration:400}},resize:{animation:{duration:0}},show:{animations:{colors:{from:`transparent`},visible:{type:`boolean`,duration:0}}},hide:{animations:{colors:{to:`transparent`},visible:{type:`boolean`,easing:`linear`,fn:e=>e|0}}}})}function ds(e){e.set(`layout`,{autoPadding:!0,padding:{top:0,right:0,bottom:0,left:0}})}var fs=new Map;function ps(e,t){t||={};let n=e+JSON.stringify(t),r=fs.get(n);return r||(r=new Intl.NumberFormat(e,t),fs.set(n,r)),r}function ms(e,t,n){return ps(t,n).format(e)}var hs={values(e){return W(e)?e:``+e},numeric(e,t,n){if(e===0)return`0`;let r=this.chart.options.locale,i,a=e;if(n.length>1){let t=Math.max(Math.abs(n[0].value),Math.abs(n[n.length-1].value));(t<1e-4||t>0x38d7ea4c68000)&&(i=`scientific`),a=gs(e,n)}let o=So(Math.abs(a)),s=isNaN(o)?1:Math.max(Math.min(-1*Math.floor(o),20),0),c={notation:i,minimumFractionDigits:s,maximumFractionDigits:s};return Object.assign(c,this.options.ticks.format),ms(e,r,c)},logarithmic(e,t,n){if(e===0)return`0`;let r=n[t].significand||e/10**Math.floor(So(e));return[1,2,3,5,10,15].includes(r)||t>.8*n.length?hs.numeric.call(this,e,t,n):``}};function gs(e,t){let n=t.length>3?t[2].value-t[1].value:t[1].value-t[0].value;return Math.abs(n)>=1&&e!==Math.floor(e)&&(n=e-Math.floor(e)),n}var _s={formatters:hs};function vs(e){e.set(`scale`,{display:!0,offset:!1,reverse:!1,beginAtZero:!1,bounds:`ticks`,clip:!0,grace:0,grid:{display:!0,lineWidth:1,drawOnChartArea:!0,drawTicks:!0,tickLength:8,tickWidth:(e,t)=>t.lineWidth,tickColor:(e,t)=>t.color,offset:!1},border:{display:!0,dash:[],dashOffset:0,width:1},title:{display:!1,text:``,padding:{top:4,bottom:4}},ticks:{minRotation:0,maxRotation:50,mirror:!1,textStrokeWidth:0,textStrokeColor:``,padding:3,display:!0,autoSkip:!0,autoSkipPadding:3,labelOffset:0,callback:_s.formatters.values,minor:{},major:{},align:`center`,crossAlign:`near`,showLabelBackdrop:!1,backdropColor:`rgba(255, 255, 255, 0.75)`,backdropPadding:2}}),e.route(`scale.ticks`,`color`,``,`color`),e.route(`scale.grid`,`color`,``,`borderColor`),e.route(`scale.border`,`color`,``,`borderColor`),e.route(`scale.title`,`color`,``,`color`),e.describe(`scale`,{_fallback:!1,_scriptable:e=>!e.startsWith(`before`)&&!e.startsWith(`after`)&&e!==`callback`&&e!==`parser`,_indexable:e=>e!==`borderDash`&&e!==`tickBorderDash`&&e!==`dash`}),e.describe(`scales`,{_fallback:`scale`}),e.describe(`scale.ticks`,{_scriptable:e=>e!==`backdropPadding`&&e!==`callback`,_indexable:e=>e!==`backdropPadding`})}var ys=Object.create(null),bs=Object.create(null);function xs(e,t){if(!t)return e;let n=t.split(`.`);for(let t=0,r=n.length;t<r;++t){let r=n[t];e=e[r]||(e[r]=Object.create(null))}return e}function Ss(e,t,n){return typeof t==`string`?ro(xs(e,t),n):ro(xs(e,``),t)}var Z=new class{constructor(e,t){this.animation=void 0,this.backgroundColor=`rgba(0,0,0,0.1)`,this.borderColor=`rgba(0,0,0,0.1)`,this.color=`#666`,this.datasets={},this.devicePixelRatio=e=>e.chart.platform.getDevicePixelRatio(),this.elements={},this.events=[`mousemove`,`mouseout`,`click`,`touchstart`,`touchmove`],this.font={family:`'Helvetica Neue', 'Helvetica', 'Arial', sans-serif`,size:12,style:`normal`,lineHeight:1.2,weight:null},this.hover={},this.hoverBackgroundColor=(e,t)=>ss(t.backgroundColor),this.hoverBorderColor=(e,t)=>ss(t.borderColor),this.hoverColor=(e,t)=>ss(t.color),this.indexAxis=`x`,this.interaction={mode:`nearest`,intersect:!0,includeInvisible:!1},this.maintainAspectRatio=!0,this.onHover=null,this.onClick=null,this.parsing=!0,this.plugins={},this.responsive=!0,this.scale=void 0,this.scales={},this.showLine=!0,this.drawActiveElementsOnTop=!0,this.describe(e),this.apply(t)}set(e,t){return Ss(this,e,t)}get(e){return xs(this,e)}describe(e,t){return Ss(bs,e,t)}override(e,t){return Ss(ys,e,t)}route(e,t,n,r){let i=xs(this,e),a=xs(this,n),o=`_`+t;Object.defineProperties(i,{[o]:{value:i[t],writable:!0},[t]:{enumerable:!0,get(){let e=this[o],t=a[r];return G(e)?Object.assign({},t,e):q(e,t)},set(e){this[o]=e}}})}apply(e){e.forEach(e=>e(this))}}({_scriptable:e=>!e.startsWith(`on`),_indexable:e=>e!==`events`,hover:{_fallback:`interaction`},interaction:{_scriptable:!1,_indexable:!1}},[us,ds,vs]);function Cs(e){return!e||U(e.size)||U(e.family)?null:(e.style?e.style+` `:``)+(e.weight?e.weight+` `:``)+e.size+`px `+e.family}function ws(e,t,n,r,i){let a=t[i];return a||(a=t[i]=e.measureText(i).width,n.push(i)),a>r&&(r=a),r}function Ts(e,t,n,r){r||={};let i=r.data=r.data||{},a=r.garbageCollect=r.garbageCollect||[];r.font!==t&&(i=r.data={},a=r.garbageCollect=[],r.font=t),e.save(),e.font=t;let o=0,s=n.length,c,l,u,d,f;for(c=0;c<s;c++)if(d=n[c],d!=null&&!W(d))o=ws(e,i,a,o,d);else if(W(d))for(l=0,u=d.length;l<u;l++)f=d[l],f!=null&&!W(f)&&(o=ws(e,i,a,o,f));e.restore();let p=a.length/2;if(p>n.length){for(c=0;c<p;c++)delete i[a[c]];a.splice(0,p)}return o}function Es(e,t,n){let r=e.currentDevicePixelRatio,i=n===0?0:Math.max(n/2,.5);return Math.round((t-i)*r)/r+i}function Ds(e,t){!t&&!e||(t||=e.getContext(`2d`),t.save(),t.resetTransform(),t.clearRect(0,0,e.width,e.height),t.restore())}function Os(e,t,n,r){ks(e,t,n,r,null)}function ks(e,t,n,r,i){let a,o,s,c,l,u,d,f,p=t.pointStyle,m=t.rotation,h=t.radius,g=(m||0)*vo;if(p&&typeof p==`object`&&(a=p.toString(),a===`[object HTMLImageElement]`||a===`[object HTMLCanvasElement]`)){e.save(),e.translate(n,r),e.rotate(g),e.drawImage(p,-p.width/2,-p.height/2,p.width,p.height),e.restore();return}if(!(isNaN(h)||h<=0)){switch(e.beginPath(),p){default:i?e.ellipse(n,r,i/2,h,0,0,go):e.arc(n,r,h,0,go),e.closePath();break;case`triangle`:u=i?i/2:h,e.moveTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=xo,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=xo,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),e.closePath();break;case`rectRounded`:l=h*.516,c=h-l,o=Math.cos(g+bo)*c,d=Math.cos(g+bo)*(i?i/2-l:c),s=Math.sin(g+bo)*c,f=Math.sin(g+bo)*(i?i/2-l:c),e.arc(n-d,r-s,l,g-X,g-yo),e.arc(n+f,r-o,l,g-yo,g),e.arc(n+d,r+s,l,g,g+yo),e.arc(n-f,r+o,l,g+yo,g+X),e.closePath();break;case`rect`:if(!m){c=Math.SQRT1_2*h,u=i?i/2:c,e.rect(n-u,r-c,2*u,2*c);break}g+=bo;case`rectRot`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+f,r-o),e.lineTo(n+d,r+s),e.lineTo(n-f,r+o),e.closePath();break;case`crossRot`:g+=bo;case`cross`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o);break;case`star`:d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o),g+=bo,d=Math.cos(g)*(i?i/2:h),o=Math.cos(g)*h,s=Math.sin(g)*h,f=Math.sin(g)*(i?i/2:h),e.moveTo(n-d,r-s),e.lineTo(n+d,r+s),e.moveTo(n+f,r-o),e.lineTo(n-f,r+o);break;case`line`:o=i?i/2:Math.cos(g)*h,s=Math.sin(g)*h,e.moveTo(n-o,r-s),e.lineTo(n+o,r+s);break;case`dash`:e.moveTo(n,r),e.lineTo(n+Math.cos(g)*(i?i/2:h),r+Math.sin(g)*h);break;case!1:e.closePath()}e.fill(),t.borderWidth>0&&e.stroke()}}function As(e,t,n){return n||=.5,!t||e&&e.x>t.left-n&&e.x<t.right+n&&e.y>t.top-n&&e.y<t.bottom+n}function js(e,t){e.save(),e.beginPath(),e.rect(t.left,t.top,t.right-t.left,t.bottom-t.top),e.clip()}function Ms(e){e.restore()}function Ns(e,t){t.translation&&e.translate(t.translation[0],t.translation[1]),U(t.rotation)||e.rotate(t.rotation),t.color&&(e.fillStyle=t.color),t.textAlign&&(e.textAlign=t.textAlign),t.textBaseline&&(e.textBaseline=t.textBaseline)}function Ps(e,t,n,r,i){if(i.strikethrough||i.underline){let a=e.measureText(r),o=t-a.actualBoundingBoxLeft,s=t+a.actualBoundingBoxRight,c=n-a.actualBoundingBoxAscent,l=n+a.actualBoundingBoxDescent,u=i.strikethrough?(c+l)/2:l;e.strokeStyle=e.fillStyle,e.beginPath(),e.lineWidth=i.decorationWidth||2,e.moveTo(o,u),e.lineTo(s,u),e.stroke()}}function Fs(e,t){let n=e.fillStyle;e.fillStyle=t.color,e.fillRect(t.left,t.top,t.width,t.height),e.fillStyle=n}function Is(e,t,n,r,i,a={}){let o=W(t)?t:[t],s=a.strokeWidth>0&&a.strokeColor!==``,c,l;for(e.save(),e.font=i.string,Ns(e,a),c=0;c<o.length;++c)l=o[c],a.backdrop&&Fs(e,a.backdrop),s&&(a.strokeColor&&(e.strokeStyle=a.strokeColor),U(a.strokeWidth)||(e.lineWidth=a.strokeWidth),e.strokeText(l,n,r,a.maxWidth)),e.fillText(l,n,r,a.maxWidth),Ps(e,n,r,l,a),r+=Number(i.lineHeight);e.restore()}function Ls(e,t){let{x:n,y:r,w:i,h:a,radius:o}=t;e.arc(n+o.topLeft,r+o.topLeft,o.topLeft,1.5*X,X,!0),e.lineTo(n,r+a-o.bottomLeft),e.arc(n+o.bottomLeft,r+a-o.bottomLeft,o.bottomLeft,X,yo,!0),e.lineTo(n+i-o.bottomRight,r+a),e.arc(n+i-o.bottomRight,r+a-o.bottomRight,o.bottomRight,yo,0,!0),e.lineTo(n+i,r+o.topRight),e.arc(n+i-o.topRight,r+o.topRight,o.topRight,0,-yo,!0),e.lineTo(n+o.topLeft,r)}var Rs=/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/,zs=/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;function Bs(e,t){let n=(``+e).match(Rs);if(!n||n[1]===`normal`)return t*1.2;switch(e=+n[2],n[3]){case`px`:return e;case`%`:e/=100}return t*e}var Vs=e=>+e||0;function Hs(e,t){let n={},r=G(t),i=r?Object.keys(t):t,a=G(e)?r?n=>q(e[n],e[t[n]]):t=>e[t]:()=>e;for(let e of i)n[e]=Vs(a(e));return n}function Us(e){return Hs(e,{top:`y`,right:`x`,bottom:`y`,left:`x`})}function Ws(e){return Hs(e,[`topLeft`,`topRight`,`bottomLeft`,`bottomRight`])}function Q(e){let t=Us(e);return t.width=t.left+t.right,t.height=t.top+t.bottom,t}function $(e,t){e||={},t||=Z.font;let n=q(e.size,t.size);typeof n==`string`&&(n=parseInt(n,10));let r=q(e.style,t.style);r&&!(``+r).match(zs)&&(console.warn(`Invalid font style specified: "`+r+`"`),r=void 0);let i={family:q(e.family,t.family),lineHeight:Bs(q(e.lineHeight,t.lineHeight),n),size:n,style:r,weight:q(e.weight,t.weight),string:``};return i.string=Cs(i),i}function Gs(e,t,n,r){let i=!0,a,o,s;for(a=0,o=e.length;a<o;++a)if(s=e[a],s!==void 0&&(t!==void 0&&typeof s==`function`&&(s=s(t),i=!1),n!==void 0&&W(s)&&(s=s[n%s.length],i=!1),s!==void 0))return r&&!i&&(r.cacheable=!1),s}function Ks(e,t,n){let{min:r,max:i}=e,a=Qa(t,(i-r)/2),o=(e,t)=>n&&e===0?0:e+t;return{min:o(r,-Math.abs(a)),max:o(i,a)}}function qs(e,t){return Object.assign(Object.create(e),t)}function Js(e,t=[``],n,r,i=()=>e[0]){let a=n||e;return r===void 0&&(r=uc(`_fallback`,e)),new Proxy({[Symbol.toStringTag]:`Object`,_cacheable:!0,_scopes:e,_rootScopes:a,_fallback:r,_getTarget:i,override:n=>Js([n,...e],t,a,r)},{deleteProperty(t,n){return delete t[n],delete t._keys,delete e[0][n],!0},get(n,r){return $s(n,r,()=>lc(r,t,e,n))},getOwnPropertyDescriptor(e,t){return Reflect.getOwnPropertyDescriptor(e._scopes[0],t)},getPrototypeOf(){return Reflect.getPrototypeOf(e[0])},has(e,t){return dc(e).includes(t)},ownKeys(e){return dc(e)},set(e,t,n){let r=e._storage||=i();return e[t]=r[t]=n,delete e._keys,!0}})}function Ys(e,t,n,r){let i={_cacheable:!1,_proxy:e,_context:t,_subProxy:n,_stack:new Set,_descriptors:Xs(e,r),setContext:t=>Ys(e,t,n,r),override:i=>Ys(e.override(i),t,n,r)};return new Proxy(i,{deleteProperty(t,n){return delete t[n],delete e[n],!0},get(e,t,n){return $s(e,t,()=>ec(e,t,n))},getOwnPropertyDescriptor(t,n){return t._descriptors.allKeys?Reflect.has(e,n)?{enumerable:!0,configurable:!0}:void 0:Reflect.getOwnPropertyDescriptor(e,n)},getPrototypeOf(){return Reflect.getPrototypeOf(e)},has(t,n){return Reflect.has(e,n)},ownKeys(){return Reflect.ownKeys(e)},set(t,n,r){return e[n]=r,delete t[n],!0}})}function Xs(e,t={scriptable:!0,indexable:!0}){let{_scriptable:n=t.scriptable,_indexable:r=t.indexable,_allKeys:i=t.allKeys}=e;return{allKeys:i,scriptable:n,indexable:r,isScriptable:po(n)?n:()=>n,isIndexable:po(r)?r:()=>r}}var Zs=(e,t)=>e?e+uo(t):t,Qs=(e,t)=>G(t)&&e!==`adapters`&&(Object.getPrototypeOf(t)===null||t.constructor===Object);function $s(e,t,n){if(Object.prototype.hasOwnProperty.call(e,t)||t===`constructor`)return e[t];let r=n();return e[t]=r,r}function ec(e,t,n){let{_proxy:r,_context:i,_subProxy:a,_descriptors:o}=e,s=r[t];return po(s)&&o.isScriptable(t)&&(s=tc(t,s,e,n)),W(s)&&s.length&&(s=nc(t,s,e,o.isIndexable)),Qs(t,s)&&(s=Ys(s,i,a&&a[t],o)),s}function tc(e,t,n,r){let{_proxy:i,_context:a,_subProxy:o,_stack:s}=n;if(s.has(e))throw Error(`Recursion detected: `+Array.from(s).join(`->`)+`->`+e);s.add(e);let c=t(a,o||r);return s.delete(e),Qs(e,c)&&(c=oc(i._scopes,i,e,c)),c}function nc(e,t,n,r){let{_proxy:i,_context:a,_subProxy:o,_descriptors:s}=n;if(a.index!==void 0&&r(e))return t[a.index%t.length];if(G(t[0])){let n=t,r=i._scopes.filter(e=>e!==n);t=[];for(let c of n){let n=oc(r,i,e,c);t.push(Ys(n,a,o&&o[e],s))}}return t}function rc(e,t,n){return po(e)?e(t,n):e}var ic=(e,t)=>e===!0?t:typeof e==`string`?lo(t,e):void 0;function ac(e,t,n,r,i){for(let a of t){let t=ic(n,a);if(t){e.add(t);let a=rc(t._fallback,n,i);if(a!==void 0&&a!==n&&a!==r)return a}else if(t===!1&&r!==void 0&&n!==r)return null}return!1}function oc(e,t,n,r){let i=t._rootScopes,a=rc(t._fallback,n,r),o=[...e,...i],s=new Set;s.add(r);let c=sc(s,o,n,a||n,r);return c===null||a!==void 0&&a!==n&&(c=sc(s,o,a,c,r),c===null)?!1:Js(Array.from(s),[``],i,a,()=>cc(t,n,r))}function sc(e,t,n,r,i){for(;n;)n=ac(e,t,n,r,i);return n}function cc(e,t,n){let r=e._getTarget();t in r||(r[t]={});let i=r[t];return W(i)&&G(n)?n:i||{}}function lc(e,t,n,r){let i;for(let a of t)if(i=uc(Zs(a,e),n),i!==void 0)return Qs(e,i)?oc(n,r,e,i):i}function uc(e,t){for(let n of t){if(!n)continue;let t=n[e];if(t!==void 0)return t}}function dc(e){let t=e._keys;return t||=e._keys=fc(e._scopes),t}function fc(e){let t=new Set;for(let n of e)for(let e of Object.keys(n).filter(e=>!e.startsWith(`_`)))t.add(e);return Array.from(t)}function pc(){return typeof window<`u`&&typeof document<`u`}function mc(e){let t=e.parentNode;return t&&t.toString()===`[object ShadowRoot]`&&(t=t.host),t}function hc(e,t,n){let r;return typeof e==`string`?(r=parseInt(e,10),e.indexOf(`%`)!==-1&&(r=r/100*t.parentNode[n])):r=e,r}var gc=e=>e.ownerDocument.defaultView.getComputedStyle(e,null);function _c(e,t){return gc(e).getPropertyValue(t)}var vc=[`top`,`right`,`bottom`,`left`];function yc(e,t,n){let r={};n=n?`-`+n:``;for(let i=0;i<4;i++){let a=vc[i];r[a]=parseFloat(e[t+`-`+a+n])||0}return r.width=r.left+r.right,r.height=r.top+r.bottom,r}var bc=(e,t,n)=>(e>0||t>0)&&(!n||!n.shadowRoot);function xc(e,t){let n=e.touches,r=n&&n.length?n[0]:e,{offsetX:i,offsetY:a}=r,o=!1,s,c;if(bc(i,a,e.target))s=i,c=a;else{let e=t.getBoundingClientRect();s=r.clientX-e.left,c=r.clientY-e.top,o=!0}return{x:s,y:c,box:o}}function Sc(e,t){if(`native`in e)return e;let{canvas:n,currentDevicePixelRatio:r}=t,i=gc(n),a=i.boxSizing===`border-box`,o=yc(i,`padding`),s=yc(i,`border`,`width`),{x:c,y:l,box:u}=xc(e,n),d=o.left+(u&&s.left),f=o.top+(u&&s.top),{width:p,height:m}=t;return a&&(p-=o.width+s.width,m-=o.height+s.height),{x:Math.round((c-d)/p*n.width/r),y:Math.round((l-f)/m*n.height/r)}}function Cc(e,t,n){let r,i;if(t===void 0||n===void 0){let a=e&&mc(e);if(!a)t=e.clientWidth,n=e.clientHeight;else{let e=a.getBoundingClientRect(),o=gc(a),s=yc(o,`border`,`width`),c=yc(o,`padding`);t=e.width-c.width-s.width,n=e.height-c.height-s.height,r=hc(o.maxWidth,a,`clientWidth`),i=hc(o.maxHeight,a,`clientHeight`)}}return{width:t,height:n,maxWidth:r||_o,maxHeight:i||_o}}var wc=e=>Math.round(e*10)/10;function Tc(e,t,n,r){let i=gc(e),a=yc(i,`margin`),o=hc(i.maxWidth,e,`clientWidth`)||_o,s=hc(i.maxHeight,e,`clientHeight`)||_o,c=Cc(e,t,n),{width:l,height:u}=c;if(i.boxSizing===`content-box`){let e=yc(i,`border`,`width`),t=yc(i,`padding`);l-=t.width+e.width,u-=t.height+e.height}return l=Math.max(0,l-a.width),u=Math.max(0,r?l/r:u-a.height),l=wc(Math.min(l,o,c.maxWidth)),u=wc(Math.min(u,s,c.maxHeight)),l&&!u&&(u=wc(l/2)),(t!==void 0||n!==void 0)&&r&&c.height&&u>c.height&&(u=c.height,l=wc(Math.floor(u*r))),{width:l,height:u}}function Ec(e,t,n){let r=t||1,i=wc(e.height*r),a=wc(e.width*r);e.height=wc(e.height),e.width=wc(e.width);let o=e.canvas;return o.style&&(n||!o.style.height&&!o.style.width)&&(o.style.height=`${e.height}px`,o.style.width=`${e.width}px`),e.currentDevicePixelRatio!==r||o.height!==i||o.width!==a?(e.currentDevicePixelRatio=r,o.height=i,o.width=a,e.ctx.setTransform(r,0,0,r,0,0),!0):!1}var Dc=function(){let e=!1;try{let t={get passive(){return e=!0,!1}};pc()&&(window.addEventListener(`test`,null,t),window.removeEventListener(`test`,null,t))}catch{}return e}();function Oc(e,t){let n=_c(e,t),r=n&&n.match(/^(\d+)(\.\d+)?px$/);return r?+r[1]:void 0}var kc=function(e,t){return{x(n){return e+e+t-n},setWidth(e){t=e},textAlign(e){return e===`center`?e:e===`right`?`left`:`right`},xPlus(e,t){return e-t},leftForLtr(e,t){return e-t}}},Ac=function(){return{x(e){return e},setWidth(e){},textAlign(e){return e},xPlus(e,t){return e+t},leftForLtr(e,t){return e}}};function jc(e,t,n){return e?kc(t,n):Ac()}function Mc(e,t){let n,r;(t===`ltr`||t===`rtl`)&&(n=e.canvas.style,r=[n.getPropertyValue(`direction`),n.getPropertyPriority(`direction`)],n.setProperty(`direction`,t,`important`),e.prevTextDirection=r)}function Nc(e,t){t!==void 0&&(delete e.prevTextDirection,e.canvas.style.setProperty(`direction`,t[0],t[1]))}function Pc(e,t,n){return e.options.clip?e[n]:t[n]}function Fc(e,t){let{xScale:n,yScale:r}=e;return n&&r?{left:Pc(n,t,`left`),right:Pc(n,t,`right`),top:Pc(r,t,`top`),bottom:Pc(r,t,`bottom`)}:t}function Ic(e,t){let n=t._clip;if(n.disabled)return!1;let r=Fc(t,e.chartArea);return{left:n.left===!1?0:r.left-(n.left===!0?0:n.left),right:n.right===!1?e.width:r.right+(n.right===!0?0:n.right),top:n.top===!1?0:r.top-(n.top===!0?0:n.top),bottom:n.bottom===!1?e.height:r.bottom+(n.bottom===!0?0:n.bottom)}}var Lc=new class{constructor(){this._request=null,this._charts=new Map,this._running=!1,this._lastDate=void 0}_notify(e,t,n,r){let i=t.listeners[r],a=t.duration;i.forEach(r=>r({chart:e,initial:t.initial,numSteps:a,currentStep:Math.min(n-t.start,a)}))}_refresh(){this._request||=(this._running=!0,Yo.call(window,()=>{this._update(),this._request=null,this._running&&this._refresh()}))}_update(e=Date.now()){let t=0;this._charts.forEach((n,r)=>{if(!n.running||!n.items.length)return;let i=n.items,a=i.length-1,o=!1,s;for(;a>=0;--a)s=i[a],s._active?(s._total>n.duration&&(n.duration=s._total),s.tick(e),o=!0):(i[a]=i[i.length-1],i.pop());o&&(r.draw(),this._notify(r,n,e,`progress`)),i.length||(n.running=!1,this._notify(r,n,e,`complete`),n.initial=!1),t+=i.length}),this._lastDate=e,t===0&&(this._running=!1)}_getAnims(e){let t=this._charts,n=t.get(e);return n||(n={running:!1,initial:!0,items:[],listeners:{complete:[],progress:[]}},t.set(e,n)),n}listen(e,t,n){this._getAnims(e).listeners[t].push(n)}add(e,t){!t||!t.length||this._getAnims(e).items.push(...t)}has(e){return this._getAnims(e).items.length>0}start(e){let t=this._charts.get(e);t&&(t.running=!0,t.start=Date.now(),t.duration=t.items.reduce((e,t)=>Math.max(e,t._duration),0),this._refresh())}running(e){if(!this._running)return!1;let t=this._charts.get(e);return!(!t||!t.running||!t.items.length)}stop(e){let t=this._charts.get(e);if(!t||!t.items.length)return;let n=t.items,r=n.length-1;for(;r>=0;--r)n[r].cancel();t.items=[],this._notify(e,t,Date.now(),`complete`)}remove(e){return this._charts.delete(e)}},Rc=`transparent`,zc={boolean(e,t,n){return n>.5?t:e},color(e,t,n){let r=os(e||Rc),i=r.valid&&os(t||Rc);return i&&i.valid?i.mix(r,n).hexString():t},number(e,t,n){return e+(t-e)*n}},Bc=class{constructor(e,t,n,r){let i=t[n];r=Gs([e.to,r,i,e.from]);let a=Gs([e.from,i,r]);this._active=!0,this._fn=e.fn||zc[e.type||typeof a],this._easing=is[e.easing]||is.linear,this._start=Math.floor(Date.now()+(e.delay||0)),this._duration=this._total=Math.floor(e.duration),this._loop=!!e.loop,this._target=t,this._prop=n,this._from=a,this._to=r,this._promises=void 0}active(){return this._active}update(e,t,n){if(this._active){this._notify(!1);let r=this._target[this._prop],i=n-this._start,a=this._duration-i;this._start=n,this._duration=Math.floor(Math.max(a,e.duration)),this._total+=i,this._loop=!!e.loop,this._to=Gs([e.to,t,r,e.from]),this._from=Gs([e.from,r,t])}}cancel(){this._active&&(this.tick(Date.now()),this._active=!1,this._notify(!1))}tick(e){let t=e-this._start,n=this._duration,r=this._prop,i=this._from,a=this._loop,o=this._to,s;if(this._active=i!==o&&(a||t<n),!this._active){this._target[r]=o,this._notify(!0);return}if(t<0){this._target[r]=i;return}s=t/n%2,s=a&&s>1?2-s:s,s=this._easing(Math.min(1,Math.max(0,s))),this._target[r]=this._fn(i,o,s)}wait(){let e=this._promises||=[];return new Promise((t,n)=>{e.push({res:t,rej:n})})}_notify(e){let t=e?`res`:`rej`,n=this._promises||[];for(let e=0;e<n.length;e++)n[e][t]()}},Vc=class{constructor(e,t){this._chart=e,this._properties=new Map,this.configure(t)}configure(e){if(!G(e))return;let t=Object.keys(Z.animation),n=this._properties;Object.getOwnPropertyNames(e).forEach(r=>{let i=e[r];if(!G(i))return;let a={};for(let e of t)a[e]=i[e];(W(i.properties)&&i.properties||[r]).forEach(e=>{(e===r||!n.has(e))&&n.set(e,a)})})}_animateOptions(e,t){let n=t.options,r=Uc(e,n);if(!r)return[];let i=this._createAnimations(r,n);return n.$shared&&Hc(e.options.$animations,n).then(()=>{e.options=n},()=>{}),i}_createAnimations(e,t){let n=this._properties,r=[],i=e.$animations||={},a=Object.keys(t),o=Date.now(),s;for(s=a.length-1;s>=0;--s){let c=a[s];if(c.charAt(0)===`$`)continue;if(c===`options`){r.push(...this._animateOptions(e,t));continue}let l=t[c],u=i[c],d=n.get(c);if(u){if(d&&u.active()){u.update(d,l,o);continue}u.cancel()}if(!d||!d.duration){e[c]=l;continue}i[c]=u=new Bc(d,e,c,l),r.push(u)}return r}update(e,t){if(this._properties.size===0){Object.assign(e,t);return}let n=this._createAnimations(e,t);if(n.length)return Lc.add(this._chart,n),!0}};function Hc(e,t){let n=[],r=Object.keys(t);for(let t=0;t<r.length;t++){let i=e[r[t]];i&&i.active()&&n.push(i.wait())}return Promise.all(n)}function Uc(e,t){if(!t)return;let n=e.options;if(!n){e.options=t;return}return n.$shared&&(e.options=n=Object.assign({},n,{$shared:!1,$animations:{}})),n}function Wc(e,t){let n=e&&e.options||{},r=n.reverse,i=n.min===void 0?t:0,a=n.max===void 0?t:0;return{start:r?a:i,end:r?i:a}}function Gc(e,t,n){if(n===!1)return!1;let r=Wc(e,n),i=Wc(t,n);return{top:i.end,right:r.end,bottom:i.start,left:r.start}}function Kc(e){let t,n,r,i;return G(e)?(t=e.top,n=e.right,r=e.bottom,i=e.left):t=n=r=i=e,{top:t,right:n,bottom:r,left:i,disabled:e===!1}}function qc(e,t){let n=[],r=e._getSortedDatasetMetas(t),i,a;for(i=0,a=r.length;i<a;++i)n.push(r[i].index);return n}function Jc(e,t,n,r={}){let i=e.keys,a=r.mode===`single`,o,s,c,l;if(t===null)return;let u=!1;for(o=0,s=i.length;o<s;++o){if(c=+i[o],c===n){if(u=!0,r.all)continue;break}l=e.values[c],K(l)&&(a||t===0||Co(t)===Co(l))&&(t+=l)}return!u&&!r.all?0:t}function Yc(e,t){let{iScale:n,vScale:r}=t,i=n.axis===`x`?`x`:`y`,a=r.axis===`x`?`x`:`y`,o=Object.keys(e),s=Array(o.length),c,l,u;for(c=0,l=o.length;c<l;++c)u=o[c],s[c]={[i]:u,[a]:e[u]};return s}function Xc(e,t){let n=e&&e.options.stacked;return n||n===void 0&&t.stack!==void 0}function Zc(e,t,n){return`${e.id}.${t.id}.${n.stack||n.type}`}function Qc(e){let{min:t,max:n,minDefined:r,maxDefined:i}=e.getUserBounds();return{min:r?t:-1/0,max:i?n:1/0}}function $c(e,t,n){let r=e[t]||(e[t]={});return r[n]||(r[n]={})}function el(e,t,n,r){for(let i of t.getMatchingVisibleMetas(r).reverse()){let t=e[i.index];if(n&&t>0||!n&&t<0)return i.index}return null}function tl(e,t){let{chart:n,_cachedMeta:r}=e,i=n._stacks||={},{iScale:a,vScale:o,index:s}=r,c=a.axis,l=o.axis,u=Zc(a,o,r),d=t.length,f;for(let e=0;e<d;++e){let n=t[e],{[c]:a,[l]:d}=n,p=n._stacks||={};f=p[l]=$c(i,u,a),f[s]=d,f._top=el(f,o,!0,r.type),f._bottom=el(f,o,!1,r.type);let m=f._visualValues||(f._visualValues={});m[s]=d}}function nl(e,t){let n=e.scales;return Object.keys(n).filter(e=>n[e].axis===t).shift()}function rl(e,t){return qs(e,{active:!1,dataset:void 0,datasetIndex:t,index:t,mode:`default`,type:`dataset`})}function il(e,t,n){return qs(e,{active:!1,dataIndex:t,parsed:void 0,raw:void 0,element:n,index:t,mode:`default`,type:`data`})}function al(e,t){let n=e.controller.index,r=e.vScale&&e.vScale.axis;if(r){t||=e._parsed;for(let e of t){let t=e._stacks;if(!t||t[r]===void 0||t[r][n]===void 0)return;delete t[r][n],t[r]._visualValues!==void 0&&t[r]._visualValues[n]!==void 0&&delete t[r]._visualValues[n]}}}var ol=e=>e===`reset`||e===`none`,sl=(e,t)=>t?e:Object.assign({},e),cl=(e,t,n)=>e&&!t.hidden&&t._stacked&&{keys:qc(n,!0),values:null},ll=class{static defaults={};static datasetElementType=null;static dataElementType=null;constructor(e,t){this.chart=e,this._ctx=e.ctx,this.index=t,this._cachedDataOpts={},this._cachedMeta=this.getMeta(),this._type=this._cachedMeta.type,this.options=void 0,this._parsing=!1,this._data=void 0,this._objectData=void 0,this._sharedOptions=void 0,this._drawStart=void 0,this._drawCount=void 0,this.enableOptionSharing=!1,this.supportsDecimation=!1,this.$context=void 0,this._syncList=[],this.datasetElementType=new.target.datasetElementType,this.dataElementType=new.target.dataElementType,this.initialize()}initialize(){let e=this._cachedMeta;this.configure(),this.linkScales(),e._stacked=Xc(e.vScale,e),this.addElements(),this.options.fill&&!this.chart.isPluginEnabled(`filler`)&&console.warn(`Tried to use the 'fill' option without the 'Filler' plugin enabled. Please import and register the 'Filler' plugin and make sure it is not disabled in the options`)}updateIndex(e){this.index!==e&&al(this._cachedMeta),this.index=e}linkScales(){let e=this.chart,t=this._cachedMeta,n=this.getDataset(),r=(e,t,n,r)=>e===`x`?t:e===`r`?r:n,i=t.xAxisID=q(n.xAxisID,nl(e,`x`)),a=t.yAxisID=q(n.yAxisID,nl(e,`y`)),o=t.rAxisID=q(n.rAxisID,nl(e,`r`)),s=t.indexAxis,c=t.iAxisID=r(s,i,a,o),l=t.vAxisID=r(s,a,i,o);t.xScale=this.getScaleForId(i),t.yScale=this.getScaleForId(a),t.rScale=this.getScaleForId(o),t.iScale=this.getScaleForId(c),t.vScale=this.getScaleForId(l)}getDataset(){return this.chart.data.datasets[this.index]}getMeta(){return this.chart.getDatasetMeta(this.index)}getScaleForId(e){return this.chart.scales[e]}_getOtherScale(e){let t=this._cachedMeta;return e===t.iScale?t.vScale:t.iScale}reset(){this._update(`reset`)}_destroy(){let e=this._cachedMeta;this._data&&qo(this._data,this),e._stacked&&al(e)}_dataCheck(){let e=this.getDataset(),t=e.data||=[],n=this._data;if(G(t)){let e=this._cachedMeta;this._data=Yc(t,e)}else if(n!==t){if(n){qo(n,this);let e=this._cachedMeta;al(e),e._parsed=[]}t&&Object.isExtensible(t)&&Ko(t,this),this._syncList=[],this._data=t}}addElements(){let e=this._cachedMeta;this._dataCheck(),this.datasetElementType&&(e.dataset=new this.datasetElementType)}buildOrUpdateElements(e){let t=this._cachedMeta,n=this.getDataset(),r=!1;this._dataCheck();let i=t._stacked;t._stacked=Xc(t.vScale,t),t.stack!==n.stack&&(r=!0,al(t),t.stack=n.stack),this._resyncElements(e),(r||i!==t._stacked)&&(tl(this,t._parsed),t._stacked=Xc(t.vScale,t))}configure(){let e=this.chart.config,t=e.datasetScopeKeys(this._type),n=e.getOptionScopes(this.getDataset(),t,!0);this.options=e.createResolver(n,this.getContext()),this._parsing=this.options.parsing,this._cachedDataOpts={}}parse(e,t){let{_cachedMeta:n,_data:r}=this,{iScale:i,_stacked:a}=n,o=i.axis,s=e===0&&t===r.length||n._sorted,c=e>0&&n._parsed[e-1],l,u,d;if(this._parsing===!1)n._parsed=r,n._sorted=!0,d=r;else{d=W(r[e])?this.parseArrayData(n,r,e,t):G(r[e])?this.parseObjectData(n,r,e,t):this.parsePrimitiveData(n,r,e,t);let i=()=>u[o]===null||c&&u[o]<c[o];for(l=0;l<t;++l)n._parsed[l+e]=u=d[l],s&&(i()&&(s=!1),c=u);n._sorted=s}a&&tl(this,d)}parsePrimitiveData(e,t,n,r){let{iScale:i,vScale:a}=e,o=i.axis,s=a.axis,c=i.getLabels(),l=i===a,u=Array(r),d,f,p;for(d=0,f=r;d<f;++d)p=d+n,u[d]={[o]:l||i.parse(c[p],p),[s]:a.parse(t[p],p)};return u}parseArrayData(e,t,n,r){let{xScale:i,yScale:a}=e,o=Array(r),s,c,l,u;for(s=0,c=r;s<c;++s)l=s+n,u=t[l],o[s]={x:i.parse(u[0],l),y:a.parse(u[1],l)};return o}parseObjectData(e,t,n,r){let{xScale:i,yScale:a}=e,{xAxisKey:o=`x`,yAxisKey:s=`y`}=this._parsing,c=Array(r),l,u,d,f;for(l=0,u=r;l<u;++l)d=l+n,f=t[d],c[l]={x:i.parse(lo(f,o),d),y:a.parse(lo(f,s),d)};return c}getParsed(e){return this._cachedMeta._parsed[e]}getDataElement(e){return this._cachedMeta.data[e]}applyStack(e,t,n){let r=this.chart,i=this._cachedMeta,a=t[e.axis];return Jc({keys:qc(r,!0),values:t._stacks[e.axis]._visualValues},a,i.index,{mode:n})}updateRangeFromParsed(e,t,n,r){let i=n[t.axis],a=i===null?NaN:i,o=r&&n._stacks[t.axis];r&&o&&(r.values=o,a=Jc(r,i,this._cachedMeta.index)),e.min=Math.min(e.min,a),e.max=Math.max(e.max,a)}getMinMax(e,t){let n=this._cachedMeta,r=n._parsed,i=n._sorted&&e===n.iScale,a=r.length,o=this._getOtherScale(e),s=cl(t,n,this.chart),c={min:1/0,max:-1/0},{min:l,max:u}=Qc(o),d,f;function p(){f=r[d];let t=f[o.axis];return!K(f[e.axis])||l>t||u<t}for(d=0;d<a&&!(!p()&&(this.updateRangeFromParsed(c,e,f,s),i));++d);if(i){for(d=a-1;d>=0;--d)if(!p()){this.updateRangeFromParsed(c,e,f,s);break}}return c}getAllParsedValues(e){let t=this._cachedMeta._parsed,n=[],r,i,a;for(r=0,i=t.length;r<i;++r)a=t[r][e.axis],K(a)&&n.push(a);return n}getMaxOverflow(){return!1}getLabelAndValue(e){let t=this._cachedMeta,n=t.iScale,r=t.vScale,i=this.getParsed(e);return{label:n?``+n.getLabelForValue(i[n.axis]):``,value:r?``+r.getLabelForValue(i[r.axis]):``}}_update(e){let t=this._cachedMeta;this.update(e||`default`),t._clip=Kc(q(this.options.clip,Gc(t.xScale,t.yScale,this.getMaxOverflow())))}update(e){}draw(){let e=this._ctx,t=this.chart,n=this._cachedMeta,r=n.data||[],i=t.chartArea,a=[],o=this._drawStart||0,s=this._drawCount||r.length-o,c=this.options.drawActiveElementsOnTop,l;for(n.dataset&&n.dataset.draw(e,i,o,s),l=o;l<o+s;++l){let t=r[l];t.hidden||(t.active&&c?a.push(t):t.draw(e,i))}for(l=0;l<a.length;++l)a[l].draw(e,i)}getStyle(e,t){let n=t?`active`:`default`;return e===void 0&&this._cachedMeta.dataset?this.resolveDatasetElementOptions(n):this.resolveDataElementOptions(e||0,n)}getContext(e,t,n){let r=this.getDataset(),i;if(e>=0&&e<this._cachedMeta.data.length){let t=this._cachedMeta.data[e];i=t.$context||=il(this.getContext(),e,t),i.parsed=this.getParsed(e),i.raw=r.data[e],i.index=i.dataIndex=e}else i=this.$context||=rl(this.chart.getContext(),this.index),i.dataset=r,i.index=i.datasetIndex=this.index;return i.active=!!t,i.mode=n,i}resolveDatasetElementOptions(e){return this._resolveElementOptions(this.datasetElementType.id,e)}resolveDataElementOptions(e,t){return this._resolveElementOptions(this.dataElementType.id,t,e)}_resolveElementOptions(e,t=`default`,n){let r=t===`active`,i=this._cachedDataOpts,a=e+`-`+t,o=i[a],s=this.enableOptionSharing&&fo(n);if(o)return sl(o,s);let c=this.chart.config,l=c.datasetElementScopeKeys(this._type,e),u=r?[`${e}Hover`,`hover`,e,``]:[e,``],d=c.getOptionScopes(this.getDataset(),l),f=Object.keys(Z.elements[e]),p=c.resolveNamedOptions(d,f,()=>this.getContext(n,r,t),u);return p.$shared&&(p.$shared=s,i[a]=Object.freeze(sl(p,s))),p}_resolveAnimations(e,t,n){let r=this.chart,i=this._cachedDataOpts,a=`animation-${t}`,o=i[a];if(o)return o;let s;if(r.options.animation!==!1){let r=this.chart.config,i=r.datasetAnimationScopeKeys(this._type,t),a=r.getOptionScopes(this.getDataset(),i);s=r.createResolver(a,this.getContext(e,n,t))}let c=new Vc(r,s&&s.animations);return s&&s._cacheable&&(i[a]=Object.freeze(c)),c}getSharedOptions(e){if(e.$shared)return this._sharedOptions||=Object.assign({},e)}includeOptions(e,t){return!t||ol(e)||this.chart._animationsDisabled}_getSharedOptions(e,t){let n=this.resolveDataElementOptions(e,t),r=this._sharedOptions,i=this.getSharedOptions(n),a=this.includeOptions(t,i)||i!==r;return this.updateSharedOptions(i,t,n),{sharedOptions:i,includeOptions:a}}updateElement(e,t,n,r){ol(r)?Object.assign(e,n):this._resolveAnimations(t,r).update(e,n)}updateSharedOptions(e,t,n){e&&!ol(t)&&this._resolveAnimations(void 0,t).update(e,n)}_setStyle(e,t,n,r){e.active=r;let i=this.getStyle(t,r);this._resolveAnimations(t,n,r).update(e,{options:!r&&this.getSharedOptions(i)||i})}removeHoverStyle(e,t,n){this._setStyle(e,n,`active`,!1)}setHoverStyle(e,t,n){this._setStyle(e,n,`active`,!0)}_removeDatasetHoverStyle(){let e=this._cachedMeta.dataset;e&&this._setStyle(e,void 0,`active`,!1)}_setDatasetHoverStyle(){let e=this._cachedMeta.dataset;e&&this._setStyle(e,void 0,`active`,!0)}_resyncElements(e){let t=this._data,n=this._cachedMeta.data;for(let[e,t,n]of this._syncList)this[e](t,n);this._syncList=[];let r=n.length,i=t.length,a=Math.min(i,r);a&&this.parse(0,a),i>r?this._insertElements(r,i-r,e):i<r&&this._removeElements(i,r-i)}_insertElements(e,t,n=!0){let r=this._cachedMeta,i=r.data,a=e+t,o,s=e=>{for(e.length+=t,o=e.length-1;o>=a;o--)e[o]=e[o-t]};for(s(i),o=e;o<a;++o)i[o]=new this.dataElementType;this._parsing&&s(r._parsed),this.parse(e,t),n&&this.updateElements(i,e,t,`reset`)}updateElements(e,t,n,r){}_removeElements(e,t){let n=this._cachedMeta;if(this._parsing){let r=n._parsed.splice(e,t);n._stacked&&al(n,r)}n.data.splice(e,t)}_sync(e){if(this._parsing)this._syncList.push(e);else{let[t,n,r]=e;this[t](n,r)}this.chart._dataChanges.push([this.index,...e])}_onDataPush(){let e=arguments.length;this._sync([`_insertElements`,this.getDataset().data.length-e,e])}_onDataPop(){this._sync([`_removeElements`,this._cachedMeta.data.length-1,1])}_onDataShift(){this._sync([`_removeElements`,0,1])}_onDataSplice(e,t){t&&this._sync([`_removeElements`,e,t]);let n=arguments.length-2;n&&this._sync([`_insertElements`,e,n])}_onDataUnshift(){this._sync([`_insertElements`,0,arguments.length])}};function ul(e,t){if(!e._cache.$bar){let n=e.getMatchingVisibleMetas(t),r=[];for(let t=0,i=n.length;t<i;t++)r=r.concat(n[t].controller.getAllParsedValues(e));e._cache.$bar=Jo(r.sort((e,t)=>e-t))}return e._cache.$bar}function dl(e){let t=e.iScale,n=ul(t,e.type),r=t._length,i,a,o,s,c=()=>{o!==32767&&o!==-32768&&(fo(s)&&(r=Math.min(r,Math.abs(o-s)||r)),s=o)};for(i=0,a=n.length;i<a;++i)o=t.getPixelForValue(n[i]),c();for(s=void 0,i=0,a=t.ticks.length;i<a;++i)o=t.getPixelForTick(i),c();return r}function fl(e,t,n,r){let i=n.barThickness,a,o;return U(i)?(a=t.min*n.categoryPercentage,o=n.barPercentage):(a=i*r,o=1),{chunk:a/r,ratio:o,start:t.pixels[e]-a/2}}function pl(e,t,n,r){let i=t.pixels,a=i[e],o=e>0?i[e-1]:null,s=e<i.length-1?i[e+1]:null,c=n.categoryPercentage;o===null&&(o=a-(s===null?t.end-t.start:s-a)),s===null&&(s=a+a-o);let l=a-(a-Math.min(o,s))/2*c;return{chunk:Math.abs(s-o)/2*c/r,ratio:n.barPercentage,start:l}}function ml(e,t,n,r){let i=n.parse(e[0],r),a=n.parse(e[1],r),o=Math.min(i,a),s=Math.max(i,a),c=o,l=s;Math.abs(o)>Math.abs(s)&&(c=s,l=o),t[n.axis]=l,t._custom={barStart:c,barEnd:l,start:i,end:a,min:o,max:s}}function hl(e,t,n,r){return W(e)?ml(e,t,n,r):t[n.axis]=n.parse(e,r),t}function gl(e,t,n,r){let i=e.iScale,a=e.vScale,o=i.getLabels(),s=i===a,c=[],l,u,d,f;for(l=n,u=n+r;l<u;++l)f=t[l],d={},d[i.axis]=s||i.parse(o[l],l),c.push(hl(f,d,a,l));return c}function _l(e){return e&&e.barStart!==void 0&&e.barEnd!==void 0}function vl(e,t,n){return e===0?(t.isHorizontal()?1:-1)*(t.min>=n?1:-1):Co(e)}function yl(e){let t,n,r,i,a;return e.horizontal?(t=e.base>e.x,n=`left`,r=`right`):(t=e.base<e.y,n=`bottom`,r=`top`),t?(i=`end`,a=`start`):(i=`start`,a=`end`),{start:n,end:r,reverse:t,top:i,bottom:a}}function bl(e,t,n,r){let i=t.borderSkipped,a={};if(!i){e.borderSkipped=a;return}if(i===!0){e.borderSkipped={top:!0,right:!0,bottom:!0,left:!0};return}let{start:o,end:s,reverse:c,top:l,bottom:u}=yl(e);i===`middle`&&n&&(e.enableBorderRadius=!0,(n._top||0)===r?i=l:(n._bottom||0)===r?i=u:(a[xl(u,o,s,c)]=!0,i=l)),a[xl(i,o,s,c)]=!0,e.borderSkipped=a}function xl(e,t,n,r){return r?(e=Sl(e,t,n),e=Cl(e,n,t)):e=Cl(e,t,n),e}function Sl(e,t,n){return e===t?n:e===n?t:e}function Cl(e,t,n){return e===`start`?t:e===`end`?n:e}function wl(e,{inflateAmount:t},n){e.inflateAmount=t===`auto`?n===1?.33:0:t}var Tl=class extends ll{static id=`bar`;static defaults={datasetElementType:!1,dataElementType:`bar`,categoryPercentage:.8,barPercentage:.9,grouped:!0,animations:{numbers:{type:`number`,properties:[`x`,`y`,`base`,`width`,`height`]}}};static overrides={scales:{_index_:{type:`category`,offset:!0,grid:{offset:!0}},_value_:{type:`linear`,beginAtZero:!0}}};parsePrimitiveData(e,t,n,r){return gl(e,t,n,r)}parseArrayData(e,t,n,r){return gl(e,t,n,r)}parseObjectData(e,t,n,r){let{iScale:i,vScale:a}=e,{xAxisKey:o=`x`,yAxisKey:s=`y`}=this._parsing,c=i.axis===`x`?o:s,l=a.axis===`x`?o:s,u=[],d,f,p,m;for(d=n,f=n+r;d<f;++d)m=t[d],p={},p[i.axis]=i.parse(lo(m,c),d),u.push(hl(lo(m,l),p,a,d));return u}updateRangeFromParsed(e,t,n,r){super.updateRangeFromParsed(e,t,n,r);let i=n._custom;i&&t===this._cachedMeta.vScale&&(e.min=Math.min(e.min,i.min),e.max=Math.max(e.max,i.max))}getMaxOverflow(){return 0}getLabelAndValue(e){let{iScale:t,vScale:n}=this._cachedMeta,r=this.getParsed(e),i=r._custom,a=_l(i)?`[`+i.start+`, `+i.end+`]`:``+n.getLabelForValue(r[n.axis]);return{label:``+t.getLabelForValue(r[t.axis]),value:a}}initialize(){this.enableOptionSharing=!0,super.initialize();let e=this._cachedMeta;e.stack=this.getDataset().stack}update(e){let t=this._cachedMeta;this.updateElements(t.data,0,t.data.length,e)}updateElements(e,t,n,r){let i=r===`reset`,{index:a,_cachedMeta:{vScale:o}}=this,s=o.getBasePixel(),c=o.isHorizontal(),l=this._getRuler(),{sharedOptions:u,includeOptions:d}=this._getSharedOptions(t,r);for(let f=t;f<t+n;f++){let t=this.getParsed(f),n=i||U(t[o.axis])?{base:s,head:s}:this._calculateBarValuePixels(f),p=this._calculateBarIndexPixels(f,l),m=(t._stacks||{})[o.axis],h={horizontal:c,base:n.base,enableBorderRadius:!m||_l(t._custom)||a===m._top||a===m._bottom,x:c?n.head:p.center,y:c?p.center:n.head,height:c?p.size:Math.abs(n.size),width:c?Math.abs(n.size):p.size};d&&(h.options=u||this.resolveDataElementOptions(f,e[f].active?`active`:r));let g=h.options||e[f].options;bl(h,g,m,a),wl(h,g,l.ratio),this.updateElement(e[f],f,h,r)}}_getStacks(e,t){let{iScale:n}=this._cachedMeta,r=n.getMatchingVisibleMetas(this._type).filter(e=>e.controller.options.grouped),i=n.options.stacked,a=[],o=this._cachedMeta.controller.getParsed(t),s=o&&o[n.axis],c=e=>{let t=e._parsed.find(e=>e[n.axis]===s),r=t&&t[e.vScale.axis];if(U(r)||isNaN(r))return!0};for(let n of r)if(!(t!==void 0&&c(n))&&((i===!1||a.indexOf(n.stack)===-1||i===void 0&&n.stack===void 0)&&a.push(n.stack),n.index===e))break;return a.length||a.push(void 0),a}_getStackCount(e){return this._getStacks(void 0,e).length}_getAxisCount(){return this._getAxis().length}getFirstScaleIdForIndexAxis(){let e=this.chart.scales,t=this.chart.options.indexAxis;return Object.keys(e).filter(n=>e[n].axis===t).shift()}_getAxis(){let e={},t=this.getFirstScaleIdForIndexAxis();for(let n of this.chart.data.datasets)e[q(this.chart.options.indexAxis===`x`?n.xAxisID:n.yAxisID,t)]=!0;return Object.keys(e)}_getStackIndex(e,t,n){let r=this._getStacks(e,n),i=t===void 0?-1:r.indexOf(t);return i===-1?r.length-1:i}_getRuler(){let e=this.options,t=this._cachedMeta,n=t.iScale,r=[],i,a;for(i=0,a=t.data.length;i<a;++i)r.push(n.getPixelForValue(this.getParsed(i)[n.axis],i));let o=e.barThickness;return{min:o||dl(t),pixels:r,start:n._startPixel,end:n._endPixel,stackCount:this._getStackCount(),scale:n,grouped:e.grouped,ratio:o?1:e.categoryPercentage*e.barPercentage}}_calculateBarValuePixels(e){let{_cachedMeta:{vScale:t,_stacked:n,index:r},options:{base:i,minBarLength:a}}=this,o=i||0,s=this.getParsed(e),c=s._custom,l=_l(c),u=s[t.axis],d=0,f=n?this.applyStack(t,s,n):u,p,m;f!==u&&(d=f-u,f=u),l&&(u=c.barStart,f=c.barEnd-c.barStart,u!==0&&Co(u)!==Co(c.barEnd)&&(d=0),d+=u);let h=!U(i)&&!l?i:d,g=t.getPixelForValue(h);if(p=this.chart.getDataVisibility(e)?t.getPixelForValue(d+f):g,m=p-g,Math.abs(m)<a){m=vl(m,t,o)*a,u===o&&(g-=m/2);let e=t.getPixelForDecimal(0),i=t.getPixelForDecimal(1);g=Math.max(Math.min(g,Math.max(e,i)),Math.min(e,i)),p=g+m,n&&!l&&(s._stacks[t.axis]._visualValues[r]=t.getValueForPixel(p)-t.getValueForPixel(g))}if(g===t.getPixelForValue(o)){let e=Co(m)*t.getLineWidthForValue(o)/2;g+=e,m-=e}return{size:m,base:g,head:p,center:p+m/2}}_calculateBarIndexPixels(e,t){let n=t.scale,r=this.options,i=r.skipNull,a=q(r.maxBarThickness,1/0),o,s,c=this._getAxisCount();if(t.grouped){let n=i?this._getStackCount(e):t.stackCount,l=r.barThickness===`flex`?pl(e,t,r,n*c):fl(e,t,r,n*c),u=this.chart.options.indexAxis===`x`?this.getDataset().xAxisID:this.getDataset().yAxisID,d=this._getAxis().indexOf(q(u,this.getFirstScaleIdForIndexAxis())),f=this._getStackIndex(this.index,this._cachedMeta.stack,i?e:void 0)+d;o=l.start+l.chunk*f+l.chunk/2,s=Math.min(a,l.chunk*l.ratio)}else o=n.getPixelForValue(this.getParsed(e)[n.axis],e),s=Math.min(a,t.min*t.ratio);return{base:o-s/2,head:o+s/2,center:o,size:s}}draw(){let e=this._cachedMeta,t=e.vScale,n=e.data,r=n.length,i=0;for(;i<r;++i)this.getParsed(i)[t.axis]!==null&&!n[i].hidden&&n[i].draw(this._ctx)}};function El(){throw Error(`This method is not implemented: Check that a complete date adapter is provided.`)}var Dl={_date:class e{static override(t){Object.assign(e.prototype,t)}options;constructor(e){this.options=e||{}}init(){}formats(){return El()}parse(){return El()}format(){return El()}add(){return El()}diff(){return El()}startOf(){return El()}endOf(){return El()}}};function Ol(e,t,n,r){let{controller:i,data:a,_sorted:o}=e,s=i._cachedMeta.iScale,c=e.dataset&&e.dataset.options?e.dataset.options.spanGaps:null;if(s&&t===s.axis&&t!==`r`&&o&&a.length){let o=s._reversePixels?Uo:Ho;if(!r){let r=o(a,t,n);if(c){let{vScale:t}=i._cachedMeta,{_parsed:n}=e,a=n.slice(0,r.lo+1).reverse().findIndex(e=>!U(e[t.axis]));r.lo-=Math.max(0,a);let o=n.slice(r.hi).findIndex(e=>!U(e[t.axis]));r.hi+=Math.max(0,o)}return r}if(i._sharedOptions){let e=a[0],r=typeof e.getRange==`function`&&e.getRange(t);if(r){let e=o(a,t,n-r),i=o(a,t,n+r);return{lo:e.lo,hi:i.hi}}}}return{lo:0,hi:a.length-1}}function kl(e,t,n,r,i){let a=e.getSortedVisibleDatasetMetas(),o=n[t];for(let e=0,n=a.length;e<n;++e){let{index:n,data:s}=a[e],{lo:c,hi:l}=Ol(a[e],t,o,i);for(let e=c;e<=l;++e){let t=s[e];t.skip||r(t,n,e)}}}function Al(e){let t=e.indexOf(`x`)!==-1,n=e.indexOf(`y`)!==-1;return function(e,r){let i=t?Math.abs(e.x-r.x):0,a=n?Math.abs(e.y-r.y):0;return Math.sqrt(i**2+a**2)}}function jl(e,t,n,r,i){let a=[];return!i&&!e.isPointInArea(t)||kl(e,n,t,function(n,o,s){!i&&!As(n,e.chartArea,0)||n.inRange(t.x,t.y,r)&&a.push({element:n,datasetIndex:o,index:s})},!0),a}function Ml(e,t,n,r){let i=[];function a(e,n,a){let{startAngle:o,endAngle:s}=e.getProps([`startAngle`,`endAngle`],r),{angle:c}=Po(e,{x:t.x,y:t.y});Lo(c,o,s)&&i.push({element:e,datasetIndex:n,index:a})}return kl(e,n,t,a),i}function Nl(e,t,n,r,i,a){let o=[],s=Al(n),c=1/0;function l(n,l,u){let d=n.inRange(t.x,t.y,i);if(r&&!d)return;let f=n.getCenterPoint(i);if(!(a||e.isPointInArea(f))&&!d)return;let p=s(t,f);p<c?(o=[{element:n,datasetIndex:l,index:u}],c=p):p===c&&o.push({element:n,datasetIndex:l,index:u})}return kl(e,n,t,l),o}function Pl(e,t,n,r,i,a){return!a&&!e.isPointInArea(t)?[]:n===`r`&&!r?Ml(e,t,n,i):Nl(e,t,n,r,i,a)}function Fl(e,t,n,r,i){let a=[],o=n===`x`?`inXRange`:`inYRange`,s=!1;return kl(e,n,t,(e,r,c)=>{e[o]&&e[o](t[n],i)&&(a.push({element:e,datasetIndex:r,index:c}),s||=e.inRange(t.x,t.y,i))}),r&&!s?[]:a}var Il={evaluateInteractionItems:kl,modes:{index(e,t,n,r){let i=Sc(t,e),a=n.axis||`x`,o=n.includeInvisible||!1,s=n.intersect?jl(e,i,a,r,o):Pl(e,i,a,!1,r,o),c=[];return s.length?(e.getSortedVisibleDatasetMetas().forEach(e=>{let t=s[0].index,n=e.data[t];n&&!n.skip&&c.push({element:n,datasetIndex:e.index,index:t})}),c):[]},dataset(e,t,n,r){let i=Sc(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1,s=n.intersect?jl(e,i,a,r,o):Pl(e,i,a,!1,r,o);if(s.length>0){let t=s[0].datasetIndex,n=e.getDatasetMeta(t).data;s=[];for(let e=0;e<n.length;++e)s.push({element:n[e],datasetIndex:t,index:e})}return s},point(e,t,n,r){return jl(e,Sc(t,e),n.axis||`xy`,r,n.includeInvisible||!1)},nearest(e,t,n,r){let i=Sc(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1;return Pl(e,i,a,n.intersect,r,o)},x(e,t,n,r){return Fl(e,Sc(t,e),`x`,n.intersect,r)},y(e,t,n,r){return Fl(e,Sc(t,e),`y`,n.intersect,r)}}},Ll=[`left`,`top`,`right`,`bottom`];function Rl(e,t){return e.filter(e=>e.pos===t)}function zl(e,t){return e.filter(e=>Ll.indexOf(e.pos)===-1&&e.box.axis===t)}function Bl(e,t){return e.sort((e,n)=>{let r=t?n:e,i=t?e:n;return r.weight===i.weight?r.index-i.index:r.weight-i.weight})}function Vl(e){let t=[],n,r,i,a,o,s;for(n=0,r=(e||[]).length;n<r;++n)i=e[n],{position:a,options:{stack:o,stackWeight:s=1}}=i,t.push({index:n,box:i,pos:a,horizontal:i.isHorizontal(),weight:i.weight,stack:o&&a+o,stackWeight:s});return t}function Hl(e){let t={};for(let n of e){let{stack:e,pos:r,stackWeight:i}=n;if(!e||!Ll.includes(r))continue;let a=t[e]||(t[e]={count:0,placed:0,weight:0,size:0});a.count++,a.weight+=i}return t}function Ul(e,t){let n=Hl(e),{vBoxMaxWidth:r,hBoxMaxHeight:i}=t,a,o,s;for(a=0,o=e.length;a<o;++a){s=e[a];let{fullSize:o}=s.box,c=n[s.stack],l=c&&s.stackWeight/c.weight;s.horizontal?(s.width=l?l*r:o&&t.availableWidth,s.height=i):(s.width=r,s.height=l?l*i:o&&t.availableHeight)}return n}function Wl(e){let t=Vl(e),n=Bl(t.filter(e=>e.box.fullSize),!0),r=Bl(Rl(t,`left`),!0),i=Bl(Rl(t,`right`)),a=Bl(Rl(t,`top`),!0),o=Bl(Rl(t,`bottom`)),s=zl(t,`x`),c=zl(t,`y`);return{fullSize:n,leftAndTop:r.concat(a),rightAndBottom:i.concat(c).concat(o).concat(s),chartArea:Rl(t,`chartArea`),vertical:r.concat(i).concat(c),horizontal:a.concat(o).concat(s)}}function Gl(e,t,n,r){return Math.max(e[n],t[n])+Math.max(e[r],t[r])}function Kl(e,t){e.top=Math.max(e.top,t.top),e.left=Math.max(e.left,t.left),e.bottom=Math.max(e.bottom,t.bottom),e.right=Math.max(e.right,t.right)}function ql(e,t,n,r){let{pos:i,box:a}=n,o=e.maxPadding;if(!G(i)){n.size&&(e[i]-=n.size);let t=r[n.stack]||{size:0,count:1};t.size=Math.max(t.size,n.horizontal?a.height:a.width),n.size=t.size/t.count,e[i]+=n.size}a.getPadding&&Kl(o,a.getPadding());let s=Math.max(0,t.outerWidth-Gl(o,e,`left`,`right`)),c=Math.max(0,t.outerHeight-Gl(o,e,`top`,`bottom`)),l=s!==e.w,u=c!==e.h;return e.w=s,e.h=c,n.horizontal?{same:l,other:u}:{same:u,other:l}}function Jl(e){let t=e.maxPadding;function n(n){let r=Math.max(t[n]-e[n],0);return e[n]+=r,r}e.y+=n(`top`),e.x+=n(`left`),n(`right`),n(`bottom`)}function Yl(e,t){let n=t.maxPadding;function r(e){let r={left:0,top:0,right:0,bottom:0};return e.forEach(e=>{r[e]=Math.max(t[e],n[e])}),r}return r(e?[`left`,`right`]:[`top`,`bottom`])}function Xl(e,t,n,r){let i=[],a,o,s,c,l,u;for(a=0,o=e.length,l=0;a<o;++a){s=e[a],c=s.box,c.update(s.width||t.w,s.height||t.h,Yl(s.horizontal,t));let{same:o,other:d}=ql(t,n,s,r);l|=o&&i.length,u||=d,c.fullSize||i.push(s)}return l&&Xl(i,t,n,r)||u}function Zl(e,t,n,r,i){e.top=n,e.left=t,e.right=t+r,e.bottom=n+i,e.width=r,e.height=i}function Ql(e,t,n,r){let i=n.padding,{x:a,y:o}=t;for(let s of e){let e=s.box,c=r[s.stack]||{count:1,placed:0,weight:1},l=s.stackWeight/c.weight||1;if(s.horizontal){let r=t.w*l,a=c.size||e.height;fo(c.start)&&(o=c.start),e.fullSize?Zl(e,i.left,o,n.outerWidth-i.right-i.left,a):Zl(e,t.left+c.placed,o,r,a),c.start=o,c.placed+=r,o=e.bottom}else{let r=t.h*l,o=c.size||e.width;fo(c.start)&&(a=c.start),e.fullSize?Zl(e,a,i.top,o,n.outerHeight-i.bottom-i.top):Zl(e,a,t.top+c.placed,o,r),c.start=a,c.placed+=r,a=e.right}}t.x=a,t.y=o}var $l={addBox(e,t){e.boxes||=[],t.fullSize=t.fullSize||!1,t.position=t.position||`top`,t.weight=t.weight||0,t._layers=t._layers||function(){return[{z:0,draw(e){t.draw(e)}}]},e.boxes.push(t)},removeBox(e,t){let n=e.boxes?e.boxes.indexOf(t):-1;n!==-1&&e.boxes.splice(n,1)},configure(e,t,n){t.fullSize=n.fullSize,t.position=n.position,t.weight=n.weight},update(e,t,n,r){if(!e)return;let i=Q(e.options.layout.padding),a=Math.max(t-i.width,0),o=Math.max(n-i.height,0),s=Wl(e.boxes),c=s.vertical,l=s.horizontal;Y(e.boxes,e=>{typeof e.beforeLayout==`function`&&e.beforeLayout()});let u=c.reduce((e,t)=>t.box.options&&t.box.options.display===!1?e:e+1,0)||1,d=Object.freeze({outerWidth:t,outerHeight:n,padding:i,availableWidth:a,availableHeight:o,vBoxMaxWidth:a/2/u,hBoxMaxHeight:o/2}),f=Object.assign({},i);Kl(f,Q(r));let p=Object.assign({maxPadding:f,w:a,h:o,x:i.left,y:i.top},i),m=Ul(c.concat(l),d);Xl(s.fullSize,p,d,m),Xl(c,p,d,m),Xl(l,p,d,m)&&Xl(c,p,d,m),Jl(p),Ql(s.leftAndTop,p,d,m),p.x+=p.w,p.y+=p.h,Ql(s.rightAndBottom,p,d,m),e.chartArea={left:p.left,top:p.top,right:p.left+p.w,bottom:p.top+p.h,height:p.h,width:p.w},Y(s.chartArea,t=>{let n=t.box;Object.assign(n,e.chartArea),n.update(p.w,p.h,{left:0,top:0,right:0,bottom:0})})}},eu=class{acquireContext(e,t){}releaseContext(e){return!1}addEventListener(e,t,n){}removeEventListener(e,t,n){}getDevicePixelRatio(){return 1}getMaximumSize(e,t,n,r){return t=Math.max(0,t||e.width),n||=e.height,{width:t,height:Math.max(0,r?Math.floor(t/r):n)}}isAttached(e){return!0}updateConfig(e){}},tu=class extends eu{acquireContext(e){return e&&e.getContext&&e.getContext(`2d`)||null}updateConfig(e){e.options.animation=!1}},nu=`$chartjs`,ru={touchstart:`mousedown`,touchmove:`mousemove`,touchend:`mouseup`,pointerenter:`mouseenter`,pointerdown:`mousedown`,pointermove:`mousemove`,pointerup:`mouseup`,pointerleave:`mouseout`,pointerout:`mouseout`},iu=e=>e===null||e===``;function au(e,t){let n=e.style,r=e.getAttribute(`height`),i=e.getAttribute(`width`);if(e[nu]={initial:{height:r,width:i,style:{display:n.display,height:n.height,width:n.width}}},n.display=n.display||`block`,n.boxSizing=n.boxSizing||`border-box`,iu(i)){let t=Oc(e,`width`);t!==void 0&&(e.width=t)}if(iu(r)){if(e.style.height===``)e.height=e.width/(t||2);else{let t=Oc(e,`height`);t!==void 0&&(e.height=t)}}return e}var ou=Dc?{passive:!0}:!1;function su(e,t,n){e&&e.addEventListener(t,n,ou)}function cu(e,t,n){e&&e.canvas&&e.canvas.removeEventListener(t,n,ou)}function lu(e,t){let n=ru[e.type]||e.type,{x:r,y:i}=Sc(e,t);return{type:n,chart:t,native:e,x:r===void 0?null:r,y:i===void 0?null:i}}function uu(e,t){for(let n of e)if(n===t||n.contains(t))return!0}function du(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=uu(n.addedNodes,r),t&&=!uu(n.removedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}function fu(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=uu(n.removedNodes,r),t&&=!uu(n.addedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}var pu=new Map,mu=0;function hu(){let e=window.devicePixelRatio;e!==mu&&(mu=e,pu.forEach((t,n)=>{n.currentDevicePixelRatio!==e&&t()}))}function gu(e,t){pu.size||window.addEventListener(`resize`,hu),pu.set(e,t)}function _u(e){pu.delete(e),pu.size||window.removeEventListener(`resize`,hu)}function vu(e,t,n){let r=e.canvas,i=r&&mc(r);if(!i)return;let a=Xo((e,t)=>{let r=i.clientWidth;n(e,t),r<i.clientWidth&&n()},window),o=new ResizeObserver(e=>{let t=e[0],n=t.contentRect.width,r=t.contentRect.height;(n!==0||r!==0)&&a(n,r)});return o.observe(i),gu(e,a),o}function yu(e,t,n){n&&n.disconnect(),t===`resize`&&_u(e)}function bu(e,t,n){let r=e.canvas,i=Xo(t=>{e.ctx!==null&&n(lu(t,e))},e);return su(r,t,i),i}var xu=class extends eu{acquireContext(e,t){let n=e&&e.getContext&&e.getContext(`2d`);return n&&n.canvas===e?(au(e,t),n):null}releaseContext(e){let t=e.canvas;if(!t[nu])return!1;let n=t[nu].initial;[`height`,`width`].forEach(e=>{let r=n[e];U(r)?t.removeAttribute(e):t.setAttribute(e,r)});let r=n.style||{};return Object.keys(r).forEach(e=>{t.style[e]=r[e]}),t.width=t.width,delete t[nu],!0}addEventListener(e,t,n){this.removeEventListener(e,t);let r=e.$proxies||={};r[t]=({attach:du,detach:fu,resize:vu}[t]||bu)(e,t,n)}removeEventListener(e,t){let n=e.$proxies||={},r=n[t];r&&(({attach:yu,detach:yu,resize:yu}[t]||cu)(e,t,r),n[t]=void 0)}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(e,t,n,r){return Tc(e,t,n,r)}isAttached(e){let t=e&&mc(e);return!!(t&&t.isConnected)}};function Su(e){return!pc()||typeof OffscreenCanvas<`u`&&e instanceof OffscreenCanvas?tu:xu}var Cu=class{static defaults={};static defaultRoutes=void 0;x;y;active=!1;options;$animations;tooltipPosition(e){let{x:t,y:n}=this.getProps([`x`,`y`],e);return{x:t,y:n}}hasValue(){return Oo(this.x)&&Oo(this.y)}getProps(e,t){let n=this.$animations;if(!t||!n)return this;let r={};return e.forEach(e=>{r[e]=n[e]&&n[e].active()?n[e]._to:this[e]}),r}};function wu(e,t){let n=e.options.ticks,r=Tu(e),i=Math.min(n.maxTicksLimit||r,r),a=n.major.enabled?Du(t):[],o=a.length,s=a[0],c=a[o-1],l=[];if(o>i)return Ou(t,l,a,o/i),l;let u=Eu(a,t,i);if(o>0){let e,n,r=o>1?Math.round((c-s)/(o-1)):null;for(ku(t,l,u,U(r)?0:s-r,s),e=0,n=o-1;e<n;e++)ku(t,l,u,a[e],a[e+1]);return ku(t,l,u,c,U(r)?t.length:c+r),l}return ku(t,l,u),l}function Tu(e){let t=e.options.offset,n=e._tickSize(),r=e._length/n+ +!t,i=e._maxLength/n;return Math.floor(Math.min(r,i))}function Eu(e,t,n){let r=Au(e),i=t.length/n;if(!r)return Math.max(i,1);let a=Eo(r);for(let e=0,t=a.length-1;e<t;e++){let t=a[e];if(t>i)return t}return Math.max(i,1)}function Du(e){let t=[],n,r;for(n=0,r=e.length;n<r;n++)e[n].major&&t.push(n);return t}function Ou(e,t,n,r){let i=0,a=n[0],o;for(r=Math.ceil(r),o=0;o<e.length;o++)o===a&&(t.push(e[o]),i++,a=n[i*r])}function ku(e,t,n,r,i){let a=q(r,0),o=Math.min(q(i,e.length),e.length),s=0,c,l,u;for(n=Math.ceil(n),i&&(c=i-r,n=c/Math.floor(c/n)),u=a;u<0;)s++,u=Math.round(a+s*n);for(l=Math.max(a,0);l<o;l++)l===u&&(t.push(e[l]),s++,u=Math.round(a+s*n))}function Au(e){let t=e.length,n,r;if(t<2)return!1;for(r=e[0],n=1;n<t;++n)if(e[n]-e[n-1]!==r)return!1;return r}var ju=e=>e===`left`?`right`:e===`right`?`left`:e,Mu=(e,t,n)=>t===`top`||t===`left`?e[t]+n:e[t]-n,Nu=(e,t)=>Math.min(t||e,e);function Pu(e,t){let n=[],r=e.length/t,i=e.length,a=0;for(;a<i;a+=r)n.push(e[Math.floor(a)]);return n}function Fu(e,t,n){let r=e.ticks.length,i=Math.min(t,r-1),a=e._startPixel,o=e._endPixel,s=1e-6,c=e.getPixelForTick(i),l;if(!(n&&(l=r===1?Math.max(c-a,o-c):t===0?(e.getPixelForTick(1)-c)/2:(c-e.getPixelForTick(i-1))/2,c+=i<t?l:-l,c<a-s||c>o+s)))return c}function Iu(e,t){Y(e,e=>{let n=e.gc,r=n.length/2,i;if(r>t){for(i=0;i<r;++i)delete e.data[n[i]];n.splice(0,r)}})}function Lu(e){return e.drawTicks?e.tickLength:0}function Ru(e,t){if(!e.display)return 0;let n=$(e.font,t),r=Q(e.padding);return(W(e.text)?e.text.length:1)*n.lineHeight+r.height}function zu(e,t){return qs(e,{scale:t,type:`scale`})}function Bu(e,t,n){return qs(e,{tick:n,index:t,type:`tick`})}function Vu(e,t,n){let r=Qo(e);return(n&&t!==`right`||!n&&t===`right`)&&(r=ju(r)),r}function Hu(e,t,n,r){let{top:i,left:a,bottom:o,right:s,chart:c}=e,{chartArea:l,scales:u}=c,d=0,f,p,m,h=o-i,g=s-a;if(e.isHorizontal()){if(p=$o(r,a,s),G(n)){let e=Object.keys(n)[0],r=n[e];m=u[e].getPixelForValue(r)+h-t}else m=n===`center`?(l.bottom+l.top)/2+h-t:Mu(e,n,t);f=s-a}else{if(G(n)){let e=Object.keys(n)[0],r=n[e];p=u[e].getPixelForValue(r)-g+t}else p=n===`center`?(l.left+l.right)/2-g+t:Mu(e,n,t);m=$o(r,o,i),d=n===`left`?-yo:yo}return{titleX:p,titleY:m,maxWidth:f,rotation:d}}var Uu=class e extends Cu{constructor(e){super(),this.id=e.id,this.type=e.type,this.options=void 0,this.ctx=e.ctx,this.chart=e.chart,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.width=void 0,this.height=void 0,this._margins={left:0,right:0,top:0,bottom:0},this.maxWidth=void 0,this.maxHeight=void 0,this.paddingTop=void 0,this.paddingBottom=void 0,this.paddingLeft=void 0,this.paddingRight=void 0,this.axis=void 0,this.labelRotation=void 0,this.min=void 0,this.max=void 0,this._range=void 0,this.ticks=[],this._gridLineItems=null,this._labelItems=null,this._labelSizes=null,this._length=0,this._maxLength=0,this._longestTextCache={},this._startPixel=void 0,this._endPixel=void 0,this._reversePixels=!1,this._userMax=void 0,this._userMin=void 0,this._suggestedMax=void 0,this._suggestedMin=void 0,this._ticksLength=0,this._borderValue=0,this._cache={},this._dataLimitsCached=!1,this.$context=void 0}init(e){this.options=e.setContext(this.getContext()),this.axis=e.axis,this._userMin=this.parse(e.min),this._userMax=this.parse(e.max),this._suggestedMin=this.parse(e.suggestedMin),this._suggestedMax=this.parse(e.suggestedMax)}parse(e,t){return e}getUserBounds(){let{_userMin:e,_userMax:t,_suggestedMin:n,_suggestedMax:r}=this;return e=Za(e,1/0),t=Za(t,-1/0),n=Za(n,1/0),r=Za(r,-1/0),{min:Za(e,n),max:Za(t,r),minDefined:K(e),maxDefined:K(t)}}getMinMax(e){let{min:t,max:n,minDefined:r,maxDefined:i}=this.getUserBounds(),a;if(r&&i)return{min:t,max:n};let o=this.getMatchingVisibleMetas();for(let s=0,c=o.length;s<c;++s)a=o[s].controller.getMinMax(this,e),r||(t=Math.min(t,a.min)),i||(n=Math.max(n,a.max));return t=i&&t>n?n:t,n=r&&t>n?t:n,{min:Za(t,Za(n,t)),max:Za(n,Za(t,n))}}getPadding(){return{left:this.paddingLeft||0,top:this.paddingTop||0,right:this.paddingRight||0,bottom:this.paddingBottom||0}}getTicks(){return this.ticks}getLabels(){let e=this.chart.data;return this.options.labels||(this.isHorizontal()?e.xLabels:e.yLabels)||e.labels||[]}getLabelItems(e=this.chart.chartArea){return this._labelItems||=this._computeLabelItems(e)}beforeLayout(){this._cache={},this._dataLimitsCached=!1}beforeUpdate(){J(this.options.beforeUpdate,[this])}update(e,t,n){let{beginAtZero:r,grace:i,ticks:a}=this.options,o=a.sampleSize;this.beforeUpdate(),this.maxWidth=e,this.maxHeight=t,this._margins=n=Object.assign({left:0,right:0,top:0,bottom:0},n),this.ticks=null,this._labelSizes=null,this._gridLineItems=null,this._labelItems=null,this.beforeSetDimensions(),this.setDimensions(),this.afterSetDimensions(),this._maxLength=this.isHorizontal()?this.width+n.left+n.right:this.height+n.top+n.bottom,this._dataLimitsCached||=(this.beforeDataLimits(),this.determineDataLimits(),this.afterDataLimits(),this._range=Ks(this,i,r),!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();let s=o<this.ticks.length;this._convertTicksToLabels(s?Pu(this.ticks,o):this.ticks),this.configure(),this.beforeCalculateLabelRotation(),this.calculateLabelRotation(),this.afterCalculateLabelRotation(),a.display&&(a.autoSkip||a.source===`auto`)&&(this.ticks=wu(this,this.ticks),this._labelSizes=null,this.afterAutoSkip()),s&&this._convertTicksToLabels(this.ticks),this.beforeFit(),this.fit(),this.afterFit(),this.afterUpdate()}configure(){let e=this.options.reverse,t,n;this.isHorizontal()?(t=this.left,n=this.right):(t=this.top,n=this.bottom,e=!e),this._startPixel=t,this._endPixel=n,this._reversePixels=e,this._length=n-t,this._alignToPixels=this.options.alignToPixels}afterUpdate(){J(this.options.afterUpdate,[this])}beforeSetDimensions(){J(this.options.beforeSetDimensions,[this])}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=0,this.right=this.width):(this.height=this.maxHeight,this.top=0,this.bottom=this.height),this.paddingLeft=0,this.paddingTop=0,this.paddingRight=0,this.paddingBottom=0}afterSetDimensions(){J(this.options.afterSetDimensions,[this])}_callHooks(e){this.chart.notifyPlugins(e,this.getContext()),J(this.options[e],[this])}beforeDataLimits(){this._callHooks(`beforeDataLimits`)}determineDataLimits(){}afterDataLimits(){this._callHooks(`afterDataLimits`)}beforeBuildTicks(){this._callHooks(`beforeBuildTicks`)}buildTicks(){return[]}afterBuildTicks(){this._callHooks(`afterBuildTicks`)}beforeTickToLabelConversion(){J(this.options.beforeTickToLabelConversion,[this])}generateTickLabels(e){let t=this.options.ticks,n,r,i;for(n=0,r=e.length;n<r;n++)i=e[n],i.label=J(t.callback,[i.value,n,e],this)}afterTickToLabelConversion(){J(this.options.afterTickToLabelConversion,[this])}beforeCalculateLabelRotation(){J(this.options.beforeCalculateLabelRotation,[this])}calculateLabelRotation(){let e=this.options,t=e.ticks,n=Nu(this.ticks.length,e.ticks.maxTicksLimit),r=t.minRotation||0,i=t.maxRotation,a=r,o,s,c;if(!this._isVisible()||!t.display||r>=i||n<=1||!this.isHorizontal()){this.labelRotation=r;return}let l=this._getLabelSizes(),u=l.widest.width,d=l.highest.height,f=Ro(this.chart.width-u,0,this.maxWidth);o=e.offset?this.maxWidth/n:f/(n-1),u+6>o&&(o=f/(n-(e.offset?.5:1)),s=this.maxHeight-Lu(e.grid)-t.padding-Ru(e.title,this.chart.options.font),c=Math.sqrt(u*u+d*d),a=Mo(Math.min(Math.asin(Ro((l.highest.height+6)/o,-1,1)),Math.asin(Ro(s/c,-1,1))-Math.asin(Ro(d/c,-1,1)))),a=Math.max(r,Math.min(i,a))),this.labelRotation=a}afterCalculateLabelRotation(){J(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){J(this.options.beforeFit,[this])}fit(){let e={width:0,height:0},{chart:t,options:{ticks:n,title:r,grid:i}}=this,a=this._isVisible(),o=this.isHorizontal();if(a){let a=Ru(r,t.options.font);if(o?(e.width=this.maxWidth,e.height=Lu(i)+a):(e.height=this.maxHeight,e.width=Lu(i)+a),n.display&&this.ticks.length){let{first:t,last:r,widest:i,highest:a}=this._getLabelSizes(),s=n.padding*2,c=jo(this.labelRotation),l=Math.cos(c),u=Math.sin(c);if(o){let t=n.mirror?0:u*i.width+l*a.height;e.height=Math.min(this.maxHeight,e.height+t+s)}else{let t=n.mirror?0:l*i.width+u*a.height;e.width=Math.min(this.maxWidth,e.width+t+s)}this._calculatePadding(t,r,u,l)}}this._handleMargins(),o?(this.width=this._length=t.width-this._margins.left-this._margins.right,this.height=e.height):(this.width=e.width,this.height=this._length=t.height-this._margins.top-this._margins.bottom)}_calculatePadding(e,t,n,r){let{ticks:{align:i,padding:a},position:o}=this.options,s=this.labelRotation!==0,c=o!==`top`&&this.axis===`x`;if(this.isHorizontal()){let o=this.getPixelForTick(0)-this.left,l=this.right-this.getPixelForTick(this.ticks.length-1),u=0,d=0;s?c?(u=r*e.width,d=n*t.height):(u=n*e.height,d=r*t.width):i===`start`?d=t.width:i===`end`?u=e.width:i!==`inner`&&(u=e.width/2,d=t.width/2),this.paddingLeft=Math.max((u-o+a)*this.width/(this.width-o),0),this.paddingRight=Math.max((d-l+a)*this.width/(this.width-l),0)}else{let n=t.height/2,r=e.height/2;i===`start`?(n=0,r=e.height):i===`end`&&(n=t.height,r=0),this.paddingTop=n+a,this.paddingBottom=r+a}}_handleMargins(){this._margins&&(this._margins.left=Math.max(this.paddingLeft,this._margins.left),this._margins.top=Math.max(this.paddingTop,this._margins.top),this._margins.right=Math.max(this.paddingRight,this._margins.right),this._margins.bottom=Math.max(this.paddingBottom,this._margins.bottom))}afterFit(){J(this.options.afterFit,[this])}isHorizontal(){let{axis:e,position:t}=this.options;return t===`top`||t===`bottom`||e===`x`}isFullSize(){return this.options.fullSize}_convertTicksToLabels(e){this.beforeTickToLabelConversion(),this.generateTickLabels(e);let t,n;for(t=0,n=e.length;t<n;t++)U(e[t].label)&&(e.splice(t,1),n--,t--);this.afterTickToLabelConversion()}_getLabelSizes(){let e=this._labelSizes;if(!e){let t=this.options.ticks.sampleSize,n=this.ticks;t<n.length&&(n=Pu(n,t)),this._labelSizes=e=this._computeLabelSizes(n,n.length,this.options.ticks.maxTicksLimit)}return e}_computeLabelSizes(e,t,n){let{ctx:r,_longestTextCache:i}=this,a=[],o=[],s=Math.floor(t/Nu(t,n)),c=0,l=0,u,d,f,p,m,h,g,_,v,y,b;for(u=0;u<t;u+=s){if(p=e[u].label,m=this._resolveTickFontOptions(u),r.font=h=m.string,g=i[h]=i[h]||{data:{},gc:[]},_=m.lineHeight,v=y=0,!U(p)&&!W(p))v=ws(r,g.data,g.gc,v,p),y=_;else if(W(p))for(d=0,f=p.length;d<f;++d)b=p[d],!U(b)&&!W(b)&&(v=ws(r,g.data,g.gc,v,b),y+=_);a.push(v),o.push(y),c=Math.max(v,c),l=Math.max(y,l)}Iu(i,t);let x=a.indexOf(c),S=o.indexOf(l),C=e=>({width:a[e]||0,height:o[e]||0});return{first:C(0),last:C(t-1),widest:C(x),highest:C(S),widths:a,heights:o}}getLabelForValue(e){return e}getPixelForValue(e,t){return NaN}getValueForPixel(e){}getPixelForTick(e){let t=this.ticks;return e<0||e>t.length-1?null:this.getPixelForValue(t[e].value)}getPixelForDecimal(e){this._reversePixels&&(e=1-e);let t=this._startPixel+e*this._length;return zo(this._alignToPixels?Es(this.chart,t,0):t)}getDecimalForPixel(e){let t=(e-this._startPixel)/this._length;return this._reversePixels?1-t:t}getBasePixel(){return this.getPixelForValue(this.getBaseValue())}getBaseValue(){let{min:e,max:t}=this;return e<0&&t<0?t:e>0&&t>0?e:0}getContext(e){let t=this.ticks||[];if(e>=0&&e<t.length){let n=t[e];return n.$context||=Bu(this.getContext(),e,n)}return this.$context||=zu(this.chart.getContext(),this)}_tickSize(){let e=this.options.ticks,t=jo(this.labelRotation),n=Math.abs(Math.cos(t)),r=Math.abs(Math.sin(t)),i=this._getLabelSizes(),a=e.autoSkipPadding||0,o=i?i.widest.width+a:0,s=i?i.highest.height+a:0;return this.isHorizontal()?s*n>o*r?o/n:s/r:s*r<o*n?s/n:o/r}_isVisible(){let e=this.options.display;return e===`auto`?this.getMatchingVisibleMetas().length>0:!!e}_computeGridLineItems(e){let t=this.axis,n=this.chart,r=this.options,{grid:i,position:a,border:o}=r,s=i.offset,c=this.isHorizontal(),l=this.ticks.length+ +!!s,u=Lu(i),d=[],f=o.setContext(this.getContext()),p=f.display?f.width:0,m=p/2,h=function(e){return Es(n,e,p)},g,_,v,y,b,x,S,C,w,T,E,D;if(a===`top`)g=h(this.bottom),x=this.bottom-u,C=g-m,T=h(e.top)+m,D=e.bottom;else if(a===`bottom`)g=h(this.top),T=e.top,D=h(e.bottom)-m,x=g+m,C=this.top+u;else if(a===`left`)g=h(this.right),b=this.right-u,S=g-m,w=h(e.left)+m,E=e.right;else if(a===`right`)g=h(this.left),w=e.left,E=h(e.right)-m,b=g+m,S=this.left+u;else if(t===`x`){if(a===`center`)g=h((e.top+e.bottom)/2+.5);else if(G(a)){let e=Object.keys(a)[0],t=a[e];g=h(this.chart.scales[e].getPixelForValue(t))}T=e.top,D=e.bottom,x=g+m,C=x+u}else if(t===`y`){if(a===`center`)g=h((e.left+e.right)/2);else if(G(a)){let e=Object.keys(a)[0],t=a[e];g=h(this.chart.scales[e].getPixelForValue(t))}b=g-m,S=b-u,w=e.left,E=e.right}let O=q(r.ticks.maxTicksLimit,l),k=Math.max(1,Math.ceil(l/O));for(_=0;_<l;_+=k){let e=this.getContext(_),t=i.setContext(e),r=o.setContext(e),a=t.lineWidth,l=t.color,u=r.dash||[],f=r.dashOffset,p=t.tickWidth,m=t.tickColor,h=t.tickBorderDash||[],g=t.tickBorderDashOffset;v=Fu(this,_,s),v!==void 0&&(y=Es(n,v,a),c?b=S=w=E=y:x=C=T=D=y,d.push({tx1:b,ty1:x,tx2:S,ty2:C,x1:w,y1:T,x2:E,y2:D,width:a,color:l,borderDash:u,borderDashOffset:f,tickWidth:p,tickColor:m,tickBorderDash:h,tickBorderDashOffset:g}))}return this._ticksLength=l,this._borderValue=g,d}_computeLabelItems(e){let t=this.axis,n=this.options,{position:r,ticks:i}=n,a=this.isHorizontal(),o=this.ticks,{align:s,crossAlign:c,padding:l,mirror:u}=i,d=Lu(n.grid),f=d+l,p=u?-l:f,m=-jo(this.labelRotation),h=[],g,_,v,y,b,x,S,C,w,T,E,D,O=`middle`;if(r===`top`)x=this.bottom-p,S=this._getXAxisLabelAlignment();else if(r===`bottom`)x=this.top+p,S=this._getXAxisLabelAlignment();else if(r===`left`){let e=this._getYAxisLabelAlignment(d);S=e.textAlign,b=e.x}else if(r===`right`){let e=this._getYAxisLabelAlignment(d);S=e.textAlign,b=e.x}else if(t===`x`){if(r===`center`)x=(e.top+e.bottom)/2+f;else if(G(r)){let e=Object.keys(r)[0],t=r[e];x=this.chart.scales[e].getPixelForValue(t)+f}S=this._getXAxisLabelAlignment()}else if(t===`y`){if(r===`center`)b=(e.left+e.right)/2-f;else if(G(r)){let e=Object.keys(r)[0],t=r[e];b=this.chart.scales[e].getPixelForValue(t)}S=this._getYAxisLabelAlignment(d).textAlign}t===`y`&&(s===`start`?O=`top`:s===`end`&&(O=`bottom`));let k=this._getLabelSizes();for(g=0,_=o.length;g<_;++g){v=o[g],y=v.label;let e=i.setContext(this.getContext(g));C=this.getPixelForTick(g)+i.labelOffset,w=this._resolveTickFontOptions(g),T=w.lineHeight,E=W(y)?y.length:1;let t=E/2,n=e.color,s=e.textStrokeColor,l=e.textStrokeWidth,d=S;a?(b=C,S===`inner`&&(d=g===_-1?this.options.reverse?`left`:`right`:g===0?this.options.reverse?`right`:`left`:`center`),D=r===`top`?c===`near`||m!==0?-E*T+T/2:c===`center`?-k.highest.height/2-t*T+T:-k.highest.height+T/2:c===`near`||m!==0?T/2:c===`center`?k.highest.height/2-t*T:k.highest.height-E*T,u&&(D*=-1),m!==0&&!e.showLabelBackdrop&&(b+=T/2*Math.sin(m))):(x=C,D=(1-E)*T/2);let f;if(e.showLabelBackdrop){let t=Q(e.backdropPadding),n=k.heights[g],r=k.widths[g],i=D-t.top,a=0-t.left;switch(O){case`middle`:i-=n/2;break;case`bottom`:i-=n}switch(S){case`center`:a-=r/2;break;case`right`:a-=r;break;case`inner`:g===_-1?a-=r:g>0&&(a-=r/2)}f={left:a,top:i,width:r+t.width,height:n+t.height,color:e.backdropColor}}h.push({label:y,font:w,textOffset:D,options:{rotation:m,color:n,strokeColor:s,strokeWidth:l,textAlign:d,textBaseline:O,translation:[b,x],backdrop:f}})}return h}_getXAxisLabelAlignment(){let{position:e,ticks:t}=this.options;if(-jo(this.labelRotation))return e===`top`?`left`:`right`;let n=`center`;return t.align===`start`?n=`left`:t.align===`end`?n=`right`:t.align===`inner`&&(n=`inner`),n}_getYAxisLabelAlignment(e){let{position:t,ticks:{crossAlign:n,mirror:r,padding:i}}=this.options,a=this._getLabelSizes(),o=e+i,s=a.widest.width,c,l;return t===`left`?r?(l=this.right+i,n===`near`?c=`left`:n===`center`?(c=`center`,l+=s/2):(c=`right`,l+=s)):(l=this.right-o,n===`near`?c=`right`:n===`center`?(c=`center`,l-=s/2):(c=`left`,l=this.left)):t===`right`?r?(l=this.left+i,n===`near`?c=`right`:n===`center`?(c=`center`,l-=s/2):(c=`left`,l-=s)):(l=this.left+o,n===`near`?c=`left`:n===`center`?(c=`center`,l+=s/2):(c=`right`,l=this.right)):c=`right`,{textAlign:c,x:l}}_computeLabelArea(){if(this.options.ticks.mirror)return;let e=this.chart,t=this.options.position;if(t===`left`||t===`right`)return{top:0,left:this.left,bottom:e.height,right:this.right};if(t===`top`||t===`bottom`)return{top:this.top,left:0,bottom:this.bottom,right:e.width}}drawBackground(){let{ctx:e,options:{backgroundColor:t},left:n,top:r,width:i,height:a}=this;t&&(e.save(),e.fillStyle=t,e.fillRect(n,r,i,a),e.restore())}getLineWidthForValue(e){let t=this.options.grid;if(!this._isVisible()||!t.display)return 0;let n=this.ticks.findIndex(t=>t.value===e);return n>=0?t.setContext(this.getContext(n)).lineWidth:0}drawGrid(e){let t=this.options.grid,n=this.ctx,r=this._gridLineItems||=this._computeGridLineItems(e),i,a,o=(e,t,r)=>{!r.width||!r.color||(n.save(),n.lineWidth=r.width,n.strokeStyle=r.color,n.setLineDash(r.borderDash||[]),n.lineDashOffset=r.borderDashOffset,n.beginPath(),n.moveTo(e.x,e.y),n.lineTo(t.x,t.y),n.stroke(),n.restore())};if(t.display)for(i=0,a=r.length;i<a;++i){let e=r[i];t.drawOnChartArea&&o({x:e.x1,y:e.y1},{x:e.x2,y:e.y2},e),t.drawTicks&&o({x:e.tx1,y:e.ty1},{x:e.tx2,y:e.ty2},{color:e.tickColor,width:e.tickWidth,borderDash:e.tickBorderDash,borderDashOffset:e.tickBorderDashOffset})}}drawBorder(){let{chart:e,ctx:t,options:{border:n,grid:r}}=this,i=n.setContext(this.getContext()),a=n.display?i.width:0;if(!a)return;let o=r.setContext(this.getContext(0)).lineWidth,s=this._borderValue,c,l,u,d;this.isHorizontal()?(c=Es(e,this.left,a)-a/2,l=Es(e,this.right,o)+o/2,u=d=s):(u=Es(e,this.top,a)-a/2,d=Es(e,this.bottom,o)+o/2,c=l=s),t.save(),t.lineWidth=i.width,t.strokeStyle=i.color,t.beginPath(),t.moveTo(c,u),t.lineTo(l,d),t.stroke(),t.restore()}drawLabels(e){if(!this.options.ticks.display)return;let t=this.ctx,n=this._computeLabelArea();n&&js(t,n);let r=this.getLabelItems(e);for(let e of r){let n=e.options,r=e.font,i=e.label,a=e.textOffset;Is(t,i,0,a,r,n)}n&&Ms(t)}drawTitle(){let{ctx:e,options:{position:t,title:n,reverse:r}}=this;if(!n.display)return;let i=$(n.font),a=Q(n.padding),o=n.align,s=i.lineHeight/2;t===`bottom`||t===`center`||G(t)?(s+=a.bottom,W(n.text)&&(s+=i.lineHeight*(n.text.length-1))):s+=a.top;let{titleX:c,titleY:l,maxWidth:u,rotation:d}=Hu(this,s,t,o);Is(e,n.text,0,0,i,{color:n.color,maxWidth:u,rotation:d,textAlign:Vu(o,t,r),textBaseline:`middle`,translation:[c,l]})}draw(e){this._isVisible()&&(this.drawBackground(),this.drawGrid(e),this.drawBorder(),this.drawTitle(),this.drawLabels(e))}_layers(){let t=this.options,n=t.ticks&&t.ticks.z||0,r=q(t.grid&&t.grid.z,-1),i=q(t.border&&t.border.z,0);return!this._isVisible()||this.draw!==e.prototype.draw?[{z:n,draw:e=>{this.draw(e)}}]:[{z:r,draw:e=>{this.drawBackground(),this.drawGrid(e),this.drawTitle()}},{z:i,draw:()=>{this.drawBorder()}},{z:n,draw:e=>{this.drawLabels(e)}}]}getMatchingVisibleMetas(e){let t=this.chart.getSortedVisibleDatasetMetas(),n=this.axis+`AxisID`,r=[],i,a;for(i=0,a=t.length;i<a;++i){let a=t[i];a[n]===this.id&&(!e||a.type===e)&&r.push(a)}return r}_resolveTickFontOptions(e){return $(this.options.ticks.setContext(this.getContext(e)).font)}_maxDigits(){let e=this._resolveTickFontOptions(0).lineHeight;return(this.isHorizontal()?this.width:this.height)/e}},Wu=class{constructor(e,t,n){this.type=e,this.scope=t,this.override=n,this.items=Object.create(null)}isForType(e){return Object.prototype.isPrototypeOf.call(this.type.prototype,e.prototype)}register(e){let t=Object.getPrototypeOf(e),n;qu(t)&&(n=this.register(t));let r=this.items,i=e.id,a=this.scope+`.`+i;if(!i)throw Error(`class does not have id: `+e);return i in r?a:(r[i]=e,Gu(e,a,n),this.override&&Z.override(e.id,e.overrides),a)}get(e){return this.items[e]}unregister(e){let t=this.items,n=e.id,r=this.scope;n in t&&delete t[n],r&&n in Z[r]&&(delete Z[r][n],this.override&&delete ys[n])}};function Gu(e,t,n){let r=ro(Object.create(null),[n?Z.get(n):{},Z.get(t),e.defaults]);Z.set(t,r),e.defaultRoutes&&Ku(t,e.defaultRoutes),e.descriptors&&Z.describe(t,e.descriptors)}function Ku(e,t){Object.keys(t).forEach(n=>{let r=n.split(`.`),i=r.pop(),a=[e].concat(r).join(`.`),o=t[n].split(`.`),s=o.pop(),c=o.join(`.`);Z.route(a,i,c,s)})}function qu(e){return`id`in e&&`defaults`in e}var Ju=new class{constructor(){this.controllers=new Wu(ll,`datasets`,!0),this.elements=new Wu(Cu,`elements`),this.plugins=new Wu(Object,`plugins`),this.scales=new Wu(Uu,`scales`),this._typedRegistries=[this.controllers,this.scales,this.elements]}add(...e){this._each(`register`,e)}remove(...e){this._each(`unregister`,e)}addControllers(...e){this._each(`register`,e,this.controllers)}addElements(...e){this._each(`register`,e,this.elements)}addPlugins(...e){this._each(`register`,e,this.plugins)}addScales(...e){this._each(`register`,e,this.scales)}getController(e){return this._get(e,this.controllers,`controller`)}getElement(e){return this._get(e,this.elements,`element`)}getPlugin(e){return this._get(e,this.plugins,`plugin`)}getScale(e){return this._get(e,this.scales,`scale`)}removeControllers(...e){this._each(`unregister`,e,this.controllers)}removeElements(...e){this._each(`unregister`,e,this.elements)}removePlugins(...e){this._each(`unregister`,e,this.plugins)}removeScales(...e){this._each(`unregister`,e,this.scales)}_each(e,t,n){[...t].forEach(t=>{let r=n||this._getRegistryForType(t);n||r.isForType(t)||r===this.plugins&&t.id?this._exec(e,r,t):Y(t,t=>{let r=n||this._getRegistryForType(t);this._exec(e,r,t)})})}_exec(e,t,n){let r=uo(e);J(n[`before`+r],[],n),t[e](n),J(n[`after`+r],[],n)}_getRegistryForType(e){for(let t=0;t<this._typedRegistries.length;t++){let n=this._typedRegistries[t];if(n.isForType(e))return n}return this.plugins}_get(e,t,n){let r=t.get(e);if(r===void 0)throw Error(`"`+e+`" is not a registered `+n+`.`);return r}},Yu=class{constructor(){this._init=void 0}notify(e,t,n,r){if(t===`beforeInit`&&(this._init=this._createDescriptors(e,!0),this._notify(this._init,e,`install`)),this._init===void 0)return;let i=r?this._descriptors(e).filter(r):this._descriptors(e),a=this._notify(i,e,t,n);return t===`afterDestroy`&&(this._notify(i,e,`stop`),this._notify(this._init,e,`uninstall`),this._init=void 0),a}_notify(e,t,n,r){r||={};for(let i of e){let e=i.plugin,a=e[n];if(J(a,[t,r,i.options],e)===!1&&r.cancelable)return!1}return!0}invalidate(){U(this._cache)||(this._oldCache=this._cache,this._cache=void 0)}_descriptors(e){if(this._cache)return this._cache;let t=this._cache=this._createDescriptors(e);return this._notifyStateChanges(e),t}_createDescriptors(e,t){let n=e&&e.config,r=q(n.options&&n.options.plugins,{}),i=Xu(n);return r===!1&&!t?[]:Qu(e,i,r,t)}_notifyStateChanges(e){let t=this._oldCache||[],n=this._cache,r=(e,t)=>e.filter(e=>!t.some(t=>e.plugin.id===t.plugin.id));this._notify(r(t,n),e,`stop`),this._notify(r(n,t),e,`start`)}};function Xu(e){let t={},n=[],r=Object.keys(Ju.plugins.items);for(let e=0;e<r.length;e++)n.push(Ju.getPlugin(r[e]));let i=e.plugins||[];for(let e=0;e<i.length;e++){let r=i[e];n.indexOf(r)===-1&&(n.push(r),t[r.id]=!0)}return{plugins:n,localIds:t}}function Zu(e,t){return!t&&e===!1?null:e===!0?{}:e}function Qu(e,{plugins:t,localIds:n},r,i){let a=[],o=e.getContext();for(let s of t){let t=s.id,c=Zu(r[t],i);c!==null&&a.push({plugin:s,options:$u(e.config,{plugin:s,local:n[t]},c,o)})}return a}function $u(e,{plugin:t,local:n},r,i){let a=e.pluginScopeKeys(t),o=e.getOptionScopes(r,a);return n&&t.defaults&&o.push(t.defaults),e.createResolver(o,i,[``],{scriptable:!1,indexable:!1,allKeys:!0})}function ed(e,t){let n=Z.datasets[e]||{};return((t.datasets||{})[e]||{}).indexAxis||t.indexAxis||n.indexAxis||`x`}function td(e,t){let n=e;return e===`_index_`?n=t:e===`_value_`&&(n=t===`x`?`y`:`x`),n}function nd(e,t){return e===t?`_index_`:`_value_`}function rd(e){if(e===`x`||e===`y`||e===`r`)return e}function id(e){if(e===`top`||e===`bottom`)return`x`;if(e===`left`||e===`right`)return`y`}function ad(e,...t){if(rd(e))return e;for(let n of t){let t=n.axis||id(n.position)||e.length>1&&rd(e[0].toLowerCase());if(t)return t}throw Error(`Cannot determine type of '${e}' axis. Please provide 'axis' or 'position' option.`)}function od(e,t,n){if(n[t+`AxisID`]===e)return{axis:t}}function sd(e,t){if(t.data&&t.data.datasets){let n=t.data.datasets.filter(t=>t.xAxisID===e||t.yAxisID===e);if(n.length)return od(e,`x`,n[0])||od(e,`y`,n[0])}return{}}function cd(e,t){let n=ys[e.type]||{scales:{}},r=t.scales||{},i=ed(e.type,t),a=Object.create(null);return Object.keys(r).forEach(t=>{let o=r[t];if(!G(o))return console.error(`Invalid scale configuration for scale: ${t}`);if(o._proxy)return console.warn(`Ignoring resolver passed as options for scale: ${t}`);let s=ad(t,o,sd(t,e),Z.scales[o.type]),c=nd(s,i),l=n.scales||{};a[t]=io(Object.create(null),[{axis:s},o,l[s],l[c]])}),e.data.datasets.forEach(n=>{let i=n.type||e.type,o=n.indexAxis||ed(i,t),s=(ys[i]||{}).scales||{};Object.keys(s).forEach(e=>{let t=td(e,o),i=n[t+`AxisID`]||t;a[i]=a[i]||Object.create(null),io(a[i],[{axis:t},r[i],s[e]])})}),Object.keys(a).forEach(e=>{let t=a[e];io(t,[Z.scales[t.type],Z.scale])}),a}function ld(e){let t=e.options||={};t.plugins=q(t.plugins,{}),t.scales=cd(e,t)}function ud(e){return e||={},e.datasets=e.datasets||[],e.labels=e.labels||[],e}function dd(e){return e||={},e.data=ud(e.data),ld(e),e}var fd=new Map,pd=new Set;function md(e,t){let n=fd.get(e);return n||(n=t(),fd.set(e,n),pd.add(n)),n}var hd=(e,t,n)=>{let r=lo(t,n);r!==void 0&&e.add(r)},gd=class{constructor(e){this._config=dd(e),this._scopeCache=new Map,this._resolverCache=new Map}get platform(){return this._config.platform}get type(){return this._config.type}set type(e){this._config.type=e}get data(){return this._config.data}set data(e){this._config.data=ud(e)}get options(){return this._config.options}set options(e){this._config.options=e}get plugins(){return this._config.plugins}update(){let e=this._config;this.clearCache(),ld(e)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(e){return md(e,()=>[[`datasets.${e}`,``]])}datasetAnimationScopeKeys(e,t){return md(`${e}.transition.${t}`,()=>[[`datasets.${e}.transitions.${t}`,`transitions.${t}`],[`datasets.${e}`,``]])}datasetElementScopeKeys(e,t){return md(`${e}-${t}`,()=>[[`datasets.${e}.elements.${t}`,`datasets.${e}`,`elements.${t}`,``]])}pluginScopeKeys(e){let t=e.id,n=this.type;return md(`${n}-plugin-${t}`,()=>[[`plugins.${t}`,...e.additionalOptionScopes||[]]])}_cachedScopes(e,t){let n=this._scopeCache,r=n.get(e);return(!r||t)&&(r=new Map,n.set(e,r)),r}getOptionScopes(e,t,n){let{options:r,type:i}=this,a=this._cachedScopes(e,n),o=a.get(t);if(o)return o;let s=new Set;t.forEach(t=>{e&&(s.add(e),t.forEach(t=>hd(s,e,t))),t.forEach(e=>hd(s,r,e)),t.forEach(e=>hd(s,ys[i]||{},e)),t.forEach(e=>hd(s,Z,e)),t.forEach(e=>hd(s,bs,e))});let c=Array.from(s);return c.length===0&&c.push(Object.create(null)),pd.has(t)&&a.set(t,c),c}chartOptionScopes(){let{options:e,type:t}=this;return[e,ys[t]||{},Z.datasets[t]||{},{type:t},Z,bs]}resolveNamedOptions(e,t,n,r=[``]){let i={$shared:!0},{resolver:a,subPrefixes:o}=_d(this._resolverCache,e,r),s=a;if(yd(a,t)){i.$shared=!1,n=po(n)?n():n;let t=this.createResolver(e,n,o);s=Ys(a,n,t)}for(let e of t)i[e]=s[e];return i}createResolver(e,t,n=[``],r){let{resolver:i}=_d(this._resolverCache,e,n);return G(t)?Ys(i,t,void 0,r):i}};function _d(e,t,n){let r=e.get(t);r||(r=new Map,e.set(t,r));let i=n.join(),a=r.get(i);return a||(a={resolver:Js(t,n),subPrefixes:n.filter(e=>!e.toLowerCase().includes(`hover`))},r.set(i,a)),a}var vd=e=>G(e)&&Object.getOwnPropertyNames(e).some(t=>po(e[t]));function yd(e,t){let{isScriptable:n,isIndexable:r}=Xs(e);for(let i of t){let t=n(i),a=r(i),o=(a||t)&&e[i];if(t&&(po(o)||vd(o))||a&&W(o))return!0}return!1}var bd=`4.5.1`,xd=[`top`,`bottom`,`left`,`right`,`chartArea`];function Sd(e,t){return e===`top`||e===`bottom`||xd.indexOf(e)===-1&&t===`x`}function Cd(e,t){return function(n,r){return n[e]===r[e]?n[t]-r[t]:n[e]-r[e]}}function wd(e){let t=e.chart,n=t.options.animation;t.notifyPlugins(`afterRender`),J(n&&n.onComplete,[e],t)}function Td(e){let t=e.chart,n=t.options.animation;J(n&&n.onProgress,[e],t)}function Ed(e){return pc()&&typeof e==`string`?e=document.getElementById(e):e&&e.length&&(e=e[0]),e&&e.canvas&&(e=e.canvas),e}var Dd={},Od=e=>{let t=Ed(e);return Object.values(Dd).filter(e=>e.canvas===t).pop()};function kd(e,t,n){let r=Object.keys(e);for(let i of r){let r=+i;if(r>=t){let a=e[i];delete e[i],(n>0||r>t)&&(e[r+n]=a)}}}function Ad(e,t,n,r){return!n||e.type===`mouseout`?null:r?t:e}var jd=class{static defaults=Z;static instances=Dd;static overrides=ys;static registry=Ju;static version=bd;static getChart=Od;static register(...e){Ju.add(...e),Md()}static unregister(...e){Ju.remove(...e),Md()}constructor(e,t){let n=this.config=new gd(t),r=Ed(e),i=Od(r);if(i)throw Error(`Canvas is already in use. Chart with ID '`+i.id+`' must be destroyed before the canvas with ID '`+i.canvas.id+`' can be reused.`);let a=n.createResolver(n.chartOptionScopes(),this.getContext());this.platform=new(n.platform||(Su(r))),this.platform.updateConfig(n);let o=this.platform.acquireContext(r,a.aspectRatio),s=o&&o.canvas,c=s&&s.height,l=s&&s.width;if(this.id=Xa(),this.ctx=o,this.canvas=s,this.width=l,this.height=c,this._options=a,this._aspectRatio=this.aspectRatio,this._layers=[],this._metasets=[],this._stacks=void 0,this.boxes=[],this.currentDevicePixelRatio=void 0,this.chartArea=void 0,this._active=[],this._lastEvent=void 0,this._listeners={},this._responsiveListeners=void 0,this._sortedMetasets=[],this.scales={},this._plugins=new Yu,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=Zo(e=>this.update(e),a.resizeDelay||0),this._dataChanges=[],Dd[this.id]=this,!o||!s){console.error(`Failed to create chart: can't acquire context from the given item`);return}Lc.listen(this,`complete`,wd),Lc.listen(this,`progress`,Td),this._initialize(),this.attached&&this.update()}get aspectRatio(){let{options:{aspectRatio:e,maintainAspectRatio:t},width:n,height:r,_aspectRatio:i}=this;return U(e)?t&&i?i:r?n/r:null:e}get data(){return this.config.data}set data(e){this.config.data=e}get options(){return this._options}set options(e){this.config.options=e}get registry(){return Ju}_initialize(){return this.notifyPlugins(`beforeInit`),this.options.responsive?this.resize():Ec(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins(`afterInit`),this}clear(){return Ds(this.canvas,this.ctx),this}stop(){return Lc.stop(this),this}resize(e,t){Lc.running(this)?this._resizeBeforeDraw={width:e,height:t}:this._resize(e,t)}_resize(e,t){let n=this.options,r=this.canvas,i=n.maintainAspectRatio&&this.aspectRatio,a=this.platform.getMaximumSize(r,e,t,i),o=n.devicePixelRatio||this.platform.getDevicePixelRatio(),s=this.width?`resize`:`attach`;this.width=a.width,this.height=a.height,this._aspectRatio=this.aspectRatio,Ec(this,o,!0)&&(this.notifyPlugins(`resize`,{size:a}),J(n.onResize,[this,a],this),this.attached&&this._doResize(s)&&this.render())}ensureScalesHaveIDs(){Y(this.options.scales||{},(e,t)=>{e.id=t})}buildOrUpdateScales(){let e=this.options,t=e.scales,n=this.scales,r=Object.keys(n).reduce((e,t)=>(e[t]=!1,e),{}),i=[];t&&(i=i.concat(Object.keys(t).map(e=>{let n=t[e],r=ad(e,n),i=r===`r`,a=r===`x`;return{options:n,dposition:i?`chartArea`:a?`bottom`:`left`,dtype:i?`radialLinear`:a?`category`:`linear`}}))),Y(i,t=>{let i=t.options,a=i.id,o=ad(a,i),s=q(i.type,t.dtype);(i.position===void 0||Sd(i.position,o)!==Sd(t.dposition))&&(i.position=t.dposition),r[a]=!0;let c=null;a in n&&n[a].type===s?c=n[a]:(c=new(Ju.getScale(s))({id:a,type:s,ctx:this.ctx,chart:this}),n[c.id]=c),c.init(i,e)}),Y(r,(e,t)=>{e||delete n[t]}),Y(n,e=>{$l.configure(this,e,e.options),$l.addBox(this,e)})}_updateMetasets(){let e=this._metasets,t=this.data.datasets.length,n=e.length;if(e.sort((e,t)=>e.index-t.index),n>t){for(let e=t;e<n;++e)this._destroyDatasetMeta(e);e.splice(t,n-t)}this._sortedMetasets=e.slice(0).sort(Cd(`order`,`index`))}_removeUnreferencedMetasets(){let{_metasets:e,data:{datasets:t}}=this;e.length>t.length&&delete this._stacks,e.forEach((e,n)=>{t.filter(t=>t===e._dataset).length===0&&this._destroyDatasetMeta(n)})}buildOrUpdateControllers(){let e=[],t=this.data.datasets,n,r;for(this._removeUnreferencedMetasets(),n=0,r=t.length;n<r;n++){let r=t[n],i=this.getDatasetMeta(n),a=r.type||this.config.type;if(i.type&&i.type!==a&&(this._destroyDatasetMeta(n),i=this.getDatasetMeta(n)),i.type=a,i.indexAxis=r.indexAxis||ed(a,this.options),i.order=r.order||0,i.index=n,i.label=``+r.label,i.visible=this.isDatasetVisible(n),i.controller)i.controller.updateIndex(n),i.controller.linkScales();else{let t=Ju.getController(a),{datasetElementType:r,dataElementType:o}=Z.datasets[a];Object.assign(t,{dataElementType:Ju.getElement(o),datasetElementType:r&&Ju.getElement(r)}),i.controller=new t(this,n),e.push(i.controller)}}return this._updateMetasets(),e}_resetElements(){Y(this.data.datasets,(e,t)=>{this.getDatasetMeta(t).controller.reset()},this)}reset(){this._resetElements(),this.notifyPlugins(`reset`)}update(e){let t=this.config;t.update();let n=this._options=t.createResolver(t.chartOptionScopes(),this.getContext()),r=this._animationsDisabled=!n.animation;if(this._updateScales(),this._checkEventBindings(),this._updateHiddenIndices(),this._plugins.invalidate(),this.notifyPlugins(`beforeUpdate`,{mode:e,cancelable:!0})===!1)return;let i=this.buildOrUpdateControllers();this.notifyPlugins(`beforeElementsUpdate`);let a=0;for(let e=0,t=this.data.datasets.length;e<t;e++){let{controller:t}=this.getDatasetMeta(e),n=!r&&i.indexOf(t)===-1;t.buildOrUpdateElements(n),a=Math.max(+t.getMaxOverflow(),a)}a=this._minPadding=n.layout.autoPadding?a:0,this._updateLayout(a),r||Y(i,e=>{e.reset()}),this._updateDatasets(e),this.notifyPlugins(`afterUpdate`,{mode:e}),this._layers.sort(Cd(`z`,`_idx`));let{_active:o,_lastEvent:s}=this;s?this._eventHandler(s,!0):o.length&&this._updateHoverStyles(o,o,!0),this.render()}_updateScales(){Y(this.scales,e=>{$l.removeBox(this,e)}),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){let e=this.options;(!mo(new Set(Object.keys(this._listeners)),new Set(e.events))||!!this._responsiveListeners!==e.responsive)&&(this.unbindEvents(),this.bindEvents())}_updateHiddenIndices(){let{_hiddenIndices:e}=this,t=this._getUniformDataChanges()||[];for(let{method:n,start:r,count:i}of t)kd(e,r,n===`_removeElements`?-i:i)}_getUniformDataChanges(){let e=this._dataChanges;if(!e||!e.length)return;this._dataChanges=[];let t=this.data.datasets.length,n=t=>new Set(e.filter(e=>e[0]===t).map((e,t)=>t+`,`+e.splice(1).join(`,`))),r=n(0);for(let e=1;e<t;e++)if(!mo(r,n(e)))return;return Array.from(r).map(e=>e.split(`,`)).map(e=>({method:e[1],start:+e[2],count:+e[3]}))}_updateLayout(e){if(this.notifyPlugins(`beforeLayout`,{cancelable:!0})===!1)return;$l.update(this,this.width,this.height,e);let t=this.chartArea,n=t.width<=0||t.height<=0;this._layers=[],Y(this.boxes,e=>{n&&e.position===`chartArea`||(e.configure&&e.configure(),this._layers.push(...e._layers()))},this),this._layers.forEach((e,t)=>{e._idx=t}),this.notifyPlugins(`afterLayout`)}_updateDatasets(e){if(this.notifyPlugins(`beforeDatasetsUpdate`,{mode:e,cancelable:!0})!==!1){for(let e=0,t=this.data.datasets.length;e<t;++e)this.getDatasetMeta(e).controller.configure();for(let t=0,n=this.data.datasets.length;t<n;++t)this._updateDataset(t,po(e)?e({datasetIndex:t}):e);this.notifyPlugins(`afterDatasetsUpdate`,{mode:e})}}_updateDataset(e,t){let n=this.getDatasetMeta(e),r={meta:n,index:e,mode:t,cancelable:!0};this.notifyPlugins(`beforeDatasetUpdate`,r)!==!1&&(n.controller._update(t),r.cancelable=!1,this.notifyPlugins(`afterDatasetUpdate`,r))}render(){this.notifyPlugins(`beforeRender`,{cancelable:!0})!==!1&&(Lc.has(this)?this.attached&&!Lc.running(this)&&Lc.start(this):(this.draw(),wd({chart:this})))}draw(){let e;if(this._resizeBeforeDraw){let{width:e,height:t}=this._resizeBeforeDraw;this._resizeBeforeDraw=null,this._resize(e,t)}if(this.clear(),this.width<=0||this.height<=0||this.notifyPlugins(`beforeDraw`,{cancelable:!0})===!1)return;let t=this._layers;for(e=0;e<t.length&&t[e].z<=0;++e)t[e].draw(this.chartArea);for(this._drawDatasets();e<t.length;++e)t[e].draw(this.chartArea);this.notifyPlugins(`afterDraw`)}_getSortedDatasetMetas(e){let t=this._sortedMetasets,n=[],r,i;for(r=0,i=t.length;r<i;++r){let i=t[r];(!e||i.visible)&&n.push(i)}return n}getSortedVisibleDatasetMetas(){return this._getSortedDatasetMetas(!0)}_drawDatasets(){if(this.notifyPlugins(`beforeDatasetsDraw`,{cancelable:!0})===!1)return;let e=this.getSortedVisibleDatasetMetas();for(let t=e.length-1;t>=0;--t)this._drawDataset(e[t]);this.notifyPlugins(`afterDatasetsDraw`)}_drawDataset(e){let t=this.ctx,n={meta:e,index:e.index,cancelable:!0},r=Ic(this,e);this.notifyPlugins(`beforeDatasetDraw`,n)!==!1&&(r&&js(t,r),e.controller.draw(),r&&Ms(t),n.cancelable=!1,this.notifyPlugins(`afterDatasetDraw`,n))}isPointInArea(e){return As(e,this.chartArea,this._minPadding)}getElementsAtEventForMode(e,t,n,r){let i=Il.modes[t];return typeof i==`function`?i(this,e,n,r):[]}getDatasetMeta(e){let t=this.data.datasets[e],n=this._metasets,r=n.filter(e=>e&&e._dataset===t).pop();return r||(r={type:null,data:[],dataset:null,controller:null,hidden:null,xAxisID:null,yAxisID:null,order:t&&t.order||0,index:e,_dataset:t,_parsed:[],_sorted:!1},n.push(r)),r}getContext(){return this.$context||=qs(null,{chart:this,type:`chart`})}getVisibleDatasetCount(){return this.getSortedVisibleDatasetMetas().length}isDatasetVisible(e){let t=this.data.datasets[e];if(!t)return!1;let n=this.getDatasetMeta(e);return typeof n.hidden==`boolean`?!n.hidden:!t.hidden}setDatasetVisibility(e,t){let n=this.getDatasetMeta(e);n.hidden=!t}toggleDataVisibility(e){this._hiddenIndices[e]=!this._hiddenIndices[e]}getDataVisibility(e){return!this._hiddenIndices[e]}_updateVisibility(e,t,n){let r=n?`show`:`hide`,i=this.getDatasetMeta(e),a=i.controller._resolveAnimations(void 0,r);fo(t)?(i.data[t].hidden=!n,this.update()):(this.setDatasetVisibility(e,n),a.update(i,{visible:n}),this.update(t=>t.datasetIndex===e?r:void 0))}hide(e,t){this._updateVisibility(e,t,!1)}show(e,t){this._updateVisibility(e,t,!0)}_destroyDatasetMeta(e){let t=this._metasets[e];t&&t.controller&&t.controller._destroy(),delete this._metasets[e]}_stop(){let e,t;for(this.stop(),Lc.remove(this),e=0,t=this.data.datasets.length;e<t;++e)this._destroyDatasetMeta(e)}destroy(){this.notifyPlugins(`beforeDestroy`);let{canvas:e,ctx:t}=this;this._stop(),this.config.clearCache(),e&&(this.unbindEvents(),Ds(e,t),this.platform.releaseContext(t),this.canvas=null,this.ctx=null),delete Dd[this.id],this.notifyPlugins(`afterDestroy`)}toBase64Image(...e){return this.canvas.toDataURL(...e)}bindEvents(){this.bindUserEvents(),this.options.responsive?this.bindResponsiveEvents():this.attached=!0}bindUserEvents(){let e=this._listeners,t=this.platform,n=(n,r)=>{t.addEventListener(this,n,r),e[n]=r},r=(e,t,n)=>{e.offsetX=t,e.offsetY=n,this._eventHandler(e)};Y(this.options.events,e=>n(e,r))}bindResponsiveEvents(){this._responsiveListeners||={};let e=this._responsiveListeners,t=this.platform,n=(n,r)=>{t.addEventListener(this,n,r),e[n]=r},r=(n,r)=>{e[n]&&(t.removeEventListener(this,n,r),delete e[n])},i=(e,t)=>{this.canvas&&this.resize(e,t)},a,o=()=>{r(`attach`,o),this.attached=!0,this.resize(),n(`resize`,i),n(`detach`,a)};a=()=>{this.attached=!1,r(`resize`,i),this._stop(),this._resize(0,0),n(`attach`,o)},t.isAttached(this.canvas)?o():a()}unbindEvents(){Y(this._listeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._listeners={},Y(this._responsiveListeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._responsiveListeners=void 0}updateHoverStyle(e,t,n){let r=n?`set`:`remove`,i,a,o,s;for(t===`dataset`&&(i=this.getDatasetMeta(e[0].datasetIndex),i.controller[`_`+r+`DatasetHoverStyle`]()),o=0,s=e.length;o<s;++o){a=e[o];let t=a&&this.getDatasetMeta(a.datasetIndex).controller;t&&t[r+`HoverStyle`](a.element,a.datasetIndex,a.index)}}getActiveElements(){return this._active||[]}setActiveElements(e){let t=this._active||[],n=e.map(({datasetIndex:e,index:t})=>{let n=this.getDatasetMeta(e);if(!n)throw Error(`No dataset found at index `+e);return{datasetIndex:e,element:n.data[t],index:t}});$a(n,t)||(this._active=n,this._lastEvent=null,this._updateHoverStyles(n,t))}notifyPlugins(e,t,n){return this._plugins.notify(this,e,t,n)}isPluginEnabled(e){return this._plugins._cache.filter(t=>t.plugin.id===e).length===1}_updateHoverStyles(e,t,n){let r=this.options.hover,i=(e,t)=>e.filter(e=>!t.some(t=>e.datasetIndex===t.datasetIndex&&e.index===t.index)),a=i(t,e),o=n?e:i(e,t);a.length&&this.updateHoverStyle(a,r.mode,!1),o.length&&r.mode&&this.updateHoverStyle(o,r.mode,!0)}_eventHandler(e,t){let n={event:e,replay:t,cancelable:!0,inChartArea:this.isPointInArea(e)},r=t=>(t.options.events||this.options.events).includes(e.native.type);if(this.notifyPlugins(`beforeEvent`,n,r)===!1)return;let i=this._handleEvent(e,t,n.inChartArea);return n.cancelable=!1,this.notifyPlugins(`afterEvent`,n,r),(i||n.changed)&&this.render(),this}_handleEvent(e,t,n){let{_active:r=[],options:i}=this,a=t,o=this._getActiveElements(e,r,n,a),s=ho(e),c=Ad(e,this._lastEvent,n,s);n&&(this._lastEvent=null,J(i.onHover,[e,o,this],this),s&&J(i.onClick,[e,o,this],this));let l=!$a(o,r);return(l||t)&&(this._active=o,this._updateHoverStyles(o,r,t)),this._lastEvent=c,l}_getActiveElements(e,t,n,r){if(e.type===`mouseout`)return[];if(!n)return t;let i=this.options.hover;return this.getElementsAtEventForMode(e,i.mode,i,r)}};function Md(){return Y(jd.instances,e=>e._plugins.invalidate())}function Nd(e,t){let{x:n,y:r,base:i,width:a,height:o}=e.getProps([`x`,`y`,`base`,`width`,`height`],t),s,c,l,u,d;return e.horizontal?(d=o/2,s=Math.min(n,i),c=Math.max(n,i),l=r-d,u=r+d):(d=a/2,s=n-d,c=n+d,l=Math.min(r,i),u=Math.max(r,i)),{left:s,top:l,right:c,bottom:u}}function Pd(e,t,n,r){return e?0:Ro(t,n,r)}function Fd(e,t,n){let r=e.options.borderWidth,i=e.borderSkipped,a=Us(r);return{t:Pd(i.top,a.top,0,n),r:Pd(i.right,a.right,0,t),b:Pd(i.bottom,a.bottom,0,n),l:Pd(i.left,a.left,0,t)}}function Id(e,t,n){let{enableBorderRadius:r}=e.getProps([`enableBorderRadius`]),i=e.options.borderRadius,a=Ws(i),o=Math.min(t,n),s=e.borderSkipped,c=r||G(i);return{topLeft:Pd(!c||s.top||s.left,a.topLeft,0,o),topRight:Pd(!c||s.top||s.right,a.topRight,0,o),bottomLeft:Pd(!c||s.bottom||s.left,a.bottomLeft,0,o),bottomRight:Pd(!c||s.bottom||s.right,a.bottomRight,0,o)}}function Ld(e){let t=Nd(e),n=t.right-t.left,r=t.bottom-t.top,i=Fd(e,n/2,r/2),a=Id(e,n/2,r/2);return{outer:{x:t.left,y:t.top,w:n,h:r,radius:a},inner:{x:t.left+i.l,y:t.top+i.t,w:n-i.l-i.r,h:r-i.t-i.b,radius:{topLeft:Math.max(0,a.topLeft-Math.max(i.t,i.l)),topRight:Math.max(0,a.topRight-Math.max(i.t,i.r)),bottomLeft:Math.max(0,a.bottomLeft-Math.max(i.b,i.l)),bottomRight:Math.max(0,a.bottomRight-Math.max(i.b,i.r))}}}}function Rd(e,t,n,r){let i=t===null,a=n===null,o=e&&!(i&&a)&&Nd(e,r);return o&&(i||Bo(t,o.left,o.right))&&(a||Bo(n,o.top,o.bottom))}function zd(e){return e.topLeft||e.topRight||e.bottomLeft||e.bottomRight}function Bd(e,t){e.rect(t.x,t.y,t.w,t.h)}function Vd(e,t,n={}){let r=e.x===n.x?0:-t,i=e.y===n.y?0:-t,a=(e.x+e.w===n.x+n.w?0:t)-r,o=(e.y+e.h===n.y+n.h?0:t)-i;return{x:e.x+r,y:e.y+i,w:e.w+a,h:e.h+o,radius:e.radius}}var Hd=class extends Cu{static id=`bar`;static defaults={borderSkipped:`start`,borderWidth:0,borderRadius:0,inflateAmount:`auto`,pointStyle:void 0};static defaultRoutes={backgroundColor:`backgroundColor`,borderColor:`borderColor`};constructor(e){super(),this.options=void 0,this.horizontal=void 0,this.base=void 0,this.width=void 0,this.height=void 0,this.inflateAmount=void 0,e&&Object.assign(this,e)}draw(e){let{inflateAmount:t,options:{borderColor:n,backgroundColor:r}}=this,{inner:i,outer:a}=Ld(this),o=zd(a.radius)?Ls:Bd;e.save(),(a.w!==i.w||a.h!==i.h)&&(e.beginPath(),o(e,Vd(a,t,i)),e.clip(),o(e,Vd(i,-t,a)),e.fillStyle=n,e.fill(`evenodd`)),e.beginPath(),o(e,Vd(i,t)),e.fillStyle=r,e.fill(),e.restore()}inRange(e,t,n){return Rd(this,e,t,n)}inXRange(e,t){return Rd(this,e,null,t)}inYRange(e,t){return Rd(this,null,e,t)}getCenterPoint(e){let{x:t,y:n,base:r,horizontal:i}=this.getProps([`x`,`y`,`base`,`horizontal`],e);return{x:i?(t+r)/2:t,y:i?n:(n+r)/2}}getRange(e){return e===`x`?this.width/2:this.height/2}},Ud=(e,t)=>{let{boxHeight:n=t,boxWidth:r=t}=e;return e.usePointStyle&&(n=Math.min(n,t),r=e.pointStyleWidth||Math.min(r,t)),{boxWidth:r,boxHeight:n,itemHeight:Math.max(t,n)}},Wd=(e,t)=>e!==null&&t!==null&&e.datasetIndex===t.datasetIndex&&e.index===t.index,Gd=class extends Cu{constructor(e){super(),this._added=!1,this.legendHitBoxes=[],this._hoveredItem=null,this.doughnutMode=!1,this.chart=e.chart,this.options=e.options,this.ctx=e.ctx,this.legendItems=void 0,this.columnSizes=void 0,this.lineWidths=void 0,this.maxHeight=void 0,this.maxWidth=void 0,this.top=void 0,this.bottom=void 0,this.left=void 0,this.right=void 0,this.height=void 0,this.width=void 0,this._margins=void 0,this.position=void 0,this.weight=void 0,this.fullSize=void 0}update(e,t,n){this.maxWidth=e,this.maxHeight=t,this._margins=n,this.setDimensions(),this.buildLabels(),this.fit()}setDimensions(){this.isHorizontal()?(this.width=this.maxWidth,this.left=this._margins.left,this.right=this.width):(this.height=this.maxHeight,this.top=this._margins.top,this.bottom=this.height)}buildLabels(){let e=this.options.labels||{},t=J(e.generateLabels,[this.chart],this)||[];e.filter&&(t=t.filter(t=>e.filter(t,this.chart.data))),e.sort&&(t=t.sort((t,n)=>e.sort(t,n,this.chart.data))),this.options.reverse&&t.reverse(),this.legendItems=t}fit(){let{options:e,ctx:t}=this;if(!e.display){this.width=this.height=0;return}let n=e.labels,r=$(n.font),i=r.size,a=this._computeTitleHeight(),{boxWidth:o,itemHeight:s}=Ud(n,i),c,l;t.font=r.string,this.isHorizontal()?(c=this.maxWidth,l=this._fitRows(a,i,o,s)+10):(l=this.maxHeight,c=this._fitCols(a,r,o,s)+10),this.width=Math.min(c,e.maxWidth||this.maxWidth),this.height=Math.min(l,e.maxHeight||this.maxHeight)}_fitRows(e,t,n,r){let{ctx:i,maxWidth:a,options:{labels:{padding:o}}}=this,s=this.legendHitBoxes=[],c=this.lineWidths=[0],l=r+o,u=e;i.textAlign=`left`,i.textBaseline=`middle`;let d=-1,f=-l;return this.legendItems.forEach((e,p)=>{let m=n+t/2+i.measureText(e.text).width;(p===0||c[c.length-1]+m+2*o>a)&&(u+=l,c[c.length-(p>0?0:1)]=0,f+=l,d++),s[p]={left:0,top:f,row:d,width:m,height:r},c[c.length-1]+=m+o}),u}_fitCols(e,t,n,r){let{ctx:i,maxHeight:a,options:{labels:{padding:o}}}=this,s=this.legendHitBoxes=[],c=this.columnSizes=[],l=a-e,u=o,d=0,f=0,p=0,m=0;return this.legendItems.forEach((e,a)=>{let{itemWidth:h,itemHeight:g}=Kd(n,t,i,e,r);a>0&&f+g+2*o>l&&(u+=d+o,c.push({width:d,height:f}),p+=d+o,m++,d=f=0),s[a]={left:p,top:f,col:m,width:h,height:g},d=Math.max(d,h),f+=g+o}),u+=d,c.push({width:d,height:f}),u}adjustHitBoxes(){if(!this.options.display)return;let e=this._computeTitleHeight(),{legendHitBoxes:t,options:{align:n,labels:{padding:r},rtl:i}}=this,a=jc(i,this.left,this.width);if(this.isHorizontal()){let i=0,o=$o(n,this.left+r,this.right-this.lineWidths[i]);for(let s of t)i!==s.row&&(i=s.row,o=$o(n,this.left+r,this.right-this.lineWidths[i])),s.top+=this.top+e+r,s.left=a.leftForLtr(a.x(o),s.width),o+=s.width+r}else{let i=0,o=$o(n,this.top+e+r,this.bottom-this.columnSizes[i].height);for(let s of t)s.col!==i&&(i=s.col,o=$o(n,this.top+e+r,this.bottom-this.columnSizes[i].height)),s.top=o,s.left+=this.left+r,s.left=a.leftForLtr(a.x(s.left),s.width),o+=s.height+r}}isHorizontal(){return this.options.position===`top`||this.options.position===`bottom`}draw(){if(this.options.display){let e=this.ctx;js(e,this),this._draw(),Ms(e)}}_draw(){let{options:e,columnSizes:t,lineWidths:n,ctx:r}=this,{align:i,labels:a}=e,o=Z.color,s=jc(e.rtl,this.left,this.width),c=$(a.font),{padding:l}=a,u=c.size,d=u/2,f;this.drawTitle(),r.textAlign=s.textAlign(`left`),r.textBaseline=`middle`,r.lineWidth=.5,r.font=c.string;let{boxWidth:p,boxHeight:m,itemHeight:h}=Ud(a,u),g=function(e,t,n){if(isNaN(p)||p<=0||isNaN(m)||m<0)return;r.save();let i=q(n.lineWidth,1);if(r.fillStyle=q(n.fillStyle,o),r.lineCap=q(n.lineCap,`butt`),r.lineDashOffset=q(n.lineDashOffset,0),r.lineJoin=q(n.lineJoin,`miter`),r.lineWidth=i,r.strokeStyle=q(n.strokeStyle,o),r.setLineDash(q(n.lineDash,[])),a.usePointStyle){let o={radius:m*Math.SQRT2/2,pointStyle:n.pointStyle,rotation:n.rotation,borderWidth:i},c=s.xPlus(e,p/2),l=t+d;ks(r,o,c,l,a.pointStyleWidth&&p)}else{let a=t+Math.max((u-m)/2,0),o=s.leftForLtr(e,p),c=Ws(n.borderRadius);r.beginPath(),Object.values(c).some(e=>e!==0)?Ls(r,{x:o,y:a,w:p,h:m,radius:c}):r.rect(o,a,p,m),r.fill(),i!==0&&r.stroke()}r.restore()},_=function(e,t,n){Is(r,n.text,e,t+h/2,c,{strikethrough:n.hidden,textAlign:s.textAlign(n.textAlign)})},v=this.isHorizontal(),y=this._computeTitleHeight();f=v?{x:$o(i,this.left+l,this.right-n[0]),y:this.top+l+y,line:0}:{x:this.left+l,y:$o(i,this.top+y+l,this.bottom-t[0].height),line:0},Mc(this.ctx,e.textDirection);let b=h+l;this.legendItems.forEach((o,u)=>{r.strokeStyle=o.fontColor,r.fillStyle=o.fontColor;let m=r.measureText(o.text).width,h=s.textAlign(o.textAlign||=a.textAlign),x=p+d+m,S=f.x,C=f.y;s.setWidth(this.width),v?u>0&&S+x+l>this.right&&(C=f.y+=b,f.line++,S=f.x=$o(i,this.left+l,this.right-n[f.line])):u>0&&C+b>this.bottom&&(S=f.x=S+t[f.line].width+l,f.line++,C=f.y=$o(i,this.top+y+l,this.bottom-t[f.line].height));let w=s.x(S);if(g(w,C,o),S=es(h,S+p+d,v?S+x:this.right,e.rtl),_(s.x(S),C,o),v)f.x+=x+l;else if(typeof o.text!=`string`){let e=c.lineHeight;f.y+=Yd(o,e)+l}else f.y+=b}),Nc(this.ctx,e.textDirection)}drawTitle(){let e=this.options,t=e.title,n=$(t.font),r=Q(t.padding);if(!t.display)return;let i=jc(e.rtl,this.left,this.width),a=this.ctx,o=t.position,s=n.size/2,c=r.top+s,l,u=this.left,d=this.width;if(this.isHorizontal())d=Math.max(...this.lineWidths),l=this.top+c,u=$o(e.align,u,this.right-d);else{let t=this.columnSizes.reduce((e,t)=>Math.max(e,t.height),0);l=c+$o(e.align,this.top,this.bottom-t-e.labels.padding-this._computeTitleHeight())}let f=$o(o,u,u+d);a.textAlign=i.textAlign(Qo(o)),a.textBaseline=`middle`,a.strokeStyle=t.color,a.fillStyle=t.color,a.font=n.string,Is(a,t.text,f,l,n)}_computeTitleHeight(){let e=this.options.title,t=$(e.font),n=Q(e.padding);return e.display?t.lineHeight+n.height:0}_getLegendItemAt(e,t){let n,r,i;if(Bo(e,this.left,this.right)&&Bo(t,this.top,this.bottom)){for(i=this.legendHitBoxes,n=0;n<i.length;++n)if(r=i[n],Bo(e,r.left,r.left+r.width)&&Bo(t,r.top,r.top+r.height))return this.legendItems[n]}return null}handleEvent(e){let t=this.options;if(!Xd(e.type,t))return;let n=this._getLegendItemAt(e.x,e.y);if(e.type===`mousemove`||e.type===`mouseout`){let r=this._hoveredItem,i=Wd(r,n);r&&!i&&J(t.onLeave,[e,r,this],this),this._hoveredItem=n,n&&!i&&J(t.onHover,[e,n,this],this)}else n&&J(t.onClick,[e,n,this],this)}};function Kd(e,t,n,r,i){return{itemWidth:qd(r,e,t,n),itemHeight:Jd(i,r,t.lineHeight)}}function qd(e,t,n,r){let i=e.text;return i&&typeof i!=`string`&&(i=i.reduce((e,t)=>e.length>t.length?e:t)),t+n.size/2+r.measureText(i).width}function Jd(e,t,n){let r=e;return typeof t.text!=`string`&&(r=Yd(t,n)),r}function Yd(e,t){return t*(e.text?e.text.length:0)}function Xd(e,t){return!!((e===`mousemove`||e===`mouseout`)&&(t.onHover||t.onLeave)||t.onClick&&(e===`click`||e===`mouseup`))}var Zd={id:`legend`,_element:Gd,start(e,t,n){let r=e.legend=new Gd({ctx:e.ctx,options:n,chart:e});$l.configure(e,r,n),$l.addBox(e,r)},stop(e){$l.removeBox(e,e.legend),delete e.legend},beforeUpdate(e,t,n){let r=e.legend;$l.configure(e,r,n),r.options=n},afterUpdate(e){let t=e.legend;t.buildLabels(),t.adjustHitBoxes()},afterEvent(e,t){t.replay||e.legend.handleEvent(t.event)},defaults:{display:!0,position:`top`,align:`center`,fullSize:!0,reverse:!1,weight:1e3,onClick(e,t,n){let r=t.datasetIndex,i=n.chart;i.isDatasetVisible(r)?(i.hide(r),t.hidden=!0):(i.show(r),t.hidden=!1)},onHover:null,onLeave:null,labels:{color:e=>e.chart.options.color,boxWidth:40,padding:10,generateLabels(e){let t=e.data.datasets,{labels:{usePointStyle:n,pointStyle:r,textAlign:i,color:a,useBorderRadius:o,borderRadius:s}}=e.legend.options;return e._getSortedDatasetMetas().map(e=>{let c=e.controller.getStyle(n?0:void 0),l=Q(c.borderWidth);return{text:t[e.index].label,fillStyle:c.backgroundColor,fontColor:a,hidden:!e.visible,lineCap:c.borderCapStyle,lineDash:c.borderDash,lineDashOffset:c.borderDashOffset,lineJoin:c.borderJoinStyle,lineWidth:(l.width+l.height)/4,strokeStyle:c.borderColor,pointStyle:r||c.pointStyle,rotation:c.rotation,textAlign:i||c.textAlign,borderRadius:o&&(s||c.borderRadius),datasetIndex:e.index}},this)}},title:{color:e=>e.chart.options.color,display:!1,position:`center`,text:``}},descriptors:{_scriptable:e=>!e.startsWith(`on`),labels:{_scriptable:e=>![`generateLabels`,`filter`,`sort`].includes(e)}}},Qd={average(e){if(!e.length)return!1;let t,n,r=new Set,i=0,a=0;for(t=0,n=e.length;t<n;++t){let n=e[t].element;if(n&&n.hasValue()){let e=n.tooltipPosition();r.add(e.x),i+=e.y,++a}}return a===0||r.size===0?!1:{x:[...r].reduce((e,t)=>e+t)/r.size,y:i/a}},nearest(e,t){if(!e.length)return!1;let n=t.x,r=t.y,i=1/0,a,o,s;for(a=0,o=e.length;a<o;++a){let n=e[a].element;if(n&&n.hasValue()){let e=Fo(t,n.getCenterPoint());e<i&&(i=e,s=n)}}if(s){let e=s.tooltipPosition();n=e.x,r=e.y}return{x:n,y:r}}};function $d(e,t){return t&&(W(t)?Array.prototype.push.apply(e,t):e.push(t)),e}function ef(e){return(typeof e==`string`||e instanceof String)&&e.indexOf(`
`)>-1?e.split(`
`):e}function tf(e,t){let{element:n,datasetIndex:r,index:i}=t,a=e.getDatasetMeta(r).controller,{label:o,value:s}=a.getLabelAndValue(i);return{chart:e,label:o,parsed:a.getParsed(i),raw:e.data.datasets[r].data[i],formattedValue:s,dataset:a.getDataset(),dataIndex:i,datasetIndex:r,element:n}}function nf(e,t){let n=e.chart.ctx,{body:r,footer:i,title:a}=e,{boxWidth:o,boxHeight:s}=t,c=$(t.bodyFont),l=$(t.titleFont),u=$(t.footerFont),d=a.length,f=i.length,p=r.length,m=Q(t.padding),h=m.height,g=0,_=r.reduce((e,t)=>e+t.before.length+t.lines.length+t.after.length,0);if(_+=e.beforeBody.length+e.afterBody.length,d&&(h+=d*l.lineHeight+(d-1)*t.titleSpacing+t.titleMarginBottom),_){let e=t.displayColors?Math.max(s,c.lineHeight):c.lineHeight;h+=p*e+(_-p)*c.lineHeight+(_-1)*t.bodySpacing}f&&(h+=t.footerMarginTop+f*u.lineHeight+(f-1)*t.footerSpacing);let v=0,y=function(e){g=Math.max(g,n.measureText(e).width+v)};return n.save(),n.font=l.string,Y(e.title,y),n.font=c.string,Y(e.beforeBody.concat(e.afterBody),y),v=t.displayColors?o+2+t.boxPadding:0,Y(r,e=>{Y(e.before,y),Y(e.lines,y),Y(e.after,y)}),v=0,n.font=u.string,Y(e.footer,y),n.restore(),g+=m.width,{width:g,height:h}}function rf(e,t){let{y:n,height:r}=t;return n<r/2?`top`:n>e.height-r/2?`bottom`:`center`}function af(e,t,n,r){let{x:i,width:a}=r,o=n.caretSize+n.caretPadding;if(e===`left`&&i+a+o>t.width||e===`right`&&i-a-o<0)return!0}function of(e,t,n,r){let{x:i,width:a}=n,{width:o,chartArea:{left:s,right:c}}=e,l=`center`;return r===`center`?l=i<=(s+c)/2?`left`:`right`:i<=a/2?l=`left`:i>=o-a/2&&(l=`right`),af(l,e,t,n)&&(l=`center`),l}function sf(e,t,n){let r=n.yAlign||t.yAlign||rf(e,n);return{xAlign:n.xAlign||t.xAlign||of(e,t,n,r),yAlign:r}}function cf(e,t){let{x:n,width:r}=e;return t===`right`?n-=r:t===`center`&&(n-=r/2),n}function lf(e,t,n){let{y:r,height:i}=e;return t===`top`?r+=n:r-=t===`bottom`?i+n:i/2,r}function uf(e,t,n,r){let{caretSize:i,caretPadding:a,cornerRadius:o}=e,{xAlign:s,yAlign:c}=n,l=i+a,{topLeft:u,topRight:d,bottomLeft:f,bottomRight:p}=Ws(o),m=cf(t,s),h=lf(t,c,l);return c===`center`?s===`left`?m+=l:s===`right`&&(m-=l):s===`left`?m-=Math.max(u,f)+i:s===`right`&&(m+=Math.max(d,p)+i),{x:Ro(m,0,r.width-t.width),y:Ro(h,0,r.height-t.height)}}function df(e,t,n){let r=Q(n.padding);return t===`center`?e.x+e.width/2:t===`right`?e.x+e.width-r.right:e.x+r.left}function ff(e){return $d([],ef(e))}function pf(e,t,n){return qs(e,{tooltip:t,tooltipItems:n,type:`tooltip`})}function mf(e,t){let n=t&&t.dataset&&t.dataset.tooltip&&t.dataset.tooltip.callbacks;return n?e.override(n):e}var hf={beforeTitle:Ya,title(e){if(e.length>0){let t=e[0],n=t.chart.data.labels,r=n?n.length:0;if(this&&this.options&&this.options.mode===`dataset`)return t.dataset.label||``;if(t.label)return t.label;if(r>0&&t.dataIndex<r)return n[t.dataIndex]}return``},afterTitle:Ya,beforeBody:Ya,beforeLabel:Ya,label(e){if(this&&this.options&&this.options.mode===`dataset`)return e.label+`: `+e.formattedValue||e.formattedValue;let t=e.dataset.label||``;t&&(t+=`: `);let n=e.formattedValue;return U(n)||(t+=n),t},labelColor(e){let t=e.chart.getDatasetMeta(e.datasetIndex).controller.getStyle(e.dataIndex);return{borderColor:t.borderColor,backgroundColor:t.backgroundColor,borderWidth:t.borderWidth,borderDash:t.borderDash,borderDashOffset:t.borderDashOffset,borderRadius:0}},labelTextColor(){return this.options.bodyColor},labelPointStyle(e){let t=e.chart.getDatasetMeta(e.datasetIndex).controller.getStyle(e.dataIndex);return{pointStyle:t.pointStyle,rotation:t.rotation}},afterLabel:Ya,afterBody:Ya,beforeFooter:Ya,footer:Ya,afterFooter:Ya};function gf(e,t,n,r){let i=e[t].call(n,r);return i===void 0?hf[t].call(n,r):i}var _f=class extends Cu{static positioners=Qd;constructor(e){super(),this.opacity=0,this._active=[],this._eventPosition=void 0,this._size=void 0,this._cachedAnimations=void 0,this._tooltipItems=[],this.$animations=void 0,this.$context=void 0,this.chart=e.chart,this.options=e.options,this.dataPoints=void 0,this.title=void 0,this.beforeBody=void 0,this.body=void 0,this.afterBody=void 0,this.footer=void 0,this.xAlign=void 0,this.yAlign=void 0,this.x=void 0,this.y=void 0,this.height=void 0,this.width=void 0,this.caretX=void 0,this.caretY=void 0,this.labelColors=void 0,this.labelPointStyles=void 0,this.labelTextColors=void 0}initialize(e){this.options=e,this._cachedAnimations=void 0,this.$context=void 0}_resolveAnimations(){let e=this._cachedAnimations;if(e)return e;let t=this.chart,n=this.options.setContext(this.getContext()),r=n.enabled&&t.options.animation&&n.animations,i=new Vc(this.chart,r);return r._cacheable&&(this._cachedAnimations=Object.freeze(i)),i}getContext(){return this.$context||=pf(this.chart.getContext(),this,this._tooltipItems)}getTitle(e,t){let{callbacks:n}=t,r=gf(n,`beforeTitle`,this,e),i=gf(n,`title`,this,e),a=gf(n,`afterTitle`,this,e),o=[];return o=$d(o,ef(r)),o=$d(o,ef(i)),o=$d(o,ef(a)),o}getBeforeBody(e,t){return ff(gf(t.callbacks,`beforeBody`,this,e))}getBody(e,t){let{callbacks:n}=t,r=[];return Y(e,e=>{let t={before:[],lines:[],after:[]},i=mf(n,e);$d(t.before,ef(gf(i,`beforeLabel`,this,e))),$d(t.lines,gf(i,`label`,this,e)),$d(t.after,ef(gf(i,`afterLabel`,this,e))),r.push(t)}),r}getAfterBody(e,t){return ff(gf(t.callbacks,`afterBody`,this,e))}getFooter(e,t){let{callbacks:n}=t,r=gf(n,`beforeFooter`,this,e),i=gf(n,`footer`,this,e),a=gf(n,`afterFooter`,this,e),o=[];return o=$d(o,ef(r)),o=$d(o,ef(i)),o=$d(o,ef(a)),o}_createItems(e){let t=this._active,n=this.chart.data,r=[],i=[],a=[],o=[],s,c;for(s=0,c=t.length;s<c;++s)o.push(tf(this.chart,t[s]));return e.filter&&(o=o.filter((t,r,i)=>e.filter(t,r,i,n))),e.itemSort&&(o=o.sort((t,r)=>e.itemSort(t,r,n))),Y(o,t=>{let n=mf(e.callbacks,t);r.push(gf(n,`labelColor`,this,t)),i.push(gf(n,`labelPointStyle`,this,t)),a.push(gf(n,`labelTextColor`,this,t))}),this.labelColors=r,this.labelPointStyles=i,this.labelTextColors=a,this.dataPoints=o,o}update(e,t){let n=this.options.setContext(this.getContext()),r=this._active,i,a=[];if(!r.length)this.opacity!==0&&(i={opacity:0});else{let e=Qd[n.position].call(this,r,this._eventPosition);a=this._createItems(n),this.title=this.getTitle(a,n),this.beforeBody=this.getBeforeBody(a,n),this.body=this.getBody(a,n),this.afterBody=this.getAfterBody(a,n),this.footer=this.getFooter(a,n);let t=this._size=nf(this,n),o=Object.assign({},e,t),s=sf(this.chart,n,o),c=uf(n,o,s,this.chart);this.xAlign=s.xAlign,this.yAlign=s.yAlign,i={opacity:1,x:c.x,y:c.y,width:t.width,height:t.height,caretX:e.x,caretY:e.y}}this._tooltipItems=a,this.$context=void 0,i&&this._resolveAnimations().update(this,i),e&&n.external&&n.external.call(this,{chart:this.chart,tooltip:this,replay:t})}drawCaret(e,t,n,r){let i=this.getCaretPosition(e,n,r);t.lineTo(i.x1,i.y1),t.lineTo(i.x2,i.y2),t.lineTo(i.x3,i.y3)}getCaretPosition(e,t,n){let{xAlign:r,yAlign:i}=this,{caretSize:a,cornerRadius:o}=n,{topLeft:s,topRight:c,bottomLeft:l,bottomRight:u}=Ws(o),{x:d,y:f}=e,{width:p,height:m}=t,h,g,_,v,y,b;return i===`center`?(y=f+m/2,r===`left`?(h=d,g=h-a,v=y+a,b=y-a):(h=d+p,g=h+a,v=y-a,b=y+a),_=h):(g=r===`left`?d+Math.max(s,l)+a:r===`right`?d+p-Math.max(c,u)-a:this.caretX,i===`top`?(v=f,y=v-a,h=g-a,_=g+a):(v=f+m,y=v+a,h=g+a,_=g-a),b=v),{x1:h,x2:g,x3:_,y1:v,y2:y,y3:b}}drawTitle(e,t,n){let r=this.title,i=r.length,a,o,s;if(i){let c=jc(n.rtl,this.x,this.width);for(e.x=df(this,n.titleAlign,n),t.textAlign=c.textAlign(n.titleAlign),t.textBaseline=`middle`,a=$(n.titleFont),o=n.titleSpacing,t.fillStyle=n.titleColor,t.font=a.string,s=0;s<i;++s)t.fillText(r[s],c.x(e.x),e.y+a.lineHeight/2),e.y+=a.lineHeight+o,s+1===i&&(e.y+=n.titleMarginBottom-o)}}_drawColorBox(e,t,n,r,i){let a=this.labelColors[n],o=this.labelPointStyles[n],{boxHeight:s,boxWidth:c}=i,l=$(i.bodyFont),u=df(this,`left`,i),d=r.x(u),f=s<l.lineHeight?(l.lineHeight-s)/2:0,p=t.y+f;if(i.usePointStyle){let t={radius:Math.min(c,s)/2,pointStyle:o.pointStyle,rotation:o.rotation,borderWidth:1},n=r.leftForLtr(d,c)+c/2,l=p+s/2;e.strokeStyle=i.multiKeyBackground,e.fillStyle=i.multiKeyBackground,Os(e,t,n,l),e.strokeStyle=a.borderColor,e.fillStyle=a.backgroundColor,Os(e,t,n,l)}else{e.lineWidth=G(a.borderWidth)?Math.max(...Object.values(a.borderWidth)):a.borderWidth||1,e.strokeStyle=a.borderColor,e.setLineDash(a.borderDash||[]),e.lineDashOffset=a.borderDashOffset||0;let t=r.leftForLtr(d,c),n=r.leftForLtr(r.xPlus(d,1),c-2),o=Ws(a.borderRadius);Object.values(o).some(e=>e!==0)?(e.beginPath(),e.fillStyle=i.multiKeyBackground,Ls(e,{x:t,y:p,w:c,h:s,radius:o}),e.fill(),e.stroke(),e.fillStyle=a.backgroundColor,e.beginPath(),Ls(e,{x:n,y:p+1,w:c-2,h:s-2,radius:o}),e.fill()):(e.fillStyle=i.multiKeyBackground,e.fillRect(t,p,c,s),e.strokeRect(t,p,c,s),e.fillStyle=a.backgroundColor,e.fillRect(n,p+1,c-2,s-2))}e.fillStyle=this.labelTextColors[n]}drawBody(e,t,n){let{body:r}=this,{bodySpacing:i,bodyAlign:a,displayColors:o,boxHeight:s,boxWidth:c,boxPadding:l}=n,u=$(n.bodyFont),d=u.lineHeight,f=0,p=jc(n.rtl,this.x,this.width),m=function(n){t.fillText(n,p.x(e.x+f),e.y+d/2),e.y+=d+i},h=p.textAlign(a),g,_,v,y,b,x,S;for(t.textAlign=a,t.textBaseline=`middle`,t.font=u.string,e.x=df(this,h,n),t.fillStyle=n.bodyColor,Y(this.beforeBody,m),f=o&&h!==`right`?a===`center`?c/2+l:c+2+l:0,y=0,x=r.length;y<x;++y){for(g=r[y],_=this.labelTextColors[y],t.fillStyle=_,Y(g.before,m),v=g.lines,o&&v.length&&(this._drawColorBox(t,e,y,p,n),d=Math.max(u.lineHeight,s)),b=0,S=v.length;b<S;++b)m(v[b]),d=u.lineHeight;Y(g.after,m)}f=0,d=u.lineHeight,Y(this.afterBody,m),e.y-=i}drawFooter(e,t,n){let r=this.footer,i=r.length,a,o;if(i){let s=jc(n.rtl,this.x,this.width);for(e.x=df(this,n.footerAlign,n),e.y+=n.footerMarginTop,t.textAlign=s.textAlign(n.footerAlign),t.textBaseline=`middle`,a=$(n.footerFont),t.fillStyle=n.footerColor,t.font=a.string,o=0;o<i;++o)t.fillText(r[o],s.x(e.x),e.y+a.lineHeight/2),e.y+=a.lineHeight+n.footerSpacing}}drawBackground(e,t,n,r){let{xAlign:i,yAlign:a}=this,{x:o,y:s}=e,{width:c,height:l}=n,{topLeft:u,topRight:d,bottomLeft:f,bottomRight:p}=Ws(r.cornerRadius);t.fillStyle=r.backgroundColor,t.strokeStyle=r.borderColor,t.lineWidth=r.borderWidth,t.beginPath(),t.moveTo(o+u,s),a===`top`&&this.drawCaret(e,t,n,r),t.lineTo(o+c-d,s),t.quadraticCurveTo(o+c,s,o+c,s+d),a===`center`&&i===`right`&&this.drawCaret(e,t,n,r),t.lineTo(o+c,s+l-p),t.quadraticCurveTo(o+c,s+l,o+c-p,s+l),a===`bottom`&&this.drawCaret(e,t,n,r),t.lineTo(o+f,s+l),t.quadraticCurveTo(o,s+l,o,s+l-f),a===`center`&&i===`left`&&this.drawCaret(e,t,n,r),t.lineTo(o,s+u),t.quadraticCurveTo(o,s,o+u,s),t.closePath(),t.fill(),r.borderWidth>0&&t.stroke()}_updateAnimationTarget(e){let t=this.chart,n=this.$animations,r=n&&n.x,i=n&&n.y;if(r||i){let n=Qd[e.position].call(this,this._active,this._eventPosition);if(!n)return;let a=this._size=nf(this,e),o=Object.assign({},n,this._size),s=sf(t,e,o),c=uf(e,o,s,t);(r._to!==c.x||i._to!==c.y)&&(this.xAlign=s.xAlign,this.yAlign=s.yAlign,this.width=a.width,this.height=a.height,this.caretX=n.x,this.caretY=n.y,this._resolveAnimations().update(this,c))}}_willRender(){return!!this.opacity}draw(e){let t=this.options.setContext(this.getContext()),n=this.opacity;if(!n)return;this._updateAnimationTarget(t);let r={width:this.width,height:this.height},i={x:this.x,y:this.y};n=Math.abs(n)<.001?0:n;let a=Q(t.padding),o=this.title.length||this.beforeBody.length||this.body.length||this.afterBody.length||this.footer.length;t.enabled&&o&&(e.save(),e.globalAlpha=n,this.drawBackground(i,e,r,t),Mc(e,t.textDirection),i.y+=a.top,this.drawTitle(i,e,t),this.drawBody(i,e,t),this.drawFooter(i,e,t),Nc(e,t.textDirection),e.restore())}getActiveElements(){return this._active||[]}setActiveElements(e,t){let n=this._active,r=e.map(({datasetIndex:e,index:t})=>{let n=this.chart.getDatasetMeta(e);if(!n)throw Error(`Cannot find a dataset at index `+e);return{datasetIndex:e,element:n.data[t],index:t}}),i=!$a(n,r),a=this._positionChanged(r,t);(i||a)&&(this._active=r,this._eventPosition=t,this._ignoreReplayEvents=!0,this.update(!0))}handleEvent(e,t,n=!0){if(t&&this._ignoreReplayEvents)return!1;this._ignoreReplayEvents=!1;let r=this.options,i=this._active||[],a=this._getActiveElements(e,i,t,n),o=this._positionChanged(a,e),s=t||!$a(a,i)||o;return s&&(this._active=a,(r.enabled||r.external)&&(this._eventPosition={x:e.x,y:e.y},this.update(!0,t))),s}_getActiveElements(e,t,n,r){let i=this.options;if(e.type===`mouseout`)return[];if(!r)return t.filter(e=>this.chart.data.datasets[e.datasetIndex]&&this.chart.getDatasetMeta(e.datasetIndex).controller.getParsed(e.index)!==void 0);let a=this.chart.getElementsAtEventForMode(e,i.mode,i,n);return i.reverse&&a.reverse(),a}_positionChanged(e,t){let{caretX:n,caretY:r,options:i}=this,a=Qd[i.position].call(this,e,t);return a!==!1&&(n!==a.x||r!==a.y)}},vf={id:`tooltip`,_element:_f,positioners:Qd,afterInit(e,t,n){n&&(e.tooltip=new _f({chart:e,options:n}))},beforeUpdate(e,t,n){e.tooltip&&e.tooltip.initialize(n)},reset(e,t,n){e.tooltip&&e.tooltip.initialize(n)},afterDraw(e){let t=e.tooltip;if(t&&t._willRender()){let n={tooltip:t};if(e.notifyPlugins(`beforeTooltipDraw`,{...n,cancelable:!0})===!1)return;t.draw(e.ctx),e.notifyPlugins(`afterTooltipDraw`,n)}},afterEvent(e,t){if(e.tooltip){let n=t.replay;e.tooltip.handleEvent(t.event,n,t.inChartArea)&&(t.changed=!0)}},defaults:{enabled:!0,external:null,position:`average`,backgroundColor:`rgba(0,0,0,0.8)`,titleColor:`#fff`,titleFont:{weight:`bold`},titleSpacing:2,titleMarginBottom:6,titleAlign:`left`,bodyColor:`#fff`,bodySpacing:2,bodyFont:{},bodyAlign:`left`,footerColor:`#fff`,footerSpacing:2,footerMarginTop:6,footerFont:{weight:`bold`},footerAlign:`left`,padding:6,caretPadding:2,caretSize:5,cornerRadius:6,boxHeight:(e,t)=>t.bodyFont.size,boxWidth:(e,t)=>t.bodyFont.size,multiKeyBackground:`#fff`,displayColors:!0,boxPadding:0,borderColor:`rgba(0,0,0,0)`,borderWidth:0,animation:{duration:400,easing:`easeOutQuart`},animations:{numbers:{type:`number`,properties:[`x`,`y`,`width`,`height`,`caretX`,`caretY`]},opacity:{easing:`linear`,duration:200}},callbacks:hf},defaultRoutes:{bodyFont:`font`,footerFont:`font`,titleFont:`font`},descriptors:{_scriptable:e=>e!==`filter`&&e!==`itemSort`&&e!==`external`,_indexable:!1,callbacks:{_scriptable:!1,_indexable:!1},animation:{_fallback:!1},animations:{_fallback:`animation`}},additionalOptionScopes:[`interaction`]},yf=(e,t,n,r)=>(typeof t==`string`?(n=e.push(t)-1,r.unshift({index:n,label:t})):isNaN(t)&&(n=null),n);function bf(e,t,n,r){let i=e.indexOf(t);return i===-1?yf(e,t,n,r):i===e.lastIndexOf(t)?i:n}var xf=(e,t)=>e===null?null:Ro(Math.round(e),0,t);function Sf(e){let t=this.getLabels();return e>=0&&e<t.length?t[e]:e}var Cf=class extends Uu{static id=`category`;static defaults={ticks:{callback:Sf}};constructor(e){super(e),this._startValue=void 0,this._valueRange=0,this._addedLabels=[]}init(e){let t=this._addedLabels;if(t.length){let e=this.getLabels();for(let{index:n,label:r}of t)e[n]===r&&e.splice(n,1);this._addedLabels=[]}super.init(e)}parse(e,t){if(U(e))return null;let n=this.getLabels();return t=isFinite(t)&&n[t]===e?t:bf(n,e,q(t,e),this._addedLabels),xf(t,n.length-1)}determineDataLimits(){let{minDefined:e,maxDefined:t}=this.getUserBounds(),{min:n,max:r}=this.getMinMax(!0);this.options.bounds===`ticks`&&(e||(n=0),t||(r=this.getLabels().length-1)),this.min=n,this.max=r}buildTicks(){let e=this.min,t=this.max,n=this.options.offset,r=[],i=this.getLabels();i=e===0&&t===i.length-1?i:i.slice(e,t+1),this._valueRange=Math.max(i.length-+!n,1),this._startValue=this.min-(n?.5:0);for(let n=e;n<=t;n++)r.push({value:n});return r}getLabelForValue(e){return Sf.call(this,e)}configure(){super.configure(),this.isHorizontal()||(this._reversePixels=!this._reversePixels)}getPixelForValue(e){return typeof e!=`number`&&(e=this.parse(e)),e===null?NaN:this.getPixelForDecimal((e-this._startValue)/this._valueRange)}getPixelForTick(e){let t=this.ticks;return e<0||e>t.length-1?null:this.getPixelForValue(t[e].value)}getValueForPixel(e){return Math.round(this._startValue+this.getDecimalForPixel(e)*this._valueRange)}getBasePixel(){return this.bottom}};function wf(e,t){let n=[],{bounds:r,step:i,min:a,max:o,precision:s,count:c,maxTicks:l,maxDigits:u,includeBounds:d}=e,f=i||1,p=l-1,{min:m,max:h}=t,g=!U(a),_=!U(o),v=!U(c),y=(h-m)/(u+1),b=To((h-m)/p/f)*f,x,S,C,w;if(b<1e-14&&!g&&!_)return[{value:m},{value:h}];w=Math.ceil(h/b)-Math.floor(m/b),w>p&&(b=To(w*b/p/f)*f),U(s)||(x=10**s,b=Math.ceil(b*x)/x),r===`ticks`?(S=Math.floor(m/b)*b,C=Math.ceil(h/b)*b):(S=m,C=h),g&&_&&i&&ko((o-a)/i,b/1e3)?(w=Math.round(Math.min((o-a)/b,l)),b=(o-a)/w,S=a,C=o):v?(S=g?a:S,C=_?o:C,w=c-1,b=(C-S)/w):(w=(C-S)/b,w=wo(w,Math.round(w),b/1e3)?Math.round(w):Math.ceil(w));let T=Math.max(No(b),No(S));x=10**(U(s)?T:s),S=Math.round(S*x)/x,C=Math.round(C*x)/x;let E=0;for(g&&(d&&S!==a?(n.push({value:a}),S<a&&E++,wo(Math.round((S+E*b)*x)/x,a,Tf(a,y,e))&&E++):S<a&&E++);E<w;++E){let e=Math.round((S+E*b)*x)/x;if(_&&e>o)break;n.push({value:e})}return _&&d&&C!==o?n.length&&wo(n[n.length-1].value,o,Tf(o,y,e))?n[n.length-1].value=o:n.push({value:o}):(!_||C===o)&&n.push({value:C}),n}function Tf(e,t,{horizontal:n,minRotation:r}){let i=jo(r),a=(n?Math.sin(i):Math.cos(i))||.001,o=.75*t*(``+e).length;return Math.min(t/a,o)}var Ef=class extends Uu{constructor(e){super(e),this.start=void 0,this.end=void 0,this._startValue=void 0,this._endValue=void 0,this._valueRange=0}parse(e,t){return U(e)||(typeof e==`number`||e instanceof Number)&&!isFinite(+e)?null:+e}handleTickRangeOptions(){let{beginAtZero:e}=this.options,{minDefined:t,maxDefined:n}=this.getUserBounds(),{min:r,max:i}=this,a=e=>r=t?r:e,o=e=>i=n?i:e;if(e){let e=Co(r),t=Co(i);e<0&&t<0?o(0):e>0&&t>0&&a(0)}if(r===i){let t=i===0?1:Math.abs(i*.05);o(i+t),e||a(r-t)}this.min=r,this.max=i}getTickLimit(){let{maxTicksLimit:e,stepSize:t}=this.options.ticks,n;return t?(n=Math.ceil(this.max/t)-Math.floor(this.min/t)+1,n>1e3&&(console.warn(`scales.${this.id}.ticks.stepSize: ${t} would result generating up to ${n} ticks. Limiting to 1000.`),n=1e3)):(n=this.computeTickLimit(),e||=11),e&&(n=Math.min(e,n)),n}computeTickLimit(){return 1/0}buildTicks(){let e=this.options,t=e.ticks,n=this.getTickLimit();n=Math.max(2,n);let r=wf({maxTicks:n,bounds:e.bounds,min:e.min,max:e.max,precision:t.precision,step:t.stepSize,count:t.count,maxDigits:this._maxDigits(),horizontal:this.isHorizontal(),minRotation:t.minRotation||0,includeBounds:t.includeBounds!==!1},this._range||this);return e.bounds===`ticks`&&Ao(r,this,`value`),e.reverse?(r.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),r}configure(){let e=this.ticks,t=this.min,n=this.max;if(super.configure(),this.options.offset&&e.length){let r=(n-t)/Math.max(e.length-1,1)/2;t-=r,n+=r}this._startValue=t,this._endValue=n,this._valueRange=n-t}getLabelForValue(e){return ms(e,this.chart.options.locale,this.options.ticks.format)}},Df=class extends Ef{static id=`linear`;static defaults={ticks:{callback:_s.formatters.numeric}};determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=K(e)?e:0,this.max=K(t)?t:1,this.handleTickRangeOptions()}computeTickLimit(){let e=this.isHorizontal(),t=e?this.width:this.height,n=jo(this.options.ticks.minRotation),r=(e?Math.sin(n):Math.cos(n))||.001,i=this._resolveTickFontOptions(0);return Math.ceil(t/Math.min(40,i.lineHeight/r))}getPixelForValue(e){return e===null?NaN:this.getPixelForDecimal((e-this._startValue)/this._valueRange)}getValueForPixel(e){return this._startValue+this.getDecimalForPixel(e)*this._valueRange}},Of=e=>Math.floor(So(e)),kf=(e,t)=>10**(Of(e)+t);function Af(e){return e/10**Of(e)==1}function jf(e,t,n){let r=10**n,i=Math.floor(e/r);return Math.ceil(t/r)-i}function Mf(e,t){let n=Of(t-e);for(;jf(e,t,n)>10;)n++;for(;jf(e,t,n)<10;)n--;return Math.min(n,Of(e))}function Nf(e,{min:t,max:n}){t=Za(e.min,t);let r=[],i=Of(t),a=Mf(t,n),o=a<0?10**Math.abs(a):1,s=10**a,c=i>a?10**i:0,l=Math.round((t-c)*o)/o,u=Math.floor((t-c)/s/10)*s*10,d=Math.floor((l-u)/10**a),f=Za(e.min,Math.round((c+u+d*10**a)*o)/o);for(;f<n;)r.push({value:f,major:Af(f),significand:d}),d>=10?d=d<15?15:20:d++,d>=20&&(a++,d=2,o=a>=0?1:o),f=Math.round((c+u+d*10**a)*o)/o;let p=Za(e.max,f);return r.push({value:p,major:Af(p),significand:d}),r}(class extends Uu{static id=`logarithmic`;static defaults={ticks:{callback:_s.formatters.logarithmic,major:{enabled:!0}}};constructor(e){super(e),this.start=void 0,this.end=void 0,this._startValue=void 0,this._valueRange=0}parse(e,t){let n=Ef.prototype.parse.apply(this,[e,t]);if(n===0){this._zero=!0;return}return K(n)&&n>0?n:null}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=K(e)?Math.max(0,e):null,this.max=K(t)?Math.max(0,t):null,this.options.beginAtZero&&(this._zero=!0),this._zero&&this.min!==this._suggestedMin&&!K(this._userMin)&&(this.min=e===kf(this.min,0)?kf(this.min,-1):kf(this.min,0)),this.handleTickRangeOptions()}handleTickRangeOptions(){let{minDefined:e,maxDefined:t}=this.getUserBounds(),n=this.min,r=this.max,i=t=>n=e?n:t,a=e=>r=t?r:e;n===r&&(n<=0?(i(1),a(10)):(i(kf(n,-1)),a(kf(r,1)))),n<=0&&i(kf(r,-1)),r<=0&&a(kf(n,1)),this.min=n,this.max=r}buildTicks(){let e=this.options,t=Nf({min:this._userMin,max:this._userMax},this);return e.bounds===`ticks`&&Ao(t,this,`value`),e.reverse?(t.reverse(),this.start=this.max,this.end=this.min):(this.start=this.min,this.end=this.max),t}getLabelForValue(e){return e===void 0?`0`:ms(e,this.chart.options.locale,this.options.ticks.format)}configure(){let e=this.min;super.configure(),this._startValue=So(e),this._valueRange=So(this.max)-So(e)}getPixelForValue(e){return(e===void 0||e===0)&&(e=this.min),e===null||isNaN(e)?NaN:this.getPixelForDecimal(e===this.min?0:(So(e)-this._startValue)/this._valueRange)}getValueForPixel(e){let t=this.getDecimalForPixel(e);return 10**(this._startValue+t*this._valueRange)}});function Pf(e){let t=e.ticks;if(t.display&&e.display){let e=Q(t.backdropPadding);return q(t.font&&t.font.size,Z.font.size)+e.height}return 0}function Ff(e,t,n){return n=W(n)?n:[n],{w:Ts(e,t.string,n),h:n.length*t.lineHeight}}function If(e,t,n,r,i){return e===r||e===i?{start:t-n/2,end:t+n/2}:e<r||e>i?{start:t-n,end:t}:{start:t,end:t+n}}function Lf(e){let t={l:e.left+e._padding.left,r:e.right-e._padding.right,t:e.top+e._padding.top,b:e.bottom-e._padding.bottom},n=Object.assign({},t),r=[],i=[],a=e._pointLabels.length,o=e.options.pointLabels,s=o.centerPointLabels?X/a:0;for(let c=0;c<a;c++){let a=o.setContext(e.getPointLabelContext(c));i[c]=a.padding;let l=e.getPointPosition(c,e.drawingArea+i[c],s),u=$(a.font),d=Ff(e.ctx,u,e._pointLabels[c]);r[c]=d;let f=Io(e.getIndexAngle(c)+s),p=Math.round(Mo(f));Rf(n,t,f,If(p,l.x,d.w,0,180),If(p,l.y,d.h,90,270))}e.setCenterPoint(t.l-n.l,n.r-t.r,t.t-n.t,n.b-t.b),e._pointLabelItems=Vf(e,r,i)}function Rf(e,t,n,r,i){let a=Math.abs(Math.sin(n)),o=Math.abs(Math.cos(n)),s=0,c=0;r.start<t.l?(s=(t.l-r.start)/a,e.l=Math.min(e.l,t.l-s)):r.end>t.r&&(s=(r.end-t.r)/a,e.r=Math.max(e.r,t.r+s)),i.start<t.t?(c=(t.t-i.start)/o,e.t=Math.min(e.t,t.t-c)):i.end>t.b&&(c=(i.end-t.b)/o,e.b=Math.max(e.b,t.b+c))}function zf(e,t,n){let r=e.drawingArea,{extra:i,additionalAngle:a,padding:o,size:s}=n,c=e.getPointPosition(t,r+i+o,a),l=Math.round(Mo(Io(c.angle+yo))),u=Wf(c.y,s.h,l),d=Hf(l),f=Uf(c.x,s.w,d);return{visible:!0,x:c.x,y:u,textAlign:d,left:f,top:u,right:f+s.w,bottom:u+s.h}}function Bf(e,t){if(!t)return!0;let{left:n,top:r,right:i,bottom:a}=e;return!(As({x:n,y:r},t)||As({x:n,y:a},t)||As({x:i,y:r},t)||As({x:i,y:a},t))}function Vf(e,t,n){let r=[],i=e._pointLabels.length,a=e.options,{centerPointLabels:o,display:s}=a.pointLabels,c={extra:Pf(a)/2,additionalAngle:o?X/i:0},l;for(let a=0;a<i;a++){c.padding=n[a],c.size=t[a];let i=zf(e,a,c);r.push(i),s===`auto`&&(i.visible=Bf(i,l),i.visible&&(l=i))}return r}function Hf(e){return e===0||e===180?`center`:e<180?`left`:`right`}function Uf(e,t,n){return n===`right`?e-=t:n===`center`&&(e-=t/2),e}function Wf(e,t,n){return n===90||n===270?e-=t/2:(n>270||n<90)&&(e-=t),e}function Gf(e,t,n){let{left:r,top:i,right:a,bottom:o}=n,{backdropColor:s}=t;if(!U(s)){let n=Ws(t.borderRadius),c=Q(t.backdropPadding);e.fillStyle=s;let l=r-c.left,u=i-c.top,d=a-r+c.width,f=o-i+c.height;Object.values(n).some(e=>e!==0)?(e.beginPath(),Ls(e,{x:l,y:u,w:d,h:f,radius:n}),e.fill()):e.fillRect(l,u,d,f)}}function Kf(e,t){let{ctx:n,options:{pointLabels:r}}=e;for(let i=t-1;i>=0;i--){let t=e._pointLabelItems[i];if(!t.visible)continue;let a=r.setContext(e.getPointLabelContext(i));Gf(n,a,t);let o=$(a.font),{x:s,y:c,textAlign:l}=t;Is(n,e._pointLabels[i],s,c+o.lineHeight/2,o,{color:a.color,textAlign:l,textBaseline:`middle`})}}function qf(e,t,n,r){let{ctx:i}=e;if(n)i.arc(e.xCenter,e.yCenter,t,0,go);else{let n=e.getPointPosition(0,t);i.moveTo(n.x,n.y);for(let a=1;a<r;a++)n=e.getPointPosition(a,t),i.lineTo(n.x,n.y)}}function Jf(e,t,n,r,i){let a=e.ctx,o=t.circular,{color:s,lineWidth:c}=t;!o&&!r||!s||!c||n<0||(a.save(),a.strokeStyle=s,a.lineWidth=c,a.setLineDash(i.dash||[]),a.lineDashOffset=i.dashOffset,a.beginPath(),qf(e,n,o,r),a.closePath(),a.stroke(),a.restore())}function Yf(e,t,n){return qs(e,{label:n,index:t,type:`pointLabel`})}(class extends Ef{static id=`radialLinear`;static defaults={display:!0,animate:!0,position:`chartArea`,angleLines:{display:!0,lineWidth:1,borderDash:[],borderDashOffset:0},grid:{circular:!1},startAngle:0,ticks:{showLabelBackdrop:!0,callback:_s.formatters.numeric},pointLabels:{backdropColor:void 0,backdropPadding:2,display:!0,font:{size:10},callback(e){return e},padding:5,centerPointLabels:!1}};static defaultRoutes={"angleLines.color":`borderColor`,"pointLabels.color":`color`,"ticks.color":`color`};static descriptors={angleLines:{_fallback:`grid`}};constructor(e){super(e),this.xCenter=void 0,this.yCenter=void 0,this.drawingArea=void 0,this._pointLabels=[],this._pointLabelItems=[]}setDimensions(){let e=this._padding=Q(Pf(this.options)/2),t=this.width=this.maxWidth-e.width,n=this.height=this.maxHeight-e.height;this.xCenter=Math.floor(this.left+t/2+e.left),this.yCenter=Math.floor(this.top+n/2+e.top),this.drawingArea=Math.floor(Math.min(t,n)/2)}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!1);this.min=K(e)&&!isNaN(e)?e:0,this.max=K(t)&&!isNaN(t)?t:0,this.handleTickRangeOptions()}computeTickLimit(){return Math.ceil(this.drawingArea/Pf(this.options))}generateTickLabels(e){Ef.prototype.generateTickLabels.call(this,e),this._pointLabels=this.getLabels().map((e,t)=>{let n=J(this.options.pointLabels.callback,[e,t],this);return n||n===0?n:``}).filter((e,t)=>this.chart.getDataVisibility(t))}fit(){let e=this.options;e.display&&e.pointLabels.display?Lf(this):this.setCenterPoint(0,0,0,0)}setCenterPoint(e,t,n,r){this.xCenter+=Math.floor((e-t)/2),this.yCenter+=Math.floor((n-r)/2),this.drawingArea-=Math.min(this.drawingArea/2,Math.max(e,t,n,r))}getIndexAngle(e){let t=go/(this._pointLabels.length||1),n=this.options.startAngle||0;return Io(e*t+jo(n))}getDistanceFromCenterForValue(e){if(U(e))return NaN;let t=this.drawingArea/(this.max-this.min);return this.options.reverse?(this.max-e)*t:(e-this.min)*t}getValueForDistanceFromCenter(e){if(U(e))return NaN;let t=e/(this.drawingArea/(this.max-this.min));return this.options.reverse?this.max-t:this.min+t}getPointLabelContext(e){let t=this._pointLabels||[];if(e>=0&&e<t.length){let n=t[e];return Yf(this.getContext(),e,n)}}getPointPosition(e,t,n=0){let r=this.getIndexAngle(e)-yo+n;return{x:Math.cos(r)*t+this.xCenter,y:Math.sin(r)*t+this.yCenter,angle:r}}getPointPositionForValue(e,t){return this.getPointPosition(e,this.getDistanceFromCenterForValue(t))}getBasePosition(e){return this.getPointPositionForValue(e||0,this.getBaseValue())}getPointLabelPosition(e){let{left:t,top:n,right:r,bottom:i}=this._pointLabelItems[e];return{left:t,top:n,right:r,bottom:i}}drawBackground(){let{backgroundColor:e,grid:{circular:t}}=this.options;if(e){let n=this.ctx;n.save(),n.beginPath(),qf(this,this.getDistanceFromCenterForValue(this._endValue),t,this._pointLabels.length),n.closePath(),n.fillStyle=e,n.fill(),n.restore()}}drawGrid(){let e=this.ctx,t=this.options,{angleLines:n,grid:r,border:i}=t,a=this._pointLabels.length,o,s,c;if(t.pointLabels.display&&Kf(this,a),r.display&&this.ticks.forEach((e,t)=>{if(t!==0||t===0&&this.min<0){s=this.getDistanceFromCenterForValue(e.value);let n=this.getContext(t),o=r.setContext(n),c=i.setContext(n);Jf(this,o,s,a,c)}}),n.display){for(e.save(),o=a-1;o>=0;o--){let r=n.setContext(this.getPointLabelContext(o)),{color:i,lineWidth:a}=r;!a||!i||(e.lineWidth=a,e.strokeStyle=i,e.setLineDash(r.borderDash),e.lineDashOffset=r.borderDashOffset,s=this.getDistanceFromCenterForValue(t.reverse?this.min:this.max),c=this.getPointPosition(o,s),e.beginPath(),e.moveTo(this.xCenter,this.yCenter),e.lineTo(c.x,c.y),e.stroke())}e.restore()}}drawBorder(){}drawLabels(){let e=this.ctx,t=this.options,n=t.ticks;if(!n.display)return;let r=this.getIndexAngle(0),i,a;e.save(),e.translate(this.xCenter,this.yCenter),e.rotate(r),e.textAlign=`center`,e.textBaseline=`middle`,this.ticks.forEach((r,o)=>{if(o===0&&this.min>=0&&!t.reverse)return;let s=n.setContext(this.getContext(o)),c=$(s.font);if(i=this.getDistanceFromCenterForValue(this.ticks[o].value),s.showLabelBackdrop){e.font=c.string,a=e.measureText(r.label).width,e.fillStyle=s.backdropColor;let t=Q(s.backdropPadding);e.fillRect(-a/2-t.left,-i-c.size/2-t.top,a+t.width,c.size+t.height)}Is(e,r.label,0,-i,c,{color:s.color,strokeColor:s.textStrokeColor,strokeWidth:s.textStrokeWidth})}),e.restore()}drawTitle(){}});var Xf={millisecond:{common:!0,size:1,steps:1e3},second:{common:!0,size:1e3,steps:60},minute:{common:!0,size:6e4,steps:60},hour:{common:!0,size:36e5,steps:24},day:{common:!0,size:864e5,steps:30},week:{common:!1,size:6048e5,steps:4},month:{common:!0,size:2628e6,steps:12},quarter:{common:!1,size:7884e6,steps:4},year:{common:!0,size:3154e7}},Zf=Object.keys(Xf);function Qf(e,t){return e-t}function $f(e,t){if(U(t))return null;let n=e._adapter,{parser:r,round:i,isoWeekday:a}=e._parseOpts,o=t;return typeof r==`function`&&(o=r(o)),K(o)||(o=typeof r==`string`?n.parse(o,r):n.parse(o)),o===null?null:(i&&(o=i===`week`&&(Oo(a)||a===!0)?n.startOf(o,`isoWeek`,a):n.startOf(o,i)),+o)}function ep(e,t,n,r){let i=Zf.length;for(let a=Zf.indexOf(e);a<i-1;++a){let e=Xf[Zf[a]],i=e.steps?e.steps:2**53-1;if(e.common&&Math.ceil((n-t)/(i*e.size))<=r)return Zf[a]}return Zf[i-1]}function tp(e,t,n,r,i){for(let a=Zf.length-1;a>=Zf.indexOf(n);a--){let n=Zf[a];if(Xf[n].common&&e._adapter.diff(i,r,n)>=t-1)return n}return Zf[n?Zf.indexOf(n):0]}function np(e){for(let t=Zf.indexOf(e)+1,n=Zf.length;t<n;++t)if(Xf[Zf[t]].common)return Zf[t]}function rp(e,t,n){if(!n)e[t]=!0;else if(n.length){let{lo:r,hi:i}=Vo(n,t),a=n[r]>=t?n[r]:n[i];e[a]=!0}}function ip(e,t,n,r){let i=e._adapter,a=+i.startOf(t[0].value,r),o=t[t.length-1].value,s,c;for(s=a;s<=o;s=+i.add(s,1,r))c=n[s],c>=0&&(t[c].major=!0);return t}function ap(e,t,n){let r=[],i={},a=t.length,o,s;for(o=0;o<a;++o)s=t[o],i[s]=o,r.push({value:s,major:!1});return a===0||!n?r:ip(e,r,i,n)}var op=class extends Uu{static id=`time`;static defaults={bounds:`data`,adapters:{},time:{parser:!1,unit:!1,round:!1,isoWeekday:!1,minUnit:`millisecond`,displayFormats:{}},ticks:{source:`auto`,callback:!1,major:{enabled:!1}}};constructor(e){super(e),this._cache={data:[],labels:[],all:[]},this._unit=`day`,this._majorUnit=void 0,this._offsets={},this._normalized=!1,this._parseOpts=void 0}init(e,t={}){let n=e.time||={},r=this._adapter=new Dl._date(e.adapters.date);r.init(t),io(n.displayFormats,r.formats()),this._parseOpts={parser:n.parser,round:n.round,isoWeekday:n.isoWeekday},super.init(e),this._normalized=t.normalized}parse(e,t){return e===void 0?null:$f(this,e)}beforeLayout(){super.beforeLayout(),this._cache={data:[],labels:[],all:[]}}determineDataLimits(){let e=this.options,t=this._adapter,n=e.time.unit||`day`,{min:r,max:i,minDefined:a,maxDefined:o}=this.getUserBounds();function s(e){!a&&!isNaN(e.min)&&(r=Math.min(r,e.min)),!o&&!isNaN(e.max)&&(i=Math.max(i,e.max))}(!a||!o)&&(s(this._getLabelBounds()),(e.bounds!==`ticks`||e.ticks.source!==`labels`)&&s(this.getMinMax(!1))),r=K(r)&&!isNaN(r)?r:+t.startOf(Date.now(),n),i=K(i)&&!isNaN(i)?i:+t.endOf(Date.now(),n)+1,this.min=Math.min(r,i-1),this.max=Math.max(r+1,i)}_getLabelBounds(){let e=this.getLabelTimestamps(),t=1/0,n=-1/0;return e.length&&(t=e[0],n=e[e.length-1]),{min:t,max:n}}buildTicks(){let e=this.options,t=e.time,n=e.ticks,r=n.source===`labels`?this.getLabelTimestamps():this._generate();e.bounds===`ticks`&&r.length&&(this.min=this._userMin||r[0],this.max=this._userMax||r[r.length-1]);let i=this.min,a=this.max,o=Wo(r,i,a);return this._unit=t.unit||(n.autoSkip?ep(t.minUnit,this.min,this.max,this._getLabelCapacity(i)):tp(this,o.length,t.minUnit,this.min,this.max)),this._majorUnit=!n.major.enabled||this._unit===`year`?void 0:np(this._unit),this.initOffsets(r),e.reverse&&o.reverse(),ap(this,o,this._majorUnit)}afterAutoSkip(){this.options.offsetAfterAutoskip&&this.initOffsets(this.ticks.map(e=>+e.value))}initOffsets(e=[]){let t=0,n=0,r,i;this.options.offset&&e.length&&(r=this.getDecimalForValue(e[0]),t=e.length===1?1-r:(this.getDecimalForValue(e[1])-r)/2,i=this.getDecimalForValue(e[e.length-1]),n=e.length===1?i:(i-this.getDecimalForValue(e[e.length-2]))/2);let a=e.length<3?.5:.25;t=Ro(t,0,a),n=Ro(n,0,a),this._offsets={start:t,end:n,factor:1/(t+1+n)}}_generate(){let e=this._adapter,t=this.min,n=this.max,r=this.options,i=r.time,a=i.unit||ep(i.minUnit,t,n,this._getLabelCapacity(t)),o=q(r.ticks.stepSize,1),s=a===`week`&&i.isoWeekday,c=Oo(s)||s===!0,l={},u=t,d,f;if(c&&(u=+e.startOf(u,`isoWeek`,s)),u=+e.startOf(u,c?`day`:a),e.diff(n,t,a)>1e5*o)throw Error(t+` and `+n+` are too far apart with stepSize of `+o+` `+a);let p=r.ticks.source===`data`&&this.getDataTimestamps();for(d=u,f=0;d<n;d=+e.add(d,o,a),f++)rp(l,d,p);return(d===n||r.bounds===`ticks`||f===1)&&rp(l,d,p),Object.keys(l).sort(Qf).map(e=>+e)}getLabelForValue(e){let t=this._adapter,n=this.options.time;return n.tooltipFormat?t.format(e,n.tooltipFormat):t.format(e,n.displayFormats.datetime)}format(e,t){let n=this.options.time.displayFormats,r=this._unit,i=t||n[r];return this._adapter.format(e,i)}_tickFormatFunction(e,t,n,r){let i=this.options,a=i.ticks.callback;if(a)return J(a,[e,t,n],this);let o=i.time.displayFormats,s=this._unit,c=this._majorUnit,l=s&&o[s],u=c&&o[c],d=n[t],f=c&&u&&d&&d.major;return this._adapter.format(e,r||(f?u:l))}generateTickLabels(e){let t,n,r;for(t=0,n=e.length;t<n;++t)r=e[t],r.label=this._tickFormatFunction(r.value,t,e)}getDecimalForValue(e){return e===null?NaN:(e-this.min)/(this.max-this.min)}getPixelForValue(e){let t=this._offsets,n=this.getDecimalForValue(e);return this.getPixelForDecimal((t.start+n)*t.factor)}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return this.min+n*(this.max-this.min)}_getLabelSize(e){let t=this.options.ticks,n=this.ctx.measureText(e).width,r=jo(this.isHorizontal()?t.maxRotation:t.minRotation),i=Math.cos(r),a=Math.sin(r),o=this._resolveTickFontOptions(0).size;return{w:n*i+o*a,h:n*a+o*i}}_getLabelCapacity(e){let t=this.options.time,n=t.displayFormats,r=n[t.unit]||n.millisecond,i=this._tickFormatFunction(e,0,ap(this,[e],this._majorUnit),r),a=this._getLabelSize(i),o=Math.floor(this.isHorizontal()?this.width/a.w:this.height/a.h)-1;return o>0?o:1}getDataTimestamps(){let e=this._cache.data||[],t,n;if(e.length)return e;let r=this.getMatchingVisibleMetas();if(this._normalized&&r.length)return this._cache.data=r[0].controller.getAllParsedValues(this);for(t=0,n=r.length;t<n;++t)e=e.concat(r[t].controller.getAllParsedValues(this));return this._cache.data=this.normalize(e)}getLabelTimestamps(){let e=this._cache.labels||[],t,n;if(e.length)return e;let r=this.getLabels();for(t=0,n=r.length;t<n;++t)e.push($f(this,r[t]));return this._cache.labels=this._normalized?e:this.normalize(e)}normalize(e){return Jo(e.sort(Qf))}};function sp(e,t,n){let r=0,i=e.length-1,a,o,s,c;n?(t>=e[r].pos&&t<=e[i].pos&&({lo:r,hi:i}=Ho(e,`pos`,t)),{pos:a,time:s}=e[r],{pos:o,time:c}=e[i]):(t>=e[r].time&&t<=e[i].time&&({lo:r,hi:i}=Ho(e,`time`,t)),{time:a,pos:s}=e[r],{time:o,pos:c}=e[i]);let l=o-a;return l?s+(c-s)*(t-a)/l:s}(class extends op{static id=`timeseries`;static defaults=op.defaults;constructor(e){super(e),this._table=[],this._minPos=void 0,this._tableRange=void 0}initOffsets(){let e=this._getTimestampsForTable(),t=this._table=this.buildLookupTable(e);this._minPos=sp(t,this.min),this._tableRange=sp(t,this.max)-this._minPos,super.initOffsets(e)}buildLookupTable(e){let{min:t,max:n}=this,r=[],i=[],a,o,s,c,l;for(a=0,o=e.length;a<o;++a)c=e[a],c>=t&&c<=n&&r.push(c);if(r.length<2)return[{time:t,pos:0},{time:n,pos:1}];for(a=0,o=r.length;a<o;++a)l=r[a+1],s=r[a-1],c=r[a],Math.round((l+s)/2)!==c&&i.push({time:c,pos:a/(o-1)});return i}_generate(){let e=this.min,t=this.max,n=super.getDataTimestamps();return(!n.includes(e)||!n.length)&&n.splice(0,0,e),(!n.includes(t)||n.length===1)&&n.push(t),n.sort((e,t)=>e-t)}_getTimestampsForTable(){let e=this._cache.all||[];if(e.length)return e;let t=this.getDataTimestamps(),n=this.getLabelTimestamps();return e=t.length&&n.length?this.normalize(t.concat(n)):t.length?t:n,e=this._cache.all=e,e}getDecimalForValue(e){return(sp(this._table,e)-this._minPos)/this._tableRange}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return sp(this._table,n*this._tableRange+this._minPos,!0)}});var cp={data:{type:Object,required:!0},options:{type:Object,default:()=>({})},plugins:{type:Array,default:()=>[]},datasetIdKey:{type:String,default:`label`},updateMode:{type:String,default:void 0}},lp={ariaLabel:{type:String},ariaDescribedby:{type:String}},up={type:{type:String,required:!0},destroyDelay:{type:Number,default:0},...cp,...lp},dp=(e,t)=>Object.assign(e,t);function fp(e){return c(e)?O(e):e}function pp(e){let t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:e;return c(t)?new Proxy(e,{}):e}function mp(e,t){let n=e.options;n&&t&&Object.assign(n,t)}function hp(e,t){e.labels=t}function gp(e,t,n){let r=[];e.datasets=t.map(t=>{let i=e.datasets.find(e=>e[n]===t[n]);return!i||!t.data||r.includes(i)?{...t}:(r.push(i),Object.assign(i,t),i)})}function _p(e,t){let n={labels:[],datasets:[]};return hp(n,e.labels),gp(n,e.datasets,t),n}var vp=R({props:up,setup(e,t){let{expose:n,slots:r}=t,i=F(null),a=w(null);n({chart:a});let o=()=>{if(!i.value)return;let{type:t,data:n,options:r,plugins:o,datasetIdKey:s}=e,c=pp(_p(n,s),n);a.value=new jd(i.value,{type:t,data:c,options:{...r},plugins:o})},s=()=>{let t=O(a.value);t&&(e.destroyDelay>0?setTimeout(()=>{t.destroy(),a.value=null},e.destroyDelay):(t.destroy(),a.value=null))},c=t=>{t.update(e.updateMode)};return Me(o),we(s),V([()=>e.options,()=>e.data],(t,n)=>{let[r,i]=t,[o,s]=n,l=O(a.value);if(!l)return;let u=!1;if(r){let e=fp(r),t=fp(o);e&&e!==t&&(mp(l,e),u=!0)}if(i){let t=fp(i.labels),n=fp(s.labels),r=fp(i.datasets),a=fp(s.datasets);t!==n&&(hp(l.config.data,t),u=!0),r&&r!==a&&(gp(l.config.data,r,e.datasetIdKey),u=!0)}u&&xe(()=>{c(l)})},{deep:!0}),()=>Ae(`canvas`,{role:`img`,"aria-label":e.ariaLabel,"aria-describedby":e.ariaDescribedby,ref:i},[Ae(`p`,{},[r.default?r.default():``])])}});function yp(e,t){return jd.register(t),R({props:cp,setup(t,n){let{expose:r}=n,i=w(null),a=w(null);V(()=>a.value?.chart??null,e=>{i.value=e},{flush:`sync`}),r({chart:i});let o=e=>{a.value=e};return()=>Ae(vp,dp({ref:o},{type:e,...t}))}})}var bp=yp(`bar`,Tl);jd.register(Tl,Hd,Cf,Df,Zd,vf);function xp(){let e=F(``),t=F(``),n=F(``);function r(){let r=getComputedStyle(document.documentElement);e.value=r.getPropertyValue(`--foreground`).trim(),t.value=r.getPropertyValue(`--muted-foreground`).trim(),n.value=r.getPropertyValue(`--border`).trim()}let i;return Me(()=>{r(),i=window.matchMedia(`(prefers-color-scheme: dark)`),i.addEventListener(`change`,r)}),Ie(()=>{i?.removeEventListener(`change`,r)}),{foreground:e,mutedForeground:t,border:n}}var Sp={cost:`Cost`,req:`Requests`,tokin:`Tokens in`,tokout:`Tokens out`},Cp=20,wp=100,Tp=3e4,Ep={hour:24,day:30,month:12},Dp={hour:`24h`,day:`30d`,month:`12mo`};function Op(e){switch(e){case`requests`:return[`req`];case`tokens`:return[`tokin`,`tokout`];case`cost`:return[`cost`];case`models`:return[]}}var kp=de(`history`,{state:()=>({scope:`total`,window:`hour`,tab:`requests`,modelMetric:`cost`,seriesByMetric:{},modelRanking:[],modelOptions:[],loading:!1,error:``,timer:void 0}),actions:{setScope(e){e!==this.scope&&(this.scope=e,this.refresh())},setWindow(e){e!==this.window&&(this.window=e,this.refresh())},setTab(e){e!==this.tab&&(this.tab=e,this.refresh())},setModelMetric(e){e!==this.modelMetric&&(this.modelMetric=e,this.refresh())},async refresh(){await Promise.all([this.tab===`models`?this.fetchModelRanking():this.fetchSeries(),this.fetchModelOptions()])},async fetchSeries(){if(je().isAuthenticated){this.loading=!0;try{let e=Ep[this.window],t=Op(this.tab),n=await Promise.all(t.map(t=>Fe(`/admin/api/usage/history?scope=${encodeURIComponent(this.scope)}&metric=${t}&window=${this.window}&span=${e}`))),r={};t.forEach((e,t)=>{r[e]=n[t].points}),this.seriesByMetric=r,this.error=``}catch(e){if(e instanceof be&&(e.status===401||e.status===403))return;this.error=e instanceof Error?e.message:String(e)}finally{this.loading=!1}}},async fetchModelRanking(){if(je().isAuthenticated){this.loading=!0;try{let e=await Fe(`/admin/api/usage/models?metric=${this.modelMetric}&window=${this.window}&limit=${Cp}`);this.modelRanking=e.models,this.error=``}catch(e){if(e instanceof be&&(e.status===401||e.status===403))return;this.error=e instanceof Error?e.message:String(e)}finally{this.loading=!1}}},async fetchModelOptions(){if(je().isAuthenticated)try{let e=await Fe(`/admin/api/usage/models?metric=req&window=${this.window}&limit=${wp}`);this.modelOptions=e.models}catch{}},startAutoRefresh(){this.timer===void 0&&(this.timer=setInterval(()=>void this.refresh(),Tp))},stopAutoRefresh(){this.timer!==void 0&&(clearInterval(this.timer),this.timer=void 0)}}}),Ap={key:0,class:`py-8 text-center text-sm text-muted-foreground`},jp=R({__name:`ModelUsageChart`,props:{metric:{},models:{}},setup(e){let t=e,{foreground:n,mutedForeground:r,border:a}=xp(),o={req:`--chart-requests`,tokin:`--chart-tokens-in`,tokout:`--chart-tokens-out`,cost:`--chart-cost`};function s(e,t){return e===`cost`?t/1e6:t}function c(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let l=M(()=>(n.value,{labels:t.models.map(e=>e.id),datasets:[{label:Sp[t.metric],backgroundColor:c(o[t.metric]),data:t.models.map(e=>s(t.metric,e.value))}]})),u=M(()=>`${Math.max(180,t.models.length*28+60)}px`),d=M(()=>({indexAxis:`y`,responsive:!0,maintainAspectRatio:!1,animation:!1,scales:{x:{beginAtZero:!0,grid:{color:a.value},ticks:{color:r.value,callback:e=>t.metric===`cost`?`$${e}`:ke(Number(e))}},y:{grid:{display:!1},ticks:{color:r.value,autoSkip:!1}}},plugins:{legend:{display:!1},tooltip:{callbacks:{label:e=>{let n=e.parsed.x??0;return t.metric===`cost`?`${Sp[t.metric]}: $${n.toFixed(4)}`:`${Sp[t.metric]}: ${ke(n)} (${Ue(n)})`}}}}}));return(t,n)=>e.models.length===0?(N(),P(`p`,Ap,` No model recorded any usage in this window. `)):(N(),P(`div`,{key:1,class:`w-full`,style:i({height:u.value})},[L(b(bp),{data:l.value,options:d.value},null,8,[`data`,`options`])],4))}}),Mp={class:`h-72 w-full`},Np=R({__name:`UsageChart`,props:{tab:{},window:{},seriesByMetric:{}},setup(e){let t=e,{foreground:n,mutedForeground:r,border:i}=xp(),a={requests:[{metric:`req`,label:`Requests`,color:`--chart-requests`}],tokens:[{metric:`tokin`,label:`Tokens in`,color:`--chart-tokens-in`},{metric:`tokout`,label:`Tokens out`,color:`--chart-tokens-out`}],cost:[{metric:`cost`,label:`Cost (USD)`,color:`--chart-cost`}]};function o(e,t){return e===`cost`?t/1e6:t}let s=M(()=>{let e=a[t.tab],n=new Set;for(let r of e)for(let e of t.seriesByMetric[r.metric]??[])n.add(e.bucket);return Array.from(n).sort()}),c=M(()=>s.value.map(e=>_e(e,t.window)));function l(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let u=M(()=>{n.value;let e=s.value;return{labels:c.value,datasets:a[t.tab].map(n=>{let r=new Map((t.seriesByMetric[n.metric]??[]).map(e=>[e.bucket,e.value]));return{label:n.label,backgroundColor:l(n.color),data:e.map(e=>o(n.metric,r.get(e)??0))}})}}),d=M(()=>a[t.tab].length>1),f=M(()=>({responsive:!0,maintainAspectRatio:!1,animation:!1,scales:{x:{stacked:d.value,grid:{color:i.value,display:!1},ticks:{color:r.value}},y:{stacked:d.value,beginAtZero:!0,grid:{color:i.value},ticks:{color:r.value,callback:e=>t.tab===`cost`?`$${e}`:ke(Number(e))}}},plugins:{legend:{display:d.value,labels:{color:n.value}},tooltip:{callbacks:{label:e=>{let n=e.parsed.y??0;return t.tab===`cost`?`${e.dataset.label}: $${n.toFixed(4)}`:`${e.dataset.label}: ${ke(n)} (${Ue(n)})`}}}}}));return(e,t)=>(N(),P(`div`,Mp,[L(b(bp),{data:u.value,options:f.value},null,8,[`data`,`options`])]))}}),Pp={class:`flex flex-wrap items-center gap-3`},Fp={key:0,class:`text-sm text-destructive`},Ip={class:`text-sm text-muted-foreground`},Lp=R({__name:`ChartsView`,setup(e){let t=ye(),n=kp(),{query:r,normalized:i,hasQuery:a}=Pe(),o=M(()=>{let e=t.usage?.users??[],r=t.usage?.groups??[],o=e.filter(e=>!a.value||Ne(e,i.value)||`user:${e.id}`===n.scope).map(e=>({value:`user:${e.id}`,label:e.id})),s=r.filter(t=>!a.value||Ve(t,e,i.value)||`group:${t.id}`===n.scope).map(e=>({value:`group:${e.id}`,label:e.id})),c=(n.modelOptions??[]).filter(e=>!a.value||e.id.toLowerCase().includes(i.value)||`model:${e.id}`===n.scope).map(e=>({value:`model:${e.id}`,label:e.id}));return n.scope.startsWith(`model:`)&&!c.some(e=>e.value===n.scope)&&c.push({value:n.scope,label:n.scope.slice(6)}),[{value:`total`,label:`Total (all traffic)`},...s,...o,...c]}),s=[`hour`,`day`,`month`],c=[`cost`,`req`,`tokin`,`tokout`],l=M(()=>n.tab===`models`?`requests`:n.tab);function u(e){n.setTab(e)}function d(e){typeof e==`string`&&n.setScope(e)}function f(e){typeof e==`string`&&n.setModelMetric(e)}return Me(()=>{n.refresh(),n.startAutoRefresh()}),we(()=>{n.stopAutoRefresh()}),V(o,e=>{e.some(e=>e.value===n.scope)||n.setScope(`total`)}),(e,t)=>(N(),I(b(Ge),null,{default:B(()=>[L(b(Se),{class:`flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between`},{default:B(()=>[L(b(Ce),null,{default:B(()=>[...t[2]||=[ge(`Usage charts`,-1)]]),_:1}),He(`div`,Pp,[L(Be,{modelValue:b(r),"onUpdate:modelValue":t[0]||=e=>E(r)?r.value=e:null,placeholder:`Filter users, groups or models`,class:`w-56`},null,8,[`modelValue`]),b(n).tab===`models`?(N(),I(b(Xi),{key:0,"model-value":b(n).modelMetric,"onUpdate:modelValue":f},{default:B(()=>[L(b(na),{class:`w-40`,"aria-label":`Rank models by`},{default:B(()=>[L(b(ra),{placeholder:`Rank by`})]),_:1}),L(b(Zi),null,{default:B(()=>[(N(),P(k,null,me(c,e=>L(b($i),{key:e,value:e},{default:B(()=>[ge(ce(b(Sp)[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`])):(N(),I(b(Xi),{key:1,"model-value":b(n).scope,"onUpdate:modelValue":d},{default:B(()=>[L(b(na),{class:`w-56`},{default:B(()=>[L(b(ra),{placeholder:`Scope`})]),_:1}),L(b(Zi),null,{default:B(()=>[(N(!0),P(k,null,me(o.value,e=>(N(),I(b($i),{key:e.value,value:e.value},{default:B(()=>[ge(ce(e.label),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])),L(b(he),{"model-value":b(n).window,"onUpdate:modelValue":t[1]||=e=>b(n).setWindow(e)},{default:B(()=>[L(b(Te),null,{default:B(()=>[(N(),P(k,null,me(s,e=>L(b(Re),{key:e,value:e},{default:B(()=>[ge(ce(b(Dp)[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`])])]),_:1}),L(b(pe),{class:`flex flex-col gap-4`},{default:B(()=>[L(b(he),{"model-value":b(n).tab,"onUpdate:modelValue":u},{default:B(()=>[L(b(Te),null,{default:B(()=>[L(b(Re),{value:`requests`},{default:B(()=>[...t[3]||=[ge(`Requests`,-1)]]),_:1}),L(b(Re),{value:`tokens`},{default:B(()=>[...t[4]||=[ge(`Tokens`,-1)]]),_:1}),L(b(Re),{value:`cost`},{default:B(()=>[...t[5]||=[ge(`Cost`,-1)]]),_:1}),L(b(Re),{value:`models`},{default:B(()=>[...t[6]||=[ge(`Models`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`]),b(n).error?(N(),P(`p`,Fp,ce(b(n).error),1)):ze(``,!0),b(n).tab===`models`?(N(),P(k,{key:1},[He(`p`,Ip,` Models with usage in the selected window, ranked by `+ce(b(Sp)[b(n).modelMetric].toLowerCase())+`. Each row is the provider that served the traffic, so a model reached through more than one provider appears once per provider. `,1),L(jp,{metric:b(n).modelMetric,models:b(n).modelRanking},null,8,[`metric`,`models`])],64)):(N(),I(Np,{key:2,tab:l.value,window:b(n).window,"series-by-metric":b(n).seriesByMetric},null,8,[`tab`,`window`,`series-by-metric`]))]),_:1})]),_:1}))}});export{Lp as default};", ), }, "index-CSkIItro.css": { @@ -52,10 +52,10 @@ var adminAssets = map[string]adminAsset{ "@keyframes authgate-shake-4be6bc09{10%,90%{transform:translate(-1px)}20%,80%{transform:translate(2px)}30%,50%,70%{transform:translate(-4px)}40%,60%{transform:translate(4px)}}@media (prefers-reduced-motion:no-preference){.authgate-shake[data-v-4be6bc09]{animation:.4s ease-in-out authgate-shake-4be6bc09}}@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){:root,:host{--shimmer-angle:20deg}*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-border-style:solid;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-outline-style:solid;--tw-blur:initial;--tw-brightness:initial;--tw-contrast:initial;--tw-grayscale:initial;--tw-hue-rotate:initial;--tw-invert:initial;--tw-opacity:initial;--tw-saturate:initial;--tw-sepia:initial;--tw-drop-shadow:initial;--tw-drop-shadow-color:initial;--tw-drop-shadow-alpha:100%;--tw-drop-shadow-size:initial;--tw-duration:initial;--tw-content:"";--tw-animation-delay:0s;--tw-animation-direction:normal;--tw-animation-duration:initial;--tw-animation-fill-mode:none;--tw-animation-iteration-count:1;--tw-enter-blur:0;--tw-enter-opacity:1;--tw-enter-rotate:0;--tw-enter-scale:1;--tw-enter-translate-x:0;--tw-enter-translate-y:0;--tw-exit-blur:0;--tw-exit-opacity:1;--tw-exit-rotate:0;--tw-exit-scale:1;--tw-exit-translate-x:0;--tw-exit-translate-y:0;--scroll-fade-t:0;--scroll-fade-b:0;--scroll-fade-s:0;--scroll-fade-e:0;--scroll-fade-mask:initial;--shimmer-image:initial;--shimmer-text-fill:initial}}}@layer theme{:root,:host{--font-sans:ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;--spacing:.25rem;--container-xs:20rem;--container-sm:24rem;--container-md:28rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-base:1rem;--text-base--line-height:calc(1.5 / 1);--text-lg:1.125rem;--text-lg--line-height:calc(1.75 / 1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75 / 1.25);--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--tracking-tight:-.025em;--leading-snug:1.375;--radius-md:calc(var(--radius) - 2px);--radius-4xl:2rem;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;--default-mono-font-family:ui-monospace, "SF Mono", "Cascadia Code", "Roboto Mono", Consolas, monospace}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--default-font-family,-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", "Noto Sans", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring:where(:not(iframe)){outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab, red, red)){::placeholder{color:color-mix(in oklab, currentcolor 50%, transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){appearance:button}::file-selector-button{appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}*{border-color:var(--border);outline-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){*{outline-color:color-mix(in oklab, var(--ring) 50%, transparent)}}body{background-color:var(--background);color:var(--foreground);font-variant-numeric:tabular-nums;font-family:ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif}}@layer components;@layer utilities{.\@container\/card-header{container:card-header/inline-size}.pointer-events-none{pointer-events:none}.collapse{visibility:collapse}.invisible{visibility:hidden}.visible{visibility:visible}.sr-only{clip-path:inset(50%);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.top-1\/2{top:50%}.top-2{top:calc(var(--spacing) * 2)}.right-1{right:var(--spacing)}.right-1\.5{right:calc(var(--spacing) * 1.5)}.right-2{right:calc(var(--spacing) * 2)}.left-2\.5{left:calc(var(--spacing) * 2.5)}.z-10{z-index:10}.z-50{z-index:50}.col-start-2{grid-column-start:2}.row-span-2{grid-row:span 2/span 2}.row-start-1{grid-row-start:1}.-mx-1{margin-inline:calc(var(--spacing) * -1)}.-mx-1\.5{margin-inline:calc(var(--spacing) * -1.5)}.mx-auto{margin-inline:auto}.my-1{margin-block:var(--spacing)}.mt-0\.5{margin-top:calc(var(--spacing) * .5)}.mt-2{margin-top:calc(var(--spacing) * 2)}.mt-4{margin-top:calc(var(--spacing) * 4)}.mb-1\.5{margin-bottom:calc(var(--spacing) * 1.5)}.mb-3{margin-bottom:calc(var(--spacing) * 3)}.block{display:block}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline{display:inline}.inline-flex{display:inline-flex}.table{display:table}.table-caption{display:table-caption}.table-cell{display:table-cell}.table-row{display:table-row}.size-2\.5{width:calc(var(--spacing) * 2.5);height:calc(var(--spacing) * 2.5)}.size-3{width:calc(var(--spacing) * 3);height:calc(var(--spacing) * 3)}.size-3\.5{width:calc(var(--spacing) * 3.5);height:calc(var(--spacing) * 3.5)}.size-4{width:calc(var(--spacing) * 4);height:calc(var(--spacing) * 4)}.size-5{width:calc(var(--spacing) * 5);height:calc(var(--spacing) * 5)}.size-6{width:calc(var(--spacing) * 6);height:calc(var(--spacing) * 6)}.size-7{width:calc(var(--spacing) * 7);height:calc(var(--spacing) * 7)}.size-8{width:calc(var(--spacing) * 8);height:calc(var(--spacing) * 8)}.size-9{width:calc(var(--spacing) * 9);height:calc(var(--spacing) * 9)}.size-12{width:calc(var(--spacing) * 12);height:calc(var(--spacing) * 12)}.h-5{height:calc(var(--spacing) * 5)}.h-6{height:calc(var(--spacing) * 6)}.h-7{height:calc(var(--spacing) * 7)}.h-8{height:calc(var(--spacing) * 8)}.h-9{height:calc(var(--spacing) * 9)}.h-10{height:calc(var(--spacing) * 10)}.h-72{height:calc(var(--spacing) * 72)}.h-\[calc\(100\%-1px\)\]{height:calc(100% - 1px)}.h-px{height:1px}.max-h-\(--reka-select-content-available-height\){max-height:var(--reka-select-content-available-height)}.min-h-\[70vh\]{min-height:70vh}.w-40{width:calc(var(--spacing) * 40)}.w-56{width:calc(var(--spacing) * 56)}.w-fit{width:fit-content}.w-full{width:100%}.max-w-md{max-width:var(--container-md)}.max-w-sm{max-width:var(--container-sm)}.max-w-xs{max-width:var(--container-xs)}.min-w-0{min-width:0}.min-w-36{min-width:calc(var(--spacing) * 36)}.flex-1{flex:1}.shrink-0{flex-shrink:0}.grow{flex-grow:1}.caption-bottom{caption-side:bottom}.origin-\(--reka-select-content-transform-origin\){transform-origin:var(--reka-select-content-transform-origin)}.-translate-y-1\/2{--tw-translate-y:calc(calc(1 / 2 * 100%) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.transform{transform:var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,)}.cursor-default{cursor:default}.cursor-pointer{cursor:pointer}.scroll-my-1{scroll-margin-block:var(--spacing)}.auto-rows-min{grid-auto-rows:min-content}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-center{align-items:center}.items-start{align-items:flex-start}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.gap-0\.5{gap:calc(var(--spacing) * .5)}.gap-1{gap:var(--spacing)}.gap-1\.5{gap:calc(var(--spacing) * 1.5)}.gap-2{gap:calc(var(--spacing) * 2)}.gap-3{gap:calc(var(--spacing) * 3)}.gap-4{gap:calc(var(--spacing) * 4)}.gap-6{gap:calc(var(--spacing) * 6)}.gap-x-3{column-gap:calc(var(--spacing) * 3)}.gap-x-4{column-gap:calc(var(--spacing) * 4)}.gap-x-6{column-gap:calc(var(--spacing) * 6)}.gap-y-1{row-gap:var(--spacing)}.gap-y-1\.5{row-gap:calc(var(--spacing) * 1.5)}.self-start{align-self:flex-start}.justify-self-end{justify-self:flex-end}.truncate{text-overflow:ellipsis;white-space:nowrap;overflow:hidden}.overflow-hidden{overflow:hidden}.overflow-x-auto{overflow-x:auto}.overflow-x-hidden{overflow-x:hidden}.overflow-y-auto{overflow-y:auto}.rounded{border-radius:.25rem}.rounded-4xl{border-radius:var(--radius-4xl)}.rounded-\[min\(var\(--radius-md\)\,10px\)\]{border-radius:min(var(--radius-md), 10px)}.rounded-\[min\(var\(--radius-md\)\,12px\)\]{border-radius:min(var(--radius-md), 12px)}.rounded-full{border-radius:2147483647px}.rounded-lg{border-radius:var(--radius)}.rounded-md{border-radius:calc(var(--radius) - 2px)}.rounded-xl{border-radius:calc(var(--radius) + 4px)}.rounded-t-xl{border-top-left-radius:calc(var(--radius) + 4px);border-top-right-radius:calc(var(--radius) + 4px)}.rounded-b-xl{border-bottom-right-radius:calc(var(--radius) + 4px);border-bottom-left-radius:calc(var(--radius) + 4px)}.border{border-style:var(--tw-border-style);border-width:1px}.border-t{border-top-style:var(--tw-border-style);border-top-width:1px}.border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.border-border{border-color:var(--border)}.border-input{border-color:var(--input)}.border-status-warn\/40{border-color:var(--status-warn)}@supports (color:color-mix(in lab, red, red)){.border-status-warn\/40{border-color:color-mix(in oklab, var(--status-warn) 40%, transparent)}}.border-transparent{border-color:#0000}.bg-background{background-color:var(--background)}.bg-border{background-color:var(--border)}.bg-card{background-color:var(--card)}.bg-destructive\/10{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.bg-destructive\/10{background-color:color-mix(in oklab, var(--destructive) 10%, transparent)}}.bg-muted,.bg-muted\/50{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.bg-muted\/50{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.bg-popover{background-color:var(--popover)}.bg-primary,.bg-primary\/10{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.bg-primary\/10{background-color:color-mix(in oklab, var(--primary) 10%, transparent)}}.bg-secondary{background-color:var(--secondary)}.bg-transparent{background-color:#0000}.bg-clip-padding{background-clip:padding-box}.p-0\.75{padding:calc(var(--spacing) * .75)}.p-1{padding:var(--spacing)}.p-2{padding:calc(var(--spacing) * 2)}.p-4{padding:calc(var(--spacing) * 4)}.px-1\.5{padding-inline:calc(var(--spacing) * 1.5)}.px-2{padding-inline:calc(var(--spacing) * 2)}.px-2\.5{padding-inline:calc(var(--spacing) * 2.5)}.px-3{padding-inline:calc(var(--spacing) * 3)}.px-4{padding-inline:calc(var(--spacing) * 4)}.py-0\.5{padding-block:calc(var(--spacing) * .5)}.py-1{padding-block:var(--spacing)}.py-2{padding-block:calc(var(--spacing) * 2)}.py-2\.5{padding-block:calc(var(--spacing) * 2.5)}.py-4{padding-block:calc(var(--spacing) * 4)}.py-6{padding-block:calc(var(--spacing) * 6)}.py-8{padding-block:calc(var(--spacing) * 8)}.py-10{padding-block:calc(var(--spacing) * 10)}.pt-0{padding-top:0}.pr-2{padding-right:calc(var(--spacing) * 2)}.pr-8{padding-right:calc(var(--spacing) * 8)}.pr-10{padding-right:calc(var(--spacing) * 10)}.pb-2\.5{padding-bottom:calc(var(--spacing) * 2.5)}.pl-1\.5{padding-left:calc(var(--spacing) * 1.5)}.pl-2\.5{padding-left:calc(var(--spacing) * 2.5)}.pl-8{padding-left:calc(var(--spacing) * 8)}.text-center{text-align:center}.text-left{text-align:left}.text-right{text-align:right}.align-middle{vertical-align:middle}.font-mono{font-family:ui-monospace,SF Mono,Cascadia Code,Roboto Mono,Consolas,monospace}.text-base{font-size:var(--text-base);line-height:var(--tw-leading,var(--text-base--line-height))}.text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-xl{font-size:var(--text-xl);line-height:var(--tw-leading,var(--text-xl--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.text-\[0\.8rem\]{font-size:.8rem}.leading-snug{--tw-leading:var(--leading-snug);line-height:var(--leading-snug)}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-normal{--tw-font-weight:var(--font-weight-normal);font-weight:var(--font-weight-normal)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.text-balance{text-wrap:balance}.break-all{word-break:break-all}.whitespace-nowrap{white-space:nowrap}.text-card-foreground{color:var(--card-foreground)}.text-chart-requests{color:var(--chart-requests)}.text-destructive{color:var(--destructive)}.text-foreground,.text-foreground\/60{color:var(--foreground)}@supports (color:color-mix(in lab, red, red)){.text-foreground\/60{color:color-mix(in oklab, var(--foreground) 60%, transparent)}}.text-muted-foreground,.text-muted-foreground\/60{color:var(--muted-foreground)}@supports (color:color-mix(in lab, red, red)){.text-muted-foreground\/60{color:color-mix(in oklab, var(--muted-foreground) 60%, transparent)}}.text-popover-foreground{color:var(--popover-foreground)}.text-primary{color:var(--primary)}.text-primary-foreground{color:var(--primary-foreground)}.text-secondary-foreground{color:var(--secondary-foreground)}.text-status-warn{color:var(--status-warn)}.lowercase{text-transform:lowercase}.tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,)}.underline-offset-4{text-underline-offset:4px}.shadow-md{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a), 0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ring,.ring-1{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ring-foreground\/10{--tw-ring-color:var(--foreground)}@supports (color:color-mix(in lab, red, red)){.ring-foreground\/10{--tw-ring-color:color-mix(in oklab, var(--foreground) 10%, transparent)}}.outline-hidden{--tw-outline-style:none;outline-style:none}@media (forced-colors:active){.outline-hidden{outline-offset:2px;outline:2px solid #0000}}.outline{outline-style:var(--tw-outline-style);outline-width:1px}.filter{filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.transition{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to,opacity,box-shadow,transform,translate,scale,rotate,filter,-webkit-backdrop-filter,backdrop-filter,display,content-visibility,overlay,pointer-events;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.duration-100{--tw-duration:.1s;transition-duration:.1s}.outline-none{--tw-outline-style:none;outline-style:none}.select-none{-webkit-user-select:none;user-select:none}.select-text{-webkit-user-select:text;user-select:text}.running{animation-play-state:running}.not-last\:border-b:not(:last-child){border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.group-has-\[\>svg\]\/alert\:col-start-2:is(:where(.group\/alert):has(>svg) *){grid-column-start:2}.group-aria-expanded\/accordion-trigger\:hidden:is(:where(.group\/accordion-trigger)[aria-expanded=true] *){display:none}.group-aria-expanded\/accordion-trigger\:inline:is(:where(.group\/accordion-trigger)[aria-expanded=true] *){display:inline}.group-data-\[size\=sm\]\/card\:p-3:is(:where(.group\/card)[data-size=sm] *){padding:calc(var(--spacing) * 3)}.group-data-\[size\=sm\]\/card\:px-3:is(:where(.group\/card)[data-size=sm] *){padding-inline:calc(var(--spacing) * 3)}.group-data-\[size\=sm\]\/card\:text-sm:is(:where(.group\/card)[data-size=sm] *){font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.group-data-\[variant\=line\]\/tabs-list\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *){background-color:#0000}.group-data-horizontal\/tabs\:h-8:is(:where(.group\/tabs):where([data-orientation=horizontal]) *){height:calc(var(--spacing) * 8)}.group-data-vertical\/tabs\:h-fit:is(:where(.group\/tabs):where([data-orientation=vertical]) *){height:fit-content}.group-data-vertical\/tabs\:w-full:is(:where(.group\/tabs):where([data-orientation=vertical]) *){width:100%}.group-data-vertical\/tabs\:flex-col:is(:where(.group\/tabs):where([data-orientation=vertical]) *){flex-direction:column}.group-data-vertical\/tabs\:justify-start:is(:where(.group\/tabs):where([data-orientation=vertical]) *){justify-content:flex-start}.file\:inline-flex::file-selector-button{display:inline-flex}.file\:h-6::file-selector-button{height:calc(var(--spacing) * 6)}.file\:border-0::file-selector-button{border-style:var(--tw-border-style);border-width:0}.file\:bg-transparent::file-selector-button{background-color:#0000}.file\:text-sm::file-selector-button{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.file\:font-medium::file-selector-button{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.file\:text-foreground::file-selector-button{color:var(--foreground)}.placeholder\:text-muted-foreground::placeholder{color:var(--muted-foreground)}.after\:absolute:after{content:var(--tw-content);position:absolute}.after\:bg-foreground:after{content:var(--tw-content);background-color:var(--foreground)}.after\:opacity-0:after{content:var(--tw-content);opacity:0}.after\:transition-opacity:after{content:var(--tw-content);transition-property:opacity;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.group-data-horizontal\/tabs\:after\:inset-x-0:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);inset-inline:0}.group-data-horizontal\/tabs\:after\:bottom-\[-5px\]:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);bottom:-5px}.group-data-horizontal\/tabs\:after\:h-0\.5:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);height:calc(var(--spacing) * .5)}.group-data-vertical\/tabs\:after\:inset-y-0:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);inset-block:0}.group-data-vertical\/tabs\:after\:-right-1:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);right:calc(var(--spacing) * -1)}.group-data-vertical\/tabs\:after\:w-0\.5:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);width:calc(var(--spacing) * .5)}@media (hover:hover){.hover\:bg-accent:hover{background-color:var(--accent)}.hover\:bg-destructive\/20:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.hover\:bg-destructive\/20:hover{background-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.hover\:bg-muted:hover,.hover\:bg-muted\/50:hover{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.hover\:bg-muted\/50:hover{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.hover\:bg-secondary\/80:hover{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){.hover\:bg-secondary\/80:hover{background-color:color-mix(in oklab, var(--secondary) 80%, transparent)}}.hover\:text-accent-foreground:hover{color:var(--accent-foreground)}.hover\:text-foreground:hover{color:var(--foreground)}.hover\:text-muted-foreground:hover{color:var(--muted-foreground)}.hover\:underline:hover{text-decoration-line:underline}}.focus\:bg-accent:focus{background-color:var(--accent)}.focus\:text-accent-foreground:focus,:is(.not-data-\[variant\=destructive\]\:focus\:\*\*\:text-accent-foreground:not([data-variant=destructive]):focus *){color:var(--accent-foreground)}.focus-visible\:border-destructive\/40:focus-visible{border-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.focus-visible\:border-destructive\/40:focus-visible{border-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}.focus-visible\:border-ring:focus-visible{border-color:var(--ring)}.focus-visible\:ring-3:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.focus-visible\:ring-destructive\/20:focus-visible{--tw-ring-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){.focus-visible\:ring-ring\/50:focus-visible{--tw-ring-color:color-mix(in oklab, var(--ring) 50%, transparent)}}.focus-visible\:outline-1:focus-visible{outline-style:var(--tw-outline-style);outline-width:1px}.focus-visible\:outline-ring:focus-visible{outline-color:var(--ring)}.focus-visible\:after\:border-ring:focus-visible:after{content:var(--tw-content);border-color:var(--ring)}.active\:not-aria-\[haspopup\]\:translate-y-px:active:not([aria-haspopup]){--tw-translate-y:1px;translate:var(--tw-translate-x) var(--tw-translate-y)}.disabled\:pointer-events-none:disabled{pointer-events:none}.disabled\:cursor-not-allowed:disabled{cursor:not-allowed}.disabled\:bg-input\/50:disabled{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.disabled\:bg-input\/50:disabled{background-color:color-mix(in oklab, var(--input) 50%, transparent)}}.disabled\:opacity-50:disabled{opacity:.5}:where([data-slot=button-group]) .in-data-\[slot\=button-group\]\:rounded-lg{border-radius:var(--radius)}.has-aria-expanded\:bg-muted\/50:has([aria-expanded=true]){background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.has-aria-expanded\:bg-muted\/50:has([aria-expanded=true]){background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.has-data-\[icon\=inline-end\]\:pr-1:has([data-icon=inline-end]){padding-right:var(--spacing)}.has-data-\[icon\=inline-end\]\:pr-1\.5:has([data-icon=inline-end]){padding-right:calc(var(--spacing) * 1.5)}.has-data-\[icon\=inline-end\]\:pr-2:has([data-icon=inline-end]){padding-right:calc(var(--spacing) * 2)}.has-data-\[icon\=inline-start\]\:pl-1:has([data-icon=inline-start]){padding-left:var(--spacing)}.has-data-\[icon\=inline-start\]\:pl-1\.5:has([data-icon=inline-start]){padding-left:calc(var(--spacing) * 1.5)}.has-data-\[icon\=inline-start\]\:pl-2:has([data-icon=inline-start]){padding-left:calc(var(--spacing) * 2)}.has-data-\[slot\=alert-action\]\:relative:has([data-slot=alert-action]){position:relative}.has-data-\[slot\=alert-action\]\:pr-18:has([data-slot=alert-action]){padding-right:calc(var(--spacing) * 18)}.has-data-\[slot\=card-action\]\:grid-cols-\[1fr_auto\]:has([data-slot=card-action]){grid-template-columns:1fr auto}.has-data-\[slot\=card-description\]\:grid-rows-\[auto_auto\]:has([data-slot=card-description]){grid-template-rows:auto auto}.has-data-\[slot\=card-footer\]\:pb-0:has([data-slot=card-footer]){padding-bottom:0}.has-\[\>img\:first-child\]\:pt-0:has(>img:first-child){padding-top:0}.has-\[\>svg\]\:grid-cols-\[auto_1fr\]:has(>svg){grid-template-columns:auto 1fr}.has-\[\>svg\]\:gap-x-2:has(>svg){column-gap:calc(var(--spacing) * 2)}.aria-expanded\:bg-muted[aria-expanded=true]{background-color:var(--muted)}.aria-expanded\:bg-secondary[aria-expanded=true]{background-color:var(--secondary)}.aria-expanded\:text-foreground[aria-expanded=true]{color:var(--foreground)}.aria-expanded\:text-secondary-foreground[aria-expanded=true]{color:var(--secondary-foreground)}.aria-invalid\:border-destructive[aria-invalid=true]{border-color:var(--destructive)}.aria-invalid\:ring-3[aria-invalid=true]{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(3px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.aria-invalid\:ring-destructive\/20[aria-invalid=true]{--tw-ring-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.data-placeholder\:text-muted-foreground[data-placeholder]{color:var(--muted-foreground)}.data-\[align-trigger\=true\]\:animate-none[data-align-trigger=true]{animation:none}.data-\[disabled\]\:pointer-events-none[data-disabled]{pointer-events:none}.data-\[disabled\]\:opacity-50[data-disabled]{opacity:.5}.data-\[position\=popper\]\:h-\(--reka-select-trigger-height\)[data-position=popper]{height:var(--reka-select-trigger-height)}.data-\[position\=popper\]\:w-full[data-position=popper]{width:100%}.data-\[position\=popper\]\:min-w-\(--reka-select-trigger-width\)[data-position=popper]{min-width:var(--reka-select-trigger-width)}.data-\[side\=bottom\]\:translate-y-1[data-side=bottom]{--tw-translate-y:var(--spacing);translate:var(--tw-translate-x) var(--tw-translate-y)}.data-\[side\=bottom\]\:slide-in-from-top-2[data-side=bottom]{--tw-enter-translate-y:calc(2*var(--spacing)*-1)}.data-\[side\=inline-end\]\:slide-in-from-left-2[data-side=inline-end]{--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.data-\[side\=inline-start\]\:slide-in-from-right-2[data-side=inline-start]{--tw-enter-translate-x:calc(2*var(--spacing))}.data-\[side\=left\]\:-translate-x-1[data-side=left]{--tw-translate-x:calc(var(--spacing) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.data-\[side\=left\]\:slide-in-from-right-2[data-side=left]{--tw-enter-translate-x:calc(2*var(--spacing))}.data-\[side\=right\]\:translate-x-1[data-side=right]{--tw-translate-x:var(--spacing);translate:var(--tw-translate-x) var(--tw-translate-y)}.data-\[side\=right\]\:slide-in-from-left-2[data-side=right]{--tw-enter-translate-x:calc(2*var(--spacing)*-1)}.data-\[side\=top\]\:-translate-y-1[data-side=top]{--tw-translate-y:calc(var(--spacing) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.data-\[side\=top\]\:slide-in-from-bottom-2[data-side=top]{--tw-enter-translate-y:calc(2*var(--spacing))}.data-\[size\=default\]\:h-8[data-size=default]{height:calc(var(--spacing) * 8)}.data-\[size\=sm\]\:h-7[data-size=sm]{height:calc(var(--spacing) * 7)}.data-\[size\=sm\]\:gap-3[data-size=sm]{gap:calc(var(--spacing) * 3)}.data-\[size\=sm\]\:rounded-\[min\(var\(--radius-md\)\,10px\)\][data-size=sm]{border-radius:min(var(--radius-md), 10px)}.data-\[size\=sm\]\:py-3[data-size=sm]{padding-block:calc(var(--spacing) * 3)}.data-\[size\=sm\]\:has-data-\[slot\=card-footer\]\:pb-0[data-size=sm]:has([data-slot=card-footer]){padding-bottom:0}:is(.\*\*\:data-\[slot\=accordion-trigger-icon\]\:ml-auto *)[data-slot=accordion-trigger-icon]{margin-left:auto}:is(.\*\*\:data-\[slot\=accordion-trigger-icon\]\:size-4 *)[data-slot=accordion-trigger-icon]{width:calc(var(--spacing) * 4);height:calc(var(--spacing) * 4)}:is(.\*\*\:data-\[slot\=accordion-trigger-icon\]\:text-muted-foreground *)[data-slot=accordion-trigger-icon]{color:var(--muted-foreground)}:is(.\*\:data-\[slot\=alert-description\]\:text-destructive\/90>*)[data-slot=alert-description]{color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){:is(.\*\:data-\[slot\=alert-description\]\:text-destructive\/90>*)[data-slot=alert-description]{color:color-mix(in oklab, var(--destructive) 90%, transparent)}}:is(.\*\:data-\[slot\=select-value\]\:line-clamp-1>*)[data-slot=select-value]{-webkit-line-clamp:1;-webkit-box-orient:vertical;display:-webkit-box;overflow:hidden}:is(.\*\:data-\[slot\=select-value\]\:flex>*)[data-slot=select-value]{display:flex}:is(.\*\:data-\[slot\=select-value\]\:items-center>*)[data-slot=select-value]{align-items:center}:is(.\*\:data-\[slot\=select-value\]\:gap-1\.5>*)[data-slot=select-value]{gap:calc(var(--spacing) * 1.5)}.data-\[state\=selected\]\:bg-muted[data-state=selected]{background-color:var(--muted)}.data-\[variant\=line\]\:rounded-none[data-variant=line]{border-radius:0}@media (width>=40rem){.sm\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.sm\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.sm\:flex-row{flex-direction:row}.sm\:items-center{align-items:center}.sm\:justify-between{justify-content:space-between}.sm\:px-6{padding-inline:calc(var(--spacing) * 6)}}@media (width>=48rem){.md\:text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.md\:text-pretty{text-wrap:pretty}}@media (width>=64rem){.lg\:px-8{padding-inline:calc(var(--spacing) * 8)}}@media (prefers-color-scheme:dark){.dark\:border-input{border-color:var(--input)}.dark\:bg-destructive\/20{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:bg-destructive\/20{background-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.dark\:bg-input\/30{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:bg-input\/30{background-color:color-mix(in oklab, var(--input) 30%, transparent)}}.dark\:text-muted-foreground{color:var(--muted-foreground)}@media (hover:hover){.dark\:hover\:bg-destructive\/30:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:hover\:bg-destructive\/30:hover{background-color:color-mix(in oklab, var(--destructive) 30%, transparent)}}.dark\:hover\:bg-input\/50:hover{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:hover\:bg-input\/50:hover{background-color:color-mix(in oklab, var(--input) 50%, transparent)}}.dark\:hover\:bg-muted\/50:hover{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.dark\:hover\:bg-muted\/50:hover{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.dark\:hover\:text-foreground:hover{color:var(--foreground)}}.dark\:focus-visible\:ring-destructive\/40:focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:focus-visible\:ring-destructive\/40:focus-visible{--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}.dark\:disabled\:bg-input\/80:disabled{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:disabled\:bg-input\/80:disabled{background-color:color-mix(in oklab, var(--input) 80%, transparent)}}.dark\:aria-invalid\:border-destructive\/50[aria-invalid=true]{border-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:aria-invalid\:border-destructive\/50[aria-invalid=true]{border-color:color-mix(in oklab, var(--destructive) 50%, transparent)}}.dark\:aria-invalid\:ring-destructive\/40[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:aria-invalid\:ring-destructive\/40[aria-invalid=true]{--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}}.data-open\:animate-accordion-down:where([data-state=open]),.data-open\:animate-accordion-down:where([data-open]:not([data-open=false])){animation:accordion-down var(--tw-animation-duration,var(--tw-duration,.2s))var(--tw-ease,ease-out)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-open\:animate-in:where([data-state=open]),.data-open\:animate-in:where([data-open]:not([data-open=false])){animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-open\:fade-in-0:where([data-state=open]),.data-open\:fade-in-0:where([data-open]:not([data-open=false])){--tw-enter-opacity:0}.data-open\:zoom-in-95:where([data-state=open]),.data-open\:zoom-in-95:where([data-open]:not([data-open=false])){--tw-enter-scale:.95}.data-closed\:animate-accordion-up:where([data-state=closed]),.data-closed\:animate-accordion-up:where([data-closed]:not([data-closed=false])){animation:accordion-up var(--tw-animation-duration,var(--tw-duration,.2s))var(--tw-ease,ease-out)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-closed\:animate-out:where([data-state=closed]),.data-closed\:animate-out:where([data-closed]:not([data-closed=false])){animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-closed\:fade-out-0:where([data-state=closed]),.data-closed\:fade-out-0:where([data-closed]:not([data-closed=false])){--tw-exit-opacity:0}.data-closed\:zoom-out-95:where([data-state=closed]),.data-closed\:zoom-out-95:where([data-closed]:not([data-closed=false])){--tw-exit-scale:.95}.data-active\:bg-background:where([data-state=active]),.data-active\:bg-background:where([data-active]:not([data-active=false])){background-color:var(--background)}.data-active\:text-foreground:where([data-state=active]),.data-active\:text-foreground:where([data-active]:not([data-active=false])){color:var(--foreground)}.group-data-\[variant\=default\]\/tabs-list\:data-active\:shadow-sm:is(:where(.group\/tabs-list)[data-variant=default] *):where([data-state=active]),.group-data-\[variant\=default\]\/tabs-list\:data-active\:shadow-sm:is(:where(.group\/tabs-list)[data-variant=default] *):where([data-active]:not([data-active=false])){--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){background-color:#0000}.group-data-\[variant\=line\]\/tabs-list\:data-active\:shadow-none:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.group-data-\[variant\=line\]\/tabs-list\:data-active\:shadow-none:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){--tw-shadow:0 0 #0000;box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}:is(.group-data-\[variant\=line\]\/tabs-list\:data-active\:after\:opacity-100:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.group-data-\[variant\=line\]\/tabs-list\:data-active\:after\:opacity-100:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false]))):after{content:var(--tw-content);opacity:1}@media (prefers-color-scheme:dark){.dark\:data-active\:border-input:where([data-state=active]),.dark\:data-active\:border-input:where([data-active]:not([data-active=false])){border-color:var(--input)}.dark\:data-active\:bg-input\/30:where([data-state=active]),.dark\:data-active\:bg-input\/30:where([data-active]:not([data-active=false])){background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:data-active\:bg-input\/30:where([data-state=active]),.dark\:data-active\:bg-input\/30:where([data-active]:not([data-active=false])){background-color:color-mix(in oklab, var(--input) 30%, transparent)}}.dark\:data-active\:text-foreground:where([data-state=active]),.dark\:data-active\:text-foreground:where([data-active]:not([data-active=false])){color:var(--foreground)}.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:border-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:border-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){border-color:#0000}.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){background-color:#0000}}.data-horizontal\:flex-col:where([data-orientation=horizontal]){flex-direction:column}.\[\&_a\]\:underline a{text-decoration-line:underline}.\[\&_a\]\:underline-offset-3 a{text-underline-offset:3px}@media (hover:hover){.\[\&_a\]\:hover\:text-foreground a:hover{color:var(--foreground)}}.\[\&_p\:not\(\:last-child\)\]\:mb-4 p:not(:last-child){margin-bottom:calc(var(--spacing) * 4)}.\[\&_svg\]\:pointer-events-none svg{pointer-events:none}.\[\&_svg\]\:shrink-0 svg{flex-shrink:0}.\[\&_svg\:not\(\[class\*\=size-\]\)\]\:size-3 svg:not([class*=size-]){width:calc(var(--spacing) * 3);height:calc(var(--spacing) * 3)}.\[\&_svg\:not\(\[class\*\=size-\]\)\]\:size-3\.5 svg:not([class*=size-]){width:calc(var(--spacing) * 3.5);height:calc(var(--spacing) * 3.5)}.\[\&_svg\:not\(\[class\*\=size-\]\)\]\:size-4 svg:not([class*=size-]){width:calc(var(--spacing) * 4);height:calc(var(--spacing) * 4)}.\[\&_tr\]\:border-b tr{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.\[\&_tr\:last-child\]\:border-0 tr:last-child{border-style:var(--tw-border-style);border-width:0}.\[\&\:has\(\[role\=checkbox\]\)\]\:pr-0:has([role=checkbox]){padding-right:0}.\[\.border-b\]\:pb-4.border-b{padding-bottom:calc(var(--spacing) * 4)}.group-data-\[size\=sm\]\/card\:\[\.border-b\]\:pb-3:is(:where(.group\/card)[data-size=sm] *).border-b{padding-bottom:calc(var(--spacing) * 3)}@media (hover:hover){.\[a\]\:hover\:bg-destructive\/20:is(a):hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.\[a\]\:hover\:bg-destructive\/20:is(a):hover{background-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.\[a\]\:hover\:bg-muted:is(a):hover{background-color:var(--muted)}.\[a\]\:hover\:bg-primary\/80:is(a):hover{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.\[a\]\:hover\:bg-primary\/80:is(a):hover{background-color:color-mix(in oklab, var(--primary) 80%, transparent)}}.\[a\]\:hover\:bg-secondary\/80:is(a):hover{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){.\[a\]\:hover\:bg-secondary\/80:is(a):hover{background-color:color-mix(in oklab, var(--secondary) 80%, transparent)}}.\[a\]\:hover\:text-muted-foreground:is(a):hover{color:var(--muted-foreground)}}:is(.\*\:\[img\:first-child\]\:rounded-t-xl>*):is(img:first-child){border-top-left-radius:calc(var(--radius) + 4px);border-top-right-radius:calc(var(--radius) + 4px)}:is(.\*\:\[img\:last-child\]\:rounded-b-xl>*):is(img:last-child){border-bottom-right-radius:calc(var(--radius) + 4px);border-bottom-left-radius:calc(var(--radius) + 4px)}:is(.\*\:\[span\]\:last\:flex>*):is(span):last-child{display:flex}:is(.\*\:\[span\]\:last\:items-center>*):is(span):last-child{align-items:center}:is(.\*\:\[span\]\:last\:gap-2>*):is(span):last-child{gap:calc(var(--spacing) * 2)}:is(.\*\:\[svg\]\:row-span-2>*):is(svg){grid-row:span 2/span 2}:is(.\*\:\[svg\]\:translate-y-0\.5>*):is(svg){--tw-translate-y:calc(var(--spacing) * .5);translate:var(--tw-translate-x) var(--tw-translate-y)}:is(.\*\:\[svg\]\:text-current>*):is(svg){color:currentColor}:is(.\*\:\[svg\:not\(\[class\*\=size-\]\)\]\:size-4>*):is(svg:not([class*=size-])){width:calc(var(--spacing) * 4);height:calc(var(--spacing) * 4)}.\[\&\>svg\]\:pointer-events-none>svg{pointer-events:none}.\[\&\>svg\]\:size-3\!>svg{width:calc(var(--spacing) * 3)!important;height:calc(var(--spacing) * 3)!important}.\[\&\>tr\]\:last\:border-b-0>tr:last-child{border-bottom-style:var(--tw-border-style);border-bottom-width:0}}@property --tw-animation-delay{syntax:"*";inherits:false;initial-value:0s}@property --tw-animation-direction{syntax:"*";inherits:false;initial-value:normal}@property --tw-animation-duration{syntax:"*";inherits:false}@property --tw-animation-fill-mode{syntax:"*";inherits:false;initial-value:none}@property --tw-animation-iteration-count{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-translate-y{syntax:"*";inherits:false;initial-value:0}@property --scroll-fade-t{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-b{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-s{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-e{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-mask{syntax:"*";inherits:false}@property --shimmer-angle{syntax:"<angle>";inherits:true;initial-value:20deg}@property --shimmer-image{syntax:"*";inherits:false}@property --shimmer-text-fill{syntax:"*";inherits:false}@media (prefers-reduced-motion:reduce){.shimmer{-webkit-text-fill-color:currentColor;background-image:none;animation:none}}:root{--background:oklch(99% .004 75);--foreground:oklch(19% .012 75);--card:oklch(99.5% .003 75);--card-foreground:oklch(19% .012 75);--popover:oklch(99.5% .003 75);--popover-foreground:oklch(19% .012 75);--primary:oklch(46% .09 200);--primary-foreground:oklch(98% .006 200);--secondary:oklch(95% .006 75);--secondary-foreground:oklch(22% .01 75);--muted:oklch(95% .006 75);--muted-foreground:oklch(48% .012 75);--accent:oklch(93% .02 200);--accent-foreground:oklch(28% .05 200);--destructive:oklch(55% .2 25);--border:oklch(90% .007 75);--input:oklch(90% .007 75);--ring:oklch(55% .09 200);--radius:.375rem;--chart-requests:#009e73;--chart-tokens-in:#0072b2;--chart-tokens-out:#e69f00;--chart-cost:#d55e00;--status-warn:#a35c00}@media (prefers-color-scheme:dark){:root{--background:oklch(17% .007 75);--foreground:oklch(95% .005 75);--card:oklch(21% .009 75);--card-foreground:oklch(95% .005 75);--popover:oklch(21% .009 75);--popover-foreground:oklch(95% .005 75);--primary:oklch(74% .11 200);--primary-foreground:oklch(16% .012 200);--secondary:oklch(27% .011 75);--secondary-foreground:oklch(93% .005 75);--muted:oklch(27% .011 75);--muted-foreground:oklch(68% .012 75);--accent:oklch(32% .035 200);--accent-foreground:oklch(91% .03 200);--destructive:oklch(68% .19 25);--border:oklch(100% 0 0/.12);--input:oklch(100% 0 0/.16);--ring:oklch(62% .1 200);--chart-requests:#16b891;--chart-tokens-in:#4098d7;--chart-tokens-out:#f0ac1f;--chart-cost:#e8763a;--status-warn:#f0ac1f}}@property --tw-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-translate-z{syntax:"*";inherits:false;initial-value:0}@property --tw-rotate-x{syntax:"*";inherits:false}@property --tw-rotate-y{syntax:"*";inherits:false}@property --tw-rotate-z{syntax:"*";inherits:false}@property --tw-skew-x{syntax:"*";inherits:false}@property --tw-skew-y{syntax:"*";inherits:false}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-leading{syntax:"*";inherits:false}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-ordinal{syntax:"*";inherits:false}@property --tw-slashed-zero{syntax:"*";inherits:false}@property --tw-numeric-figure{syntax:"*";inherits:false}@property --tw-numeric-spacing{syntax:"*";inherits:false}@property --tw-numeric-fraction{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"<length>";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-outline-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-blur{syntax:"*";inherits:false}@property --tw-brightness{syntax:"*";inherits:false}@property --tw-contrast{syntax:"*";inherits:false}@property --tw-grayscale{syntax:"*";inherits:false}@property --tw-hue-rotate{syntax:"*";inherits:false}@property --tw-invert{syntax:"*";inherits:false}@property --tw-opacity{syntax:"*";inherits:false}@property --tw-saturate{syntax:"*";inherits:false}@property --tw-sepia{syntax:"*";inherits:false}@property --tw-drop-shadow{syntax:"*";inherits:false}@property --tw-drop-shadow-color{syntax:"*";inherits:false}@property --tw-drop-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-drop-shadow-size{syntax:"*";inherits:false}@property --tw-duration{syntax:"*";inherits:false}@property --tw-content{syntax:"*";inherits:false;initial-value:""}@keyframes enter{0%{opacity:var(--tw-enter-opacity,1);transform:translate3d(var(--tw-enter-translate-x,0),var(--tw-enter-translate-y,0),0)scale3d(var(--tw-enter-scale,1),var(--tw-enter-scale,1),var(--tw-enter-scale,1))rotate(var(--tw-enter-rotate,0));filter:blur(var(--tw-enter-blur,0))}}@keyframes exit{to{opacity:var(--tw-exit-opacity,1);transform:translate3d(var(--tw-exit-translate-x,0),var(--tw-exit-translate-y,0),0)scale3d(var(--tw-exit-scale,1),var(--tw-exit-scale,1),var(--tw-exit-scale,1))rotate(var(--tw-exit-rotate,0));filter:blur(var(--tw-exit-blur,0))}}@keyframes accordion-down{0%{height:0}to{height:var(--reka-accordion-content-height,var(--accordion-panel-height,auto))}}@keyframes accordion-up{0%{height:var(--reka-accordion-content-height,var(--accordion-panel-height,auto))}to{height:0}}
", ), }, - "index-CwP_MbOb.js": { + "index-Cn6vEAjP.js": { contentType: "text/javascript; charset=utf-8", body: decodeAdminAsset( - "var e=Object.defineProperty,t=(t,n)=>{let r={};for(var i in t)e(r,i,{get:t[i],enumerable:!0});return n||e(r,Symbol.toStringTag,{value:`Module`}),r};function n(e){let t=Object.create(null);for(let n of e.split(`,`))t[n]=1;return e=>e in t}var r={},i=[],a=()=>{},o=()=>!1,s=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&(e.charCodeAt(2)>122||e.charCodeAt(2)<97),c=e=>e.startsWith(`onUpdate:`),l=Object.assign,u=(e,t)=>{let n=e.indexOf(t);n>-1&&e.splice(n,1)},d=Object.prototype.hasOwnProperty,f=(e,t)=>d.call(e,t),p=Array.isArray,m=e=>w(e)===`[object Map]`,h=e=>w(e)===`[object Set]`,g=e=>w(e)===`[object Date]`,_=e=>w(e)===`[object RegExp]`,v=e=>typeof e==`function`,y=e=>typeof e==`string`,b=e=>typeof e==`symbol`,x=e=>typeof e==`object`&&!!e,S=e=>(x(e)||v(e))&&v(e.then)&&v(e.catch),C=Object.prototype.toString,w=e=>C.call(e),ee=e=>w(e).slice(8,-1),te=e=>w(e)===`[object Object]`,T=e=>y(e)&&e!==`NaN`&&e[0]!==`-`&&``+parseInt(e,10)===e,ne=n(`,key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted`),re=e=>{let t=Object.create(null);return(n=>t[n]||(t[n]=e(n)))},ie=/-\w/g,E=re(e=>e.replace(ie,e=>e.slice(1).toUpperCase())),ae=/\B([A-Z])/g,oe=re(e=>e.replace(ae,`-$1`).toLowerCase()),se=re(e=>e.charAt(0).toUpperCase()+e.slice(1)),ce=re(e=>e?`on${se(e)}`:``),D=(e,t)=>!Object.is(e,t),le=(e,...t)=>{for(let n=0;n<e.length;n++)e[n](...t)},ue=(e,t,n,r=!1)=>{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:r,value:n})},de=e=>{let t=parseFloat(e);return isNaN(t)?e:t},fe=e=>{let t=y(e)?Number(e):NaN;return isNaN(t)?e:t},pe,me=()=>pe||=typeof globalThis<`u`?globalThis:typeof self<`u`?self:typeof window<`u`?window:typeof global<`u`?global:{},he=n(`Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol`);function ge(e){if(p(e)){let t={};for(let n=0;n<e.length;n++){let r=e[n],i=y(r)?be(r):ge(r);if(i)for(let e in i)t[e]=i[e]}return t}if(y(e)||x(e))return e}var _e=/;(?![^(]*\))/g,ve=/:([^]+)/,ye=/\/\*[^]*?\*\//g;function be(e){let t={};return e.replace(ye,``).split(_e).forEach(e=>{if(e){let n=e.split(ve);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}function O(e){let t=``;if(y(e))t=e;else if(p(e))for(let n=0;n<e.length;n++){let r=O(e[n]);r&&(t+=r+` `)}else if(x(e))for(let n in e)e[n]&&(t+=n+` `);return t.trim()}function xe(e){if(!e)return null;let{class:t,style:n}=e;return t&&!y(t)&&(e.class=O(t)),n&&(e.style=ge(n)),e}var Se=`itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`,Ce=n(Se);Se+``;function we(e){return!!e||e===``}function Te(e,t){if(e.length!==t.length)return!1;let n=!0;for(let r=0;n&&r<e.length;r++)n=Ee(e[r],t[r]);return n}function Ee(e,t){if(e===t)return!0;let n=g(e),r=g(t);if(n||r)return n&&r?e.getTime()===t.getTime():!1;if(n=b(e),r=b(t),n||r)return e===t;if(n=p(e),r=p(t),n||r)return n&&r?Te(e,t):!1;if(n=x(e),r=x(t),n||r){if(!n||!r||Object.keys(e).length!==Object.keys(t).length)return!1;for(let n in e){let r=e.hasOwnProperty(n),i=t.hasOwnProperty(n);if(r&&!i||!r&&i||!Ee(e[n],t[n]))return!1}}return String(e)===String(t)}function De(e,t){return e.findIndex(e=>Ee(e,t))}var Oe=e=>!!(e&&e.__v_isRef===!0),k=e=>y(e)?e:e==null?``:p(e)||x(e)&&(e.toString===C||!v(e.toString))?Oe(e)?k(e.value):JSON.stringify(e,ke,2):String(e),ke=(e,t)=>Oe(t)?ke(e,t.value):m(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((e,[t,n],r)=>(e[Ae(t,r)+` =>`]=n,e),{})}:h(t)?{[`Set(${t.size})`]:[...t.values()].map(e=>Ae(e))}:b(t)?Ae(t):x(t)&&!p(t)&&!te(t)?String(t):t,Ae=(e,t=``)=>b(e)?`Symbol(${e.description??t})`:e;function je(e){return e==null?`initial`:typeof e==`string`?e===``?` `:e:String(e)}var Me,Ne=class{constructor(e=!1){this.detached=e,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this._warnOnRun=!0,this.__v_skip=!0,!e&&Me&&(Me.active?(this.parent=Me,this.index=(Me.scopes||(Me.scopes=[])).push(this)-1):(this._active=!1,this._warnOnRun=!1))}get active(){return this._active}pause(){if(this._active){this._isPaused=!0;let e,t;if(this.scopes){let n=this.scopes.slice();for(e=0,t=n.length;e<t;e++)n[e].pause()}for(e=0,t=this.effects.length;e<t;e++)this.effects[e].pause()}}resume(){if(this._active&&this._isPaused){this._isPaused=!1;let e,t;if(this.scopes){let n=this.scopes.slice();for(e=0,t=n.length;e<t;e++)n[e].resume()}let n=this.effects.slice();for(e=0,t=n.length;e<t;e++)n[e].resume()}}run(e){if(this._active){let t=Me;try{return Me=this,e()}finally{Me=t}}}on(){++this._on===1&&(this.prevScope=Me,Me=this)}off(){if(this._on>0&&--this._on===0){if(Me===this)Me=this.prevScope;else{let e=Me;for(;e;){if(e.prevScope===this){e.prevScope=this.prevScope;break}e=e.prevScope}}this.prevScope=void 0}}stop(e){if(this._active){this._active=!1;let t,n;for(t=0,n=this.effects.length;t<n;t++)this.effects[t].stop();for(this.effects.length=0,t=0,n=this.cleanups.length;t<n;t++)this.cleanups[t]();if(this.cleanups.length=0,this.scopes){let e=this.scopes.slice();for(t=0,n=e.length;t<n;t++)e[t].stop(!0);this.scopes.length=0}if(!this.detached&&this.parent&&!e){let e=this.parent.scopes.pop();e&&e!==this&&(this.parent.scopes[this.index]=e,e.index=this.index)}this.parent=void 0}}};function Pe(e){return new Ne(e)}function Fe(){return Me}function Ie(e,t=!1){Me&&Me.cleanups.push(e)}var Le,Re=new WeakSet,ze=class{constructor(e){this.fn=e,this.deps=void 0,this.depsTail=void 0,this.flags=5,this.next=void 0,this.cleanup=void 0,this.scheduler=void 0,Me&&(Me.active?Me.effects.push(this):this.flags&=-2)}pause(){this.flags|=64}resume(){this.flags&64&&(this.flags&=-65,Re.has(this)&&(Re.delete(this),this.trigger()))}notify(){this.flags&2&&!(this.flags&32)||this.flags&8||Ue(this)}run(){if(!(this.flags&1))return this.fn();this.flags|=2,it(this),Ke(this);let e=Le,t=et;Le=this,et=!0;try{return this.fn()}finally{qe(this),Le=e,et=t,this.flags&=-3}}stop(){if(this.flags&1){for(let e=this.deps;e;e=e.nextDep)Xe(e);this.deps=this.depsTail=void 0,it(this),this.onStop&&this.onStop(),this.flags&=-2}}trigger(){this.flags&64?Re.add(this):this.scheduler?this.scheduler():this.runIfDirty()}runIfDirty(){Je(this)&&this.run()}get dirty(){return Je(this)}},Be=0,Ve,He;function Ue(e,t=!1){if(e.flags|=8,t){e.next=He,He=e;return}e.next=Ve,Ve=e}function We(){Be++}function Ge(){if(--Be>0)return;if(He){let e=He;for(He=void 0;e;){let t=e.next;e.next=void 0,e.flags&=-9,e=t}}let e;for(;Ve;){let t=Ve;for(Ve=void 0;t;){let n=t.next;if(t.next=void 0,t.flags&=-9,t.flags&1)try{t.trigger()}catch(t){e||=t}t=n}}if(e)throw e}function Ke(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function qe(e){let t,n=e.depsTail,r=n;for(;r;){let e=r.prevDep;r.version===-1?(r===n&&(n=e),Xe(r),Ze(r)):t=r,r.dep.activeLink=r.prevActiveLink,r.prevActiveLink=void 0,r=e}e.deps=t,e.depsTail=n}function Je(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(Ye(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function Ye(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===at)||(e.globalVersion=at,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!Je(e))))return;e.flags|=2;let t=e.dep,n=Le,r=et;Le=e,et=!0;try{Ke(e);let n=e.fn(e._value);(t.version===0||D(n,e._value))&&(e.flags|=128,e._value=n,t.version++)}catch(e){throw t.version++,e}finally{Le=n,et=r,qe(e),e.flags&=-3}}function Xe(e,t=!1){let{dep:n,prevSub:r,nextSub:i}=e;if(r&&(r.nextSub=i,e.prevSub=void 0),i&&(i.prevSub=r,e.nextSub=void 0),n.subs===e&&(n.subs=r,!r&&n.computed)){n.computed.flags&=-5;for(let e=n.computed.deps;e;e=e.nextDep)Xe(e,!0)}!t&&!--n.sc&&n.map&&n.map.delete(n.key)}function Ze(e){let{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}function Qe(e,t){e.effect instanceof ze&&(e=e.effect.fn);let n=new ze(e);t&&l(n,t);try{n.run()}catch(e){throw n.stop(),e}let r=n.run.bind(n);return r.effect=n,r}function $e(e){e.effect.stop()}var et=!0,tt=[];function nt(){tt.push(et),et=!1}function rt(){let e=tt.pop();et=e===void 0||e}function it(e){let{cleanup:t}=e;if(e.cleanup=void 0,t){let e=Le;Le=void 0;try{t()}finally{Le=e}}}var at=0,ot=class{constructor(e,t){this.sub=e,this.dep=t,this.version=t.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}},st=class{constructor(e){this.computed=e,this.version=0,this.activeLink=void 0,this.subs=void 0,this.map=void 0,this.key=void 0,this.sc=0,this.__v_skip=!0}track(e){if(!Le||!et||Le===this.computed)return;let t=this.activeLink;if(t===void 0||t.sub!==Le)t=this.activeLink=new ot(Le,this),Le.deps?(t.prevDep=Le.depsTail,Le.depsTail.nextDep=t,Le.depsTail=t):Le.deps=Le.depsTail=t,ct(t);else if(t.version===-1&&(t.version=this.version,t.nextDep)){let e=t.nextDep;e.prevDep=t.prevDep,t.prevDep&&(t.prevDep.nextDep=e),t.prevDep=Le.depsTail,t.nextDep=void 0,Le.depsTail.nextDep=t,Le.depsTail=t,Le.deps===t&&(Le.deps=e)}return t}trigger(e){this.version++,at++,this.notify(e)}notify(e){We();try{for(let e=this.subs;e;e=e.prevSub)e.sub.notify()&&e.sub.dep.notify()}finally{Ge()}}};function ct(e){if(e.dep.sc++,e.sub.flags&4){let t=e.dep.computed;if(t&&!e.dep.subs){t.flags|=20;for(let e=t.deps;e;e=e.nextDep)ct(e)}let n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}var lt=new WeakMap,ut=Symbol(``),dt=Symbol(``),ft=Symbol(``);function pt(e,t,n){if(et&&Le){let t=lt.get(e);t||lt.set(e,t=new Map);let r=t.get(n);r||(t.set(n,r=new st),r.map=t,r.key=n),r.track()}}function mt(e,t,n,r,i,a){let o=lt.get(e);if(!o){at++;return}let s=e=>{e&&e.trigger()};if(We(),t===`clear`)o.forEach(s);else{let i=p(e),a=i&&T(n);if(i&&n===`length`){let e=Number(r);o.forEach((t,n)=>{(n===`length`||n===ft||!b(n)&&n>=e)&&s(t)})}else switch((n!==void 0||o.has(void 0))&&s(o.get(n)),a&&s(o.get(ft)),t){case`add`:i?a&&s(o.get(`length`)):(s(o.get(ut)),m(e)&&s(o.get(dt)));break;case`delete`:i||(s(o.get(ut)),m(e)&&s(o.get(dt)));break;case`set`:m(e)&&s(o.get(ut))}}Ge()}function ht(e,t){let n=lt.get(e);return n&&n.get(t)}function gt(e){let t=A(e);return t===e?t:(pt(t,`iterate`,ft),an(e)?t:t.map(cn))}function _t(e){return pt(e=A(e),`iterate`,ft),e}function vt(e,t){return rn(e)?ln(nn(e)?cn(t):t):cn(t)}var yt={__proto__:null,[Symbol.iterator](){return bt(this,Symbol.iterator,e=>vt(this,e))},concat(...e){return gt(this).concat(...e.map(e=>p(e)?gt(e):e))},entries(){return bt(this,`entries`,e=>(e[1]=vt(this,e[1]),e))},every(e,t){return St(this,`every`,e,t,void 0,arguments)},filter(e,t){return St(this,`filter`,e,t,e=>e.map(e=>vt(this,e)),arguments)},find(e,t){return St(this,`find`,e,t,e=>vt(this,e),arguments)},findIndex(e,t){return St(this,`findIndex`,e,t,void 0,arguments)},findLast(e,t){return St(this,`findLast`,e,t,e=>vt(this,e),arguments)},findLastIndex(e,t){return St(this,`findLastIndex`,e,t,void 0,arguments)},forEach(e,t){return St(this,`forEach`,e,t,void 0,arguments)},includes(...e){return wt(this,`includes`,e)},indexOf(...e){return wt(this,`indexOf`,e)},join(e){return gt(this).join(e)},lastIndexOf(...e){return wt(this,`lastIndexOf`,e)},map(e,t){return St(this,`map`,e,t,void 0,arguments)},pop(){return Tt(this,`pop`)},push(...e){return Tt(this,`push`,e)},reduce(e,...t){return Ct(this,`reduce`,e,t)},reduceRight(e,...t){return Ct(this,`reduceRight`,e,t)},shift(){return Tt(this,`shift`)},some(e,t){return St(this,`some`,e,t,void 0,arguments)},splice(...e){return Tt(this,`splice`,e)},toReversed(){return gt(this).toReversed()},toSorted(e){return gt(this).toSorted(e)},toSpliced(...e){return gt(this).toSpliced(...e)},unshift(...e){return Tt(this,`unshift`,e)},values(){return bt(this,`values`,e=>vt(this,e))}};function bt(e,t,n){let r=_t(e),i=r[t]();return r!==e&&!an(e)&&(i._next=i.next,i.next=()=>{let e=i._next();return e.done||(e.value=n(e.value)),e}),i}var xt=Array.prototype;function St(e,t,n,r,i,a){let o=_t(e),s=o!==e&&!an(e),c=o[t];if(c!==xt[t]){let t=c.apply(e,a);return s?cn(t):t}let l=n;o!==e&&(s?l=function(t,r){return n.call(this,vt(e,t),r,e)}:n.length>2&&(l=function(t,r){return n.call(this,t,r,e)}));let u=c.call(o,l,r);return s&&i?i(u):u}function Ct(e,t,n,r){let i=_t(e),a=i!==e&&!an(e),o=n,s=!1;i!==e&&(a?(s=r.length===0,o=function(t,r,i){return s&&(s=!1,t=vt(e,t)),n.call(this,t,vt(e,r),i,e)}):n.length>3&&(o=function(t,r,i){return n.call(this,t,r,i,e)}));let c=i[t](o,...r);return s?vt(e,c):c}function wt(e,t,n){let r=A(e);pt(r,`iterate`,ft);let i=r[t](...n);return(i===-1||i===!1)&&on(n[0])?(n[0]=A(n[0]),r[t](...n)):i}function Tt(e,t,n=[]){nt(),We();let r=A(e)[t].apply(e,n);return Ge(),rt(),r}var Et=n(`__proto__,__v_isRef,__isVue`),Dt=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!==`arguments`&&e!==`caller`).map(e=>Symbol[e]).filter(b));function Ot(e){b(e)||(e=String(e));let t=A(this);return pt(t,`has`,e),t.hasOwnProperty(e)}var kt=class{constructor(e=!1,t=!1){this._isReadonly=e,this._isShallow=t}get(e,t,n){if(t===`__v_skip`)return e.__v_skip;let r=this._isReadonly,i=this._isShallow;if(t===`__v_isReactive`)return!r;if(t===`__v_isReadonly`)return r;if(t===`__v_isShallow`)return i;if(t===`__v_raw`)return n===(r?i?Yt:Jt:i?qt:Kt).get(e)||Object.getPrototypeOf(e)===Object.getPrototypeOf(n)?e:void 0;let a=p(e);if(!r){let e;if(a&&(e=yt[t]))return e;if(t===`hasOwnProperty`)return Ot}let o=Reflect.get(e,t,j(e)?e:n);if((b(t)?Dt.has(t):Et(t))||(r||pt(e,`get`,t),i))return o;if(j(o)){let e=a&&T(t)?o:o.value;return r&&x(e)?$t(e):e}return x(o)?r?$t(o):Zt(o):o}},At=class extends kt{constructor(e=!1){super(!1,e)}set(e,t,n,r){let i=e[t],a=p(e)&&T(t);if(!this._isShallow){let e=rn(i);if(!an(n)&&!rn(n)&&(i=A(i),n=A(n)),!a&&j(i)&&!j(n))return e||(i.value=n),!0}let o=a?Number(t)<e.length:f(e,t),s=Reflect.set(e,t,n,j(e)?e:r);return e===A(r)&&s&&(o?D(n,i)&&mt(e,`set`,t,n,i):mt(e,`add`,t,n)),s}deleteProperty(e,t){let n=f(e,t),r=e[t],i=Reflect.deleteProperty(e,t);return i&&n&&mt(e,`delete`,t,void 0,r),i}has(e,t){let n=Reflect.has(e,t);return(!b(t)||!Dt.has(t))&&pt(e,`has`,t),n}ownKeys(e){return pt(e,`iterate`,p(e)?`length`:ut),Reflect.ownKeys(e)}},jt=class extends kt{constructor(e=!1){super(!0,e)}set(e,t){return!0}deleteProperty(e,t){return!0}},Mt=new At,Nt=new jt,Pt=new At(!0),Ft=new jt(!0),It=e=>e,Lt=e=>Reflect.getPrototypeOf(e);function Rt(e,t,n){return function(...r){let i=this.__v_raw,a=A(i),o=m(a),s=e===`entries`||e===Symbol.iterator&&o,c=e===`keys`&&o,u=i[e](...r),d=n?It:t?ln:cn;return!t&&pt(a,`iterate`,c?dt:ut),l(Object.create(u),{next(){let{value:e,done:t}=u.next();return t?{value:e,done:t}:{value:s?[d(e[0]),d(e[1])]:d(e),done:t}}})}}function zt(e){return function(...t){return e===`delete`?!1:e===`clear`?void 0:this}}function Bt(e,t){let n={get(n){let r=this.__v_raw,i=A(r),a=A(n);e||(D(n,a)&&pt(i,`get`,n),pt(i,`get`,a));let{has:o}=Lt(i),s=t?It:e?ln:cn;if(o.call(i,n))return s(r.get(n));if(o.call(i,a))return s(r.get(a));r!==i&&r.get(n)},get size(){let t=this.__v_raw;return!e&&pt(A(t),`iterate`,ut),t.size},has(t){let n=this.__v_raw,r=A(n),i=A(t);return e||(D(t,i)&&pt(r,`has`,t),pt(r,`has`,i)),t===i?n.has(t):n.has(t)||n.has(i)},forEach(n,r){let i=this,a=i.__v_raw,o=A(a),s=t?It:e?ln:cn;return!e&&pt(o,`iterate`,ut),a.forEach((e,t)=>n.call(r,s(e),s(t),i))}};return l(n,e?{add:zt(`add`),set:zt(`set`),delete:zt(`delete`),clear:zt(`clear`)}:{add(e){let n=A(this),r=Lt(n),i=A(e),a=!t&&!an(e)&&!rn(e)?i:e;return r.has.call(n,a)||D(e,a)&&r.has.call(n,e)||D(i,a)&&r.has.call(n,i)||(n.add(a),mt(n,`add`,a,a)),this},set(e,n){!t&&!an(n)&&!rn(n)&&(n=A(n));let r=A(this),{has:i,get:a}=Lt(r),o=i.call(r,e);o||=(e=A(e),i.call(r,e));let s=a.call(r,e);return r.set(e,n),o?D(n,s)&&mt(r,`set`,e,n,s):mt(r,`add`,e,n),this},delete(e){let t=A(this),{has:n,get:r}=Lt(t),i=n.call(t,e);i||=(e=A(e),n.call(t,e));let a=r?r.call(t,e):void 0,o=t.delete(e);return i&&mt(t,`delete`,e,void 0,a),o},clear(){let e=A(this),t=e.size!==0,n=e.clear();return t&&mt(e,`clear`,void 0,void 0,void 0),n}}),[`keys`,`values`,`entries`,Symbol.iterator].forEach(r=>{n[r]=Rt(r,e,t)}),n}function Vt(e,t){let n=Bt(e,t);return(t,r,i)=>r===`__v_isReactive`?!e:r===`__v_isReadonly`?e:r===`__v_raw`?t:Reflect.get(f(n,r)&&r in t?n:t,r,i)}var Ht={get:Vt(!1,!1)},Ut={get:Vt(!1,!0)},Wt={get:Vt(!0,!1)},Gt={get:Vt(!0,!0)},Kt=new WeakMap,qt=new WeakMap,Jt=new WeakMap,Yt=new WeakMap;function Xt(e){switch(e){case`Object`:case`Array`:return 1;case`Map`:case`Set`:case`WeakMap`:case`WeakSet`:return 2;default:return 0}}function Zt(e){return rn(e)?e:tn(e,!1,Mt,Ht,Kt)}function Qt(e){return tn(e,!1,Pt,Ut,qt)}function $t(e){return tn(e,!0,Nt,Wt,Jt)}function en(e){return tn(e,!0,Ft,Gt,Yt)}function tn(e,t,n,r,i){if(!x(e)||e.__v_raw&&!(t&&e.__v_isReactive)||e.__v_skip||!Object.isExtensible(e))return e;let a=i.get(e);if(a)return a;let o=Xt(ee(e));if(o===0)return e;let s=new Proxy(e,o===2?r:n);return i.set(e,s),s}function nn(e){return rn(e)?nn(e.__v_raw):!!(e&&e.__v_isReactive)}function rn(e){return!!(e&&e.__v_isReadonly)}function an(e){return!!(e&&e.__v_isShallow)}function on(e){return e?!!e.__v_raw:!1}function A(e){let t=e&&e.__v_raw;return t?A(t):e}function sn(e){return!f(e,`__v_skip`)&&Object.isExtensible(e)&&ue(e,`__v_skip`,!0),e}var cn=e=>x(e)?Zt(e):e,ln=e=>x(e)?$t(e):e;function j(e){return e?e.__v_isRef===!0:!1}function M(e){return dn(e,!1)}function un(e){return dn(e,!0)}function dn(e,t){return j(e)?e:new fn(e,t)}var fn=class{constructor(e,t){this.dep=new st,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=t?e:A(e),this._value=t?e:cn(e),this.__v_isShallow=t}get value(){return this.dep.track(),this._value}set value(e){let t=this._rawValue,n=this.__v_isShallow||an(e)||rn(e);e=n?e:A(e),D(e,t)&&(this._rawValue=e,this._value=n?e:cn(e),this.dep.trigger())}};function pn(e){e.dep&&e.dep.trigger()}function N(e){return j(e)?e.value:e}function mn(e){return v(e)?e():N(e)}var hn={get:(e,t,n)=>t===`__v_raw`?e:N(Reflect.get(e,t,n)),set:(e,t,n,r)=>{let i=e[t];return j(i)&&!j(n)?(i.value=n,!0):Reflect.set(e,t,n,r)}};function gn(e){return nn(e)?e:new Proxy(e,hn)}var _n=class{constructor(e){this.__v_isRef=!0,this._value=void 0;let t=this.dep=new st,{get:n,set:r}=e(t.track.bind(t),t.trigger.bind(t));this._get=n,this._set=r}get value(){return this._value=this._get()}set value(e){this._set(e)}};function vn(e){return new _n(e)}function yn(e){let t=p(e)?Array(e.length):{};for(let n in e)t[n]=Cn(e,n);return t}var bn=class{constructor(e,t,n){this._object=e,this._defaultValue=n,this.__v_isRef=!0,this._value=void 0,this._key=b(t)?t:String(t),this._raw=A(e);let r=!0,i=e;if(!p(e)||b(this._key)||!T(this._key))do r=!on(i)||an(i);while(r&&(i=i.__v_raw));this._shallow=r}get value(){let e=this._object[this._key];return this._shallow&&(e=N(e)),this._value=e===void 0?this._defaultValue:e}set value(e){if(this._shallow&&j(this._raw[this._key])){let t=this._object[this._key];if(j(t)){t.value=e;return}}this._object[this._key]=e}get dep(){return ht(this._raw,this._key)}},xn=class{constructor(e){this._getter=e,this.__v_isRef=!0,this.__v_isReadonly=!0,this._value=void 0}get value(){return this._value=this._getter()}};function Sn(e,t,n){return j(e)?e:v(e)?new xn(e):x(e)&&arguments.length>1?Cn(e,t,n):M(e)}function Cn(e,t,n){return new bn(e,t,n)}var wn=class{constructor(e,t,n){this.fn=e,this.setter=t,this._value=void 0,this.dep=new st(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=at-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!t,this.isSSR=n}notify(){if(this.flags|=16,!(this.flags&8)&&Le!==this)return Ue(this,!0),!0}get value(){let e=this.dep.track();return Ye(this),e&&(e.version=this.dep.version),this._value}set value(e){this.setter&&this.setter(e)}};function Tn(e,t,n=!1){let r,i;return v(e)?r=e:(r=e.get,i=e.set),new wn(r,i,n)}var En={GET:`get`,HAS:`has`,ITERATE:`iterate`},Dn={SET:`set`,ADD:`add`,DELETE:`delete`,CLEAR:`clear`},On={},kn=new WeakMap,An=void 0;function jn(){return An}function Mn(e,t=!1,n=An){if(n){let t=kn.get(n);t||kn.set(n,t=[]),t.push(e)}}function Nn(e,t,n=r){let{immediate:i,deep:o,once:s,scheduler:c,augmentJob:l,call:d}=n,f=e=>o?e:an(e)||o===!1||o===0?Pn(e,1):Pn(e),m,h,g,_,y=!1,b=!1;if(j(e)?(h=()=>e.value,y=an(e)):nn(e)?(h=()=>f(e),y=!0):p(e)?(b=!0,y=e.some(e=>nn(e)||an(e)),h=()=>e.map(e=>{if(j(e))return e.value;if(nn(e))return f(e);if(v(e))return d?d(e,2):e()})):h=v(e)?t?d?()=>d(e,2):e:()=>{if(g){nt();try{g()}finally{rt()}}let t=An;An=m;try{return d?d(e,3,[_]):e(_)}finally{An=t}}:a,t&&o){let e=h,t=o===!0?1/0:o;h=()=>Pn(e(),t)}let x=Fe(),S=()=>{m.stop(),x&&x.active&&u(x.effects,m)};if(s&&t){let e=t;t=(...t)=>{let n=e(...t);return S(),n}}let C=b?Array(e.length).fill(On):On,w=e=>{if(!(!(m.flags&1)||!m.dirty&&!e)){if(t){let n=m.run();if(e||o||y||(b?n.some((e,t)=>D(e,C[t])):D(n,C))){g&&g();let e=An;An=m;try{let e=[n,C===On?void 0:b&&C[0]===On?[]:C,_];C=n,d?d(t,3,e):t(...e)}finally{An=e}}}else m.run()}};return l&&l(w),m=new ze(h),m.scheduler=c?()=>c(w,!1):w,_=e=>Mn(e,!1,m),g=m.onStop=()=>{let e=kn.get(m);if(e){if(d)d(e,4);else for(let t of e)t();kn.delete(m)}},t?i?w(!0):C=m.run():c?c(w.bind(null,!0),!0):m.run(),S.pause=m.pause.bind(m),S.resume=m.resume.bind(m),S.stop=S,S}function Pn(e,t=1/0,n){if(t<=0||!x(e)||e.__v_skip||(n||=new Map,(n.get(e)||0)>=t))return e;if(n.set(e,t),t--,j(e))Pn(e.value,t,n);else if(p(e))for(let r=0;r<e.length;r++)Pn(e[r],t,n);else if(h(e)||m(e))e.forEach(e=>{Pn(e,t,n)});else if(te(e)){for(let r in e)Pn(e[r],t,n);for(let r of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,r)&&Pn(e[r],t,n)}return e}var Fn=[];function In(e){Fn.push(e)}function Ln(){Fn.pop()}function Rn(e,t){}var zn={SETUP_FUNCTION:0,0:`SETUP_FUNCTION`,RENDER_FUNCTION:1,1:`RENDER_FUNCTION`,NATIVE_EVENT_HANDLER:5,5:`NATIVE_EVENT_HANDLER`,COMPONENT_EVENT_HANDLER:6,6:`COMPONENT_EVENT_HANDLER`,VNODE_HOOK:7,7:`VNODE_HOOK`,DIRECTIVE_HOOK:8,8:`DIRECTIVE_HOOK`,TRANSITION_HOOK:9,9:`TRANSITION_HOOK`,APP_ERROR_HANDLER:10,10:`APP_ERROR_HANDLER`,APP_WARN_HANDLER:11,11:`APP_WARN_HANDLER`,FUNCTION_REF:12,12:`FUNCTION_REF`,ASYNC_COMPONENT_LOADER:13,13:`ASYNC_COMPONENT_LOADER`,SCHEDULER:14,14:`SCHEDULER`,COMPONENT_UPDATE:15,15:`COMPONENT_UPDATE`,APP_UNMOUNT_CLEANUP:16,16:`APP_UNMOUNT_CLEANUP`},Bn={sp:`serverPrefetch hook`,bc:`beforeCreate hook`,c:`created hook`,bm:`beforeMount hook`,m:`mounted hook`,bu:`beforeUpdate hook`,u:`updated`,bum:`beforeUnmount hook`,um:`unmounted hook`,a:`activated hook`,da:`deactivated hook`,ec:`errorCaptured hook`,rtc:`renderTracked hook`,rtg:`renderTriggered hook`,0:`setup function`,1:`render function`,2:`watcher getter`,3:`watcher callback`,4:`watcher cleanup function`,5:`native event handler`,6:`component event handler`,7:`vnode hook`,8:`directive hook`,9:`transition hook`,10:`app errorHandler`,11:`app warnHandler`,12:`ref function`,13:`async component loader`,14:`scheduler flush`,15:`component update`,16:`app unmount cleanup function`};function Vn(e,t,n,r){try{return r?e(...r):e()}catch(e){Un(e,t,n)}}function Hn(e,t,n,r){if(v(e)){let i=Vn(e,t,n,r);return i&&S(i)&&i.catch(e=>{Un(e,t,n)}),i}if(p(e)){let i=[];for(let a=0;a<e.length;a++)i.push(Hn(e[a],t,n,r));return i}}function Un(e,t,n,i=!0){let a=t?t.vnode:null,{errorHandler:o,throwUnhandledErrorInProduction:s}=t&&t.appContext.config||r;if(t){let r=t.parent,i=t.proxy,a=`https://vuejs.org/error-reference/#runtime-${n}`;for(;r;){let t=r.ec;if(t){for(let n=0;n<t.length;n++)if(t[n](e,i,a)===!1)return}r=r.parent}if(o){nt(),Vn(o,null,10,[e,i,a]),rt();return}}Wn(e,n,a,i,s)}function Wn(e,t,n,r=!0,i=!1){if(i)throw e;console.error(e)}var Gn=[],Kn=-1,qn=[],Jn=null,Yn=0,Xn=Promise.resolve(),Zn=null;function Qn(e){let t=Zn||Xn;return e?t.then(this?e.bind(this):e):t}function $n(e){let t=Kn+1,n=Gn.length;for(;t<n;){let r=t+n>>>1,i=Gn[r],a=ar(i);a<e||a===e&&i.flags&2?t=r+1:n=r}return t}function er(e){if(!(e.flags&1)){let t=ar(e),n=Gn[Gn.length-1];!n||!(e.flags&2)&&t>=ar(n)?Gn.push(e):Gn.splice($n(t),0,e),e.flags|=1,tr()}}function tr(){Zn||=Xn.then(or)}function nr(e){if(!p(e))Jn&&e.id===-1?Jn.splice(Yn+1,0,e):e.flags&1||(qn.push(e),e.flags|=1);else for(let t=0;t<e.length;t++)qn.push(e[t]);tr()}function rr(e,t,n=Kn+1){for(;n<Gn.length;n++){let t=Gn[n];if(t&&t.flags&2){if(e&&t.id!==e.uid)continue;Gn.splice(n,1),n--,t.flags&4&&(t.flags&=-2),t(),t.flags&4||(t.flags&=-2)}}}function ir(e){if(qn.length){let e=[...new Set(qn)].sort((e,t)=>ar(e)-ar(t));if(qn.length=0,Jn){for(let t=0;t<e.length;t++)Jn.push(e[t]);return}for(Jn=e,Yn=0;Yn<Jn.length;Yn++){let e=Jn[Yn];e.flags&4&&(e.flags&=-2),e.flags&8||e(),e.flags&=-2}Jn=null,Yn=0}}var ar=e=>e.id==null?e.flags&2?-1:1/0:e.id;function or(e){try{for(Kn=0;Kn<Gn.length;Kn++){let e=Gn[Kn];e&&!(e.flags&8)&&(e.flags&4&&(e.flags&=-2),Vn(e,e.i,e.i?15:14),e.flags&4||(e.flags&=-2))}}finally{for(;Kn<Gn.length;Kn++){let e=Gn[Kn];e&&(e.flags&=-2)}Kn=-1,Gn.length=0,ir(e),Zn=null,(Gn.length||qn.length)&&or(e)}}var sr,cr=[];function lr(e,t){sr=e,sr?(sr.enabled=!0,cr.forEach(({event:e,args:t})=>sr.emit(e,...t)),cr=[]):typeof window<`u`&&window.HTMLElement&&!(window.navigator?.userAgent)?.includes(`jsdom`)?((t.__VUE_DEVTOOLS_HOOK_REPLAY__=t.__VUE_DEVTOOLS_HOOK_REPLAY__||[]).push(e=>{lr(e,t)}),setTimeout(()=>{sr||(t.__VUE_DEVTOOLS_HOOK_REPLAY__=null,cr=[])},3e3)):cr=[]}var ur=null,dr=null;function fr(e){let t=ur;return ur=e,dr=e&&e.type.__scopeId||null,t}function pr(e){dr=e}function mr(){dr=null}var hr=e=>P;function P(e,t=ur,n){if(!t||e._n)return e;let r=(...n)=>{r._d&&ms(-1);let i=fr(t),a=us.length,o;try{o=e(...n)}finally{for(let e=us.length;e>a;e--)fs();fr(i),r._d&&ms(1)}return o};return r._n=!0,r._c=!0,r._d=!0,r}function gr(e,t){if(ur===null)return e;let n=Qs(ur),i=e.dirs||=[];for(let e=0;e<t.length;e++){let[a,o,s,c=r]=t[e];a&&(v(a)&&(a={mounted:a,updated:a}),a.deep&&Pn(o),i.push({dir:a,instance:n,value:o,oldValue:void 0,arg:s,modifiers:c}))}return e}function _r(e,t,n,r){let i=e.dirs,a=t&&t.dirs;for(let o=0;o<i.length;o++){let s=i[o];a&&(s.oldValue=a[o].value);let c=s.dir[r];c&&(nt(),Hn(c,n,8,[e.el,s,e,t]),rt())}}function vr(e,t){if(Ps){let n=Ps.provides,r=Ps.parent&&Ps.parent.provides;r===n&&(n=Ps.provides=Object.create(r)),n[e]=t}}function yr(e,t,n=!1){let r=Fs();if(r||no){let i=no?no._context.provides:r?r.parent==null||r.ce?r.vnode.appContext&&r.vnode.appContext.provides:r.parent.provides:void 0;if(i&&e in i)return i[e];if(arguments.length>1)return n&&v(t)?t.call(r&&r.proxy):t}}function br(){return!!(Fs()||no)}var xr=Symbol.for(`v-scx`),Sr=()=>yr(xr);function Cr(e,t){return Dr(e,null,t)}function wr(e,t){return Dr(e,null,{flush:`post`})}function Tr(e,t){return Dr(e,null,{flush:`sync`})}function Er(e,t,n){return Dr(e,t,n)}function Dr(e,t,n=r){let{immediate:i,deep:o,flush:s,once:c}=n,u=l({},n),d=t&&i||!t&&s!==`post`,f;if(Vs){if(s===`sync`){let e=Sr();f=e.__watcherHandles||=[]}else if(!d){let e=()=>{};return e.stop=a,e.resume=a,e.pause=a,e}}let p=Ps;u.call=(e,t,n)=>Hn(e,p,t,n);let m=!1;s===`post`?u.scheduler=e=>{Io(e,p&&p.suspense)}:s!==`sync`&&(m=!0,u.scheduler=(e,t)=>{t?e():er(e)}),u.augmentJob=e=>{t&&(e.flags|=4),m&&(e.flags|=2,p&&(e.id=p.uid,e.i=p))};let h=Nn(e,t,u);return Vs&&(f?f.push(h):d&&h()),h}function Or(e,t,n){let r=this.proxy,i=y(e)?e.includes(`.`)?kr(r,e):()=>r[e]:e.bind(r,r),a;v(t)?a=t:(a=t.handler,n=t);let o=Rs(this),s=Dr(i,a.bind(r),n);return o(),s}function kr(e,t){let n=t.split(`.`);return()=>{let t=e;for(let e=0;e<n.length&&t;e++)t=t[n[e]];return t}}var Ar=new WeakMap,jr=Symbol(`_vte`),Mr=e=>e.__isTeleport,Nr=e=>e&&(e.disabled||e.disabled===``),Pr=e=>e&&(e.defer||e.defer===``),Fr=e=>typeof SVGElement<`u`&&e instanceof SVGElement,Ir=e=>typeof MathMLElement==`function`&&e instanceof MathMLElement,Lr=(e,t)=>{let n=e&&e.to;return y(n)?t?t(n):null:n},Rr={name:`Teleport`,__isTeleport:!0,process(e,t,n,r,i,a,o,s,c,l){let{mc:u,pc:d,pbc:f,o:{insert:p,querySelector:m,createText:h,createComment:g,parentNode:_}}=l,v=Nr(t.props),{dynamicChildren:y}=t,b=(e,t,n)=>{e.shapeFlag&16&&u(e.children,t,n,i,a,o,s,c)},x=(e=t)=>{let n=Nr(e.props),r=e.target=Lr(e.props,m),a=Ur(r,e,h,p);r&&(o!==`svg`&&Fr(r)?o=`svg`:o!==`mathml`&&Ir(r)&&(o=`mathml`),i&&i.isCE&&(i.ce._teleportTargets||(i.ce._teleportTargets=new Set)).add(r),n||(b(e,r,a),Hr(e,!1)))},S=e=>{let t=()=>{if(Ar.get(e)===t){if(Ar.delete(e),Nr(e.props)){let t=_(e.el)||n;b(e,t,e.anchor),Hr(e,!0)}x(e)}};Ar.set(e,t),Io(t,a)};if(e==null){let e=t.el=h(``),i=t.anchor=h(``);if(p(e,n,r),p(i,n,r),Pr(t.props)||a&&a.pendingBranch){S(t);return}v&&(b(t,n,i),Hr(t,!0)),x()}else{t.el=e.el;let r=t.anchor=e.anchor,u=Ar.get(e);if(u){u.flags|=8,Ar.delete(e),S(t);return}t.targetStart=e.targetStart;let p=t.target=e.target,h=t.targetAnchor=e.targetAnchor,g=Nr(e.props),_=g?n:p,b=g?r:h;if(o===`svg`||Fr(p)?o=`svg`:(o===`mathml`||Ir(p))&&(o=`mathml`),y?(f(e.dynamicChildren,y,_,i,a,o,s),Uo(e,t,!0)):c||d(e,t,_,b,i,a,o,s,!1),v)g?t.props&&e.props&&t.props.to!==e.props.to&&(t.props.to=e.props.to):zr(t,n,r,l,1);else if((t.props&&t.props.to)!==(e.props&&e.props.to)){let e=Lr(t.props,m);e&&(t.target=e,zr(t,e,null,l,0))}else g&&zr(t,p,h,l,1);Hr(t,v)}},remove(e,t,n,{um:r,o:{remove:i}},a){let{shapeFlag:o,children:s,anchor:c,targetStart:l,targetAnchor:u,target:d,props:f}=e,p=Nr(f),m=a||!p,h=Ar.get(e);if(h&&(h.flags|=8,Ar.delete(e)),d&&(i(l),i(u)),a&&i(c),!h&&(p||d)&&o&16)for(let e=0;e<s.length;e++){let i=s[e];r(i,t,n,m,!!i.dynamicChildren)}},move:zr,hydrate:Br};function zr(e,t,n,{o:{insert:r},m:i},a=2){a===0&&r(e.targetAnchor,t,n);let{el:o,anchor:s,shapeFlag:c,children:l,props:u}=e,d=a===2;if(d&&r(o,t,n),!Ar.has(e)&&(!d||Nr(u))&&c&16)for(let e=0;e<l.length;e++)i(l[e],t,n,2);d&&r(s,t,n)}function Br(e,t,n,r,i,a,{o:{nextSibling:o,parentNode:s,querySelector:c,insert:l,createText:u}},d){function f(e,n){let r=n;for(;r;){if(r&&r.nodeType===8){if(r.data===`teleport start anchor`)t.targetStart=r;else if(r.data===`teleport anchor`){t.targetAnchor=r,e._lpa=t.targetAnchor&&o(t.targetAnchor);break}}r=o(r)}}function p(e,t){t.anchor=d(o(e),t,s(e),n,r,i,a)}let m=t.target=Lr(t.props,c),h=Nr(t.props);if(m){let c=m._lpa||m.firstChild;t.shapeFlag&16&&(h?(p(e,t),f(m,c),t.targetAnchor||Ur(m,t,u,l,s(e)===m?e:null)):(t.anchor=o(e),f(m,c),t.targetAnchor||Ur(m,t,u,l),d(c&&o(c),t,m,n,r,i,a))),Hr(t,h)}else h&&t.shapeFlag&16&&(p(e,t),t.targetStart=e,t.targetAnchor=o(e));return t.anchor&&o(t.anchor)}var Vr=Rr;function Hr(e,t){let n=e.ctx;if(n&&n.ut){let r,i;for(t?(r=e.el,i=e.anchor):(r=e.targetStart,i=e.targetAnchor);r&&r!==i;)r.nodeType===1&&r.setAttribute(`data-v-owner`,n.uid),r=r.nextSibling;n.ut()}}function Ur(e,t,n,r,i=null){let a=t.targetStart=n(``),o=t.targetAnchor=n(``);return a[jr]=o,e&&(r(a,e,i),r(o,e,i)),o}var Wr=Symbol(`_leaveCb`),Gr=Symbol(`_enterCb`);function Kr(){let e={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return Zi(()=>{e.isMounted=!0}),ea(()=>{e.isUnmounting=!0}),e}var qr=[Function,Array],Jr={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:qr,onEnter:qr,onAfterEnter:qr,onEnterCancelled:qr,onBeforeLeave:qr,onLeave:qr,onAfterLeave:qr,onLeaveCancelled:qr,onBeforeAppear:qr,onAppear:qr,onAfterAppear:qr,onAppearCancelled:qr},Yr=e=>{let t=e.subTree;return t.component?Yr(t.component):t},Xr={name:`BaseTransition`,props:Jr,setup(e,{slots:t}){let n=Fs(),r=Kr();return()=>{let i=t.default&&ii(t.default(),!0),a=i&&i.length?Zr(i):n.subTree?Ts():void 0;if(!a)return;let o=A(e),{mode:s}=o;if(r.isLeaving)return ti(a);let c=ni(a);if(!c)return ti(a);let l=ei(c,o,r,n,e=>l=e);c.type!==cs&&ri(c,l);let u=n.subTree&&ni(n.subTree);if(u&&u.type!==cs&&!_s(u,c)&&Yr(n).type!==cs){let e=ei(u,o,r,n);if(ri(u,e),s===`out-in`&&c.type!==cs)return r.isLeaving=!0,e.afterLeave=()=>{r.isLeaving=!1,n.job.flags&8||n.update(),delete e.afterLeave,u=void 0},ti(a);s===`in-out`&&c.type!==cs?e.delayLeave=(e,t,n)=>{let i=$r(r,u);i[String(u.key)]=u,e[Wr]=()=>{t(),e[Wr]=void 0,delete l.delayedLeave,u=void 0},l.delayedLeave=()=>{n(),delete l.delayedLeave,u=void 0}}:u=void 0}else u&&=void 0;return a}}};function Zr(e){let t=e[0];if(e.length>1){for(let n of e)if(n.type!==cs){t=n;break}}return t}var Qr=Xr;function $r(e,t){let{leavingVNodes:n}=e,r=n.get(t.type);return r||(r=Object.create(null),n.set(t.type,r)),r}function ei(e,t,n,r,i){let{appear:a,mode:o,persisted:s=!1,onBeforeEnter:c,onEnter:l,onAfterEnter:u,onEnterCancelled:d,onBeforeLeave:f,onLeave:m,onAfterLeave:h,onLeaveCancelled:g,onBeforeAppear:_,onAppear:v,onAfterAppear:y,onAppearCancelled:b}=t,x=String(e.key),S=$r(n,e),C=(e,t)=>{e&&Hn(e,r,9,t)},w=(e,t)=>{let n=t[1];C(e,t),p(e)?e.every(e=>e.length<=1)&&n():e.length<=1&&n()},ee={mode:o,persisted:s,beforeEnter(t){let r=c;if(!n.isMounted){if(a)r=_||c;else return}t[Wr]&&t[Wr](!0);let i=S[x];i&&_s(e,i)&&i.el[Wr]&&i.el[Wr](),C(r,[t])},enter(t){if(S[x]===e)return;let r=l,i=u,o=d;if(!n.isMounted){if(a)r=v||l,i=y||u,o=b||d;else return}let s=!1;t[Gr]=e=>{s||(s=!0,C(e?o:i,[t]),ee.delayedLeave&&ee.delayedLeave(),t[Gr]=void 0)};let c=t[Gr].bind(null,!1);r?w(r,[t,c]):c()},leave(t,r){let i=String(e.key);if(t[Gr]&&t[Gr](!0),n.isUnmounting)return r();C(f,[t]);let a=!1;t[Wr]=n=>{a||(a=!0,r(),C(n?g:h,[t]),t[Wr]=void 0,S[i]===e&&delete S[i])};let o=t[Wr].bind(null,!1);S[i]=e,m?w(m,[t,o]):o()},clone(e){let a=ei(e,t,n,r,i);return i&&i(a),a}};return ee}function ti(e){if(zi(e))return e=Cs(e),e.children=null,e}function ni(e){if(!zi(e))return Mr(e.type)&&e.children?Zr(e.children):e;if(e.component)return e.component.subTree;let{shapeFlag:t,children:n}=e;if(n){if(t&16)return n[0];if(t&32&&v(n.default))return n.default()}}function ri(e,t){if(e.shapeFlag&6&&e.component){e.transition=t;let n=e.component.subTree;ri(Mr(n.type)&&ni(n)||n,t)}else e.shapeFlag&128?(e.ssContent.transition=t.clone(e.ssContent),e.ssFallback.transition=t.clone(e.ssFallback)):e.transition=t}function ii(e,t=!1,n){let r=[],i=0;for(let a=0;a<e.length;a++){let o=e[a],s=n==null?o.key:String(n)+String(o.key==null?a:o.key);o.type===L?(o.patchFlag&128&&i++,r=r.concat(ii(o.children,t,s))):(t||o.type!==cs)&&r.push(s==null?o:Cs(o,{key:s}))}if(i>1)for(let e=0;e<r.length;e++)r[e].patchFlag=-2;return r}function F(e,t){return v(e)?l({name:e.name},t,{setup:e}):e}function ai(){let e=Fs();return e?(e.appContext.config.idPrefix||`v`)+`-`+e.ids[0]+e.ids[1]++:``}function oi(e){e.ids=[e.ids[0]+e.ids[2]+++`-`,0,0]}function si(e){let t=Fs(),n=un(null);if(t){let i=t.refs===r?t.refs={}:t.refs;Object.defineProperty(i,e,{enumerable:!0,get:()=>n.value,set:e=>n.value=e})}return n}function ci(e,t){let n;return!!((n=Object.getOwnPropertyDescriptor(e,t))&&!n.configurable)}var li=new WeakMap;function ui(e,t,n,i,a=!1){if(p(e)){e.forEach((e,r)=>ui(e,t&&(p(t)?t[r]:t),n,i,a));return}if(Ii(i)&&!a){i.shapeFlag&512&&i.type.__asyncResolved&&i.component.subTree.component&&ui(e,t,n,i.component.subTree);return}let s=i.shapeFlag&4?Qs(i.component):i.el,c=a?null:s,{i:l,r:d}=e,m=t&&t.r,h=l.refs===r?l.refs={}:l.refs,g=l.setupState,_=A(g),b=g===r?o:e=>!ci(h,e)&&f(_,e),x=(e,t)=>!(t&&ci(h,t));if(m!=null&&m!==d){if(di(t),y(m))h[m]=null,b(m)&&(g[m]=null);else if(j(m)){let e=t;x(m,e.k)&&(m.value=null),e.k&&(h[e.k]=null)}}if(v(d))Vn(d,l,12,[c,h]);else{let t=y(d),r=j(d);if(t||r){let i=()=>{if(e.f){let n=t?b(d)?g[d]:h[d]:x(d)||!e.k?d.value:h[e.k];if(a)p(n)&&u(n,s);else if(p(n))n.includes(s)||n.push(s);else if(t)h[d]=[s],b(d)&&(g[d]=h[d]);else{let t=[s];x(d,e.k)&&(d.value=t),e.k&&(h[e.k]=t)}}else t?(h[d]=c,b(d)&&(g[d]=c)):r&&(x(d,e.k)&&(d.value=c),e.k&&(h[e.k]=c))};if(c){let t=()=>{i(),li.delete(e)};t.id=-1,li.set(e,t),Io(t,n)}else di(e),i()}}}function di(e){let t=li.get(e);t&&(t.flags|=8,li.delete(e))}var fi=!1,pi=()=>{fi||=(console.error(`Hydration completed but contains mismatches.`),!0)},mi=e=>e.namespaceURI.includes(`svg`)&&e.tagName!==`foreignObject`,hi=e=>e.namespaceURI.includes(`MathML`),gi=e=>{if(e.nodeType===1){if(mi(e))return`svg`;if(hi(e))return`mathml`}},_i=e=>e.nodeType===8;function vi(e){let{mt:t,p:n,o:{patchProp:r,createText:i,nextSibling:a,parentNode:o,remove:c,insert:l,createComment:u}}=e,d=(e,t)=>{if(!t.hasChildNodes()){n(null,e,t),ir(),t._vnode=e;return}f(t.firstChild,e,null,null,null),ir(),t._vnode=e},f=(n,r,s,c,u,d=!1)=>{d||=!!r.dynamicChildren;let b=_i(n)&&n.data===`[`,x=()=>g(n,r,s,c,u,b),{type:S,ref:C,shapeFlag:w,patchFlag:ee}=r,te=n.nodeType;r.el=n,ee===-2&&(d=!1,r.dynamicChildren=null);let T=null;switch(S){case ss:te===3?(n.data!==r.children&&(pi(),n.data=r.children),T=a(n)):r.children===``?(l(r.el=i(``),o(n),n),T=n):T=x();break;case cs:y(n)?(T=a(n),v(r.el=n.content.firstChild,n,s)):T=te!==8||b?x():a(n);break;case ls:if(b&&(n=a(n),te=n.nodeType),te===1||te===3){T=n;let e=!r.children.length;for(let t=0;t<r.staticCount;t++)e&&(r.children+=T.nodeType===1?T.outerHTML:T.data),t===r.staticCount-1&&(r.anchor=T),T=a(T);return b?a(T):T}x();break;case L:T=b?h(n,r,s,c,u,d):x();break;default:if(w&1)T=(te!==1||r.type.toLowerCase()!==n.tagName.toLowerCase())&&!y(n)?x():p(n,r,s,c,u,d);else if(w&6){r.slotScopeIds=u;let e=o(n);if(T=b?_(n):_i(n)&&n.data===`teleport start`?_(n,n.data,`teleport end`):a(n),t(r,e,null,s,c,gi(e),d),Ii(r)&&!r.type.__asyncResolved){let t;b?(t=H(L),t.anchor=T?T.previousSibling:e.lastChild):t=n.nodeType===3?U(``):H(`div`),t.el=n,r.component.subTree=t}}else w&64?T=te===8?r.type.hydrate(n,r,s,c,u,d,e,m):x():w&128&&(T=r.type.hydrate(n,r,s,c,gi(o(n)),u,d,e,f))}return C!=null&&ui(C,null,c,r),T},p=(e,t,n,i,a,o)=>{o||=!!t.dynamicChildren;let{type:l,dynamicProps:u,props:d,patchFlag:f,shapeFlag:p,dirs:h,transition:g}=t,_=l===`input`||l===`option`,b=!!u;if(_||b||f!==-1){h&&_r(t,null,n,`created`);let l=!1;if(y(e)){l=Ho(null,g)&&n&&n.vnode.props&&n.vnode.props.appear;let r=e.content.firstChild;if(l){let e=r.getAttribute(`class`);e&&(r.$cls=e),g.beforeEnter(r)}v(r,e,n),t.el=e=r}if(p&16&&!(d&&(d.innerHTML||d.textContent))){let r=m(e.firstChild,t,e,n,i,a,o);for(r&&!Ci(e,1)&&pi();r;){let e=r;r=r.nextSibling,c(e)}}else if(p&8){let n=t.children;n[0]===`
`&&(e.tagName===`PRE`||e.tagName===`TEXTAREA`)&&(n=n.slice(1));let{textContent:r}=e;r!==n&&r!==n.replace(/\r\n|\r/g,`
`)&&(Ci(e,0)||pi(),e.textContent=t.children)}if(d){if(_||b||!o||f&48){let t=e.tagName.includes(`-`),i=e.namespaceURI.includes(`svg`)?`svg`:e.namespaceURI.includes(`MathML`)?`mathml`:void 0;for(let a in d)if(_&&(a.endsWith(`value`)||a===`indeterminate`)||s(a)&&!ne(a)||a[0]===`.`||t&&!ne(a)||u&&u.includes(a)){if(bi(e,a,d[a]))continue;r(e,a,null,d[a],i,n)}}else if(d.onClick)r(e,`onClick`,null,d.onClick,void 0,n);else if(f&4&&nn(d.style))for(let e in d.style)d.style[e]}let x;(x=d&&d.onVnodeBeforeMount)&&As(x,n,t),h&&_r(t,null,n,`beforeMount`),((x=d&&d.onVnodeMounted)||h||l)&&is(()=>{x&&As(x,n,t),l&&g.enter(e),h&&_r(t,null,n,`mounted`)},i)}return e.nextSibling},m=(e,t,r,o,s,c,u)=>{u||=!!t.dynamicChildren;let d=t.children,p=d.length,m=!1;for(let t=0;t<p;t++){let h=u?d[t]:d[t]=Es(d[t]),g=h.type===ss;e?(g&&!u&&t+1<p&&Es(d[t+1]).type===ss&&(l(i(e.data.slice(h.children.length)),r,a(e)),e.data=h.children),e=f(e,h,o,s,c,u)):g&&!h.children?l(h.el=i(``),r):(m||(m=!0,Ci(r,1)||pi()),n(null,h,r,null,o,s,gi(r),c))}return e},h=(e,t,n,r,i,s)=>{let{slotScopeIds:c}=t;c&&(i=i?i.concat(c):c);let d=o(e),f=m(a(e),t,d,n,r,i,s);return f&&_i(f)&&f.data===`]`?a(t.anchor=f):(pi(),l(t.anchor=u(`]`),d,f),f)},g=(e,t,r,i,s,l)=>{if(Ti(e,t)||pi(),t.el=null,l){let t=_(e);for(;;){let n=a(e);if(n&&n!==t)c(n);else break}}let u=a(e),d=o(e);return c(e),n(null,t,d,u,r,i,gi(d),s),r&&(r.vnode.el=t.el,_o(r,t.el)),u},_=(e,t=`[`,n=`]`)=>{let r=0;for(;e;)if(e=a(e),e&&_i(e)&&(e.data===t&&r++,e.data===n)){if(r===0)return a(e);r--}return e},v=(e,t,n)=>{let r=t.parentNode;r&&r.replaceChild(e,t);let i=n;for(;i;)i.vnode.el===t&&(i.vnode.el=i.subTree.el=e),i=i.parent},y=e=>e.nodeType===1&&e.tagName===`TEMPLATE`;return[d,f]}var yi=new Set([`src`,`srcset`,`href`,`poster`]);function bi(e,t,n){return yi.has(t)?e.getAttribute(t)===(n==null?null:`${n}`):!1}var xi=`data-allow-mismatch`,Si={0:`text`,1:`children`,2:`class`,3:`style`,4:`attribute`};function Ci(e,t){if(t===0||t===1)for(;e&&!e.hasAttribute(xi);)e=e.parentElement;return wi(e&&e.getAttribute(xi),t)}function wi(e,t){if(e==null)return!1;if(e===``)return!0;{let n=e.split(`,`);return t===0&&n.includes(`children`)?!0:n.includes(Si[t])}}function Ti(e,t){return Ci(e.parentElement,1)||Ei(e)||Di(t)}function Ei(e){return e.nodeType===1&&wi(e.getAttribute(xi),1)}function Di({props:e}){let t=e&&e[xi];return typeof t==`string`&&wi(t,1)}var Oi=me().requestIdleCallback||(e=>setTimeout(e,1)),ki=me().cancelIdleCallback||(e=>clearTimeout(e)),Ai=(e=1e4)=>t=>{let n=Oi(t,{timeout:e});return()=>ki(n)};function ji(e){let{top:t,left:n,bottom:r,right:i}=e.getBoundingClientRect(),{innerHeight:a,innerWidth:o}=window;return(t>0&&t<a||r>0&&r<a)&&(n>0&&n<o||i>0&&i<o)}var Mi=e=>(t,n)=>{let r=new IntersectionObserver(e=>{for(let n of e)if(n.isIntersecting){r.disconnect(),t();break}},e);return n(e=>{if(e instanceof Element){if(ji(e))return t(),r.disconnect(),!1;r.observe(e)}}),()=>r.disconnect()},Ni=e=>t=>{if(e){let n=matchMedia(e);if(n.matches)t();else return n.addEventListener(`change`,t,{once:!0}),()=>n.removeEventListener(`change`,t)}},Pi=(e=[])=>(t,n)=>{y(e)&&(e=[e]);let r=!1,i=e=>{r||(r=!0,a(),t(),e.target.dispatchEvent(new e.constructor(e.type,e)))},a=()=>{n(t=>{for(let n of e)t.removeEventListener(n,i)})};return n(t=>{for(let n of e)t.addEventListener(n,i,{once:!0})}),a};function Fi(e,t){if(_i(e)&&e.data===`[`){let n=1,r=e.nextSibling;for(;r;){if(r.nodeType===1){if(t(r)===!1)break}else if(_i(r)){if(r.data===`]`){if(--n===0)break}else r.data===`[`&&n++}r=r.nextSibling}}else t(e)}var Ii=e=>!!e.type.__asyncLoader;function Li(e){v(e)&&(e={loader:e});let{loader:t,loadingComponent:n,errorComponent:r,delay:i=200,hydrate:a,timeout:o,suspensible:s=!0,onError:c}=e,l=null,u,d=0,f=()=>(d++,l=null,p()),p=()=>{let e;return l||(e=l=t().catch(e=>{if(e=e instanceof Error?e:Error(String(e)),c)return new Promise((t,n)=>{c(e,()=>t(f()),()=>n(e),d+1)});throw e}).then(t=>e!==l&&l?l:(t&&(t.__esModule||t[Symbol.toStringTag]===`Module`)&&(t=t.default),u=t,t)))};return F({name:`AsyncComponentWrapper`,__asyncLoader:p,__asyncHydrate(e,t,n){let r=e.isConnected,i=!1;(t.bu||=[]).push(()=>i=!0);let o=()=>{i||!e.parentNode||r&&!e.isConnected||n()},s=a?()=>{let n=a(o,t=>Fi(e,t));n&&(t.bum||=[]).push(n)}:o;u?s():p().then(()=>!t.isUnmounted&&s())},get __asyncResolved(){return u},setup(){let e=Ps;if(oi(e),u)return()=>Ri(u,e);let t=t=>{l=null,Un(t,e,13,!r)};if(s&&e.suspense||Vs)return p().then(t=>()=>Ri(t,e)).catch(e=>(t(e),()=>r?H(r,{error:e}):null));let a=M(!1),c=M(),d=M(!!i),f,m;return ta(()=>{f!=null&&clearTimeout(f),m!=null&&clearTimeout(m)}),i&&(m=setTimeout(()=>{e.isUnmounted||(d.value=!1)},i)),o!=null&&(f=setTimeout(()=>{if(!e.isUnmounted&&!a.value&&!c.value){let e=Error(`Async component timed out after ${o}ms.`);t(e),c.value=e}},o)),p().then(()=>{e.isUnmounted||(a.value=!0,e.parent&&zi(e.parent.vnode)&&e.parent.update())}).catch(n=>{if(e.isUnmounted){l=null;return}t(n),c.value=n}),()=>{if(a.value&&u)return Ri(u,e);if(c.value&&r)return H(r,{error:c.value});if(n&&!d.value)return Ri(n,e)}}})}function Ri(e,t){let{ref:n,props:r,children:i,ce:a}=t.vnode,o=H(e,r,i);return o.ref=n,o.ce=a,delete t.vnode.ce,o}var zi=e=>e.type.__isKeepAlive,Bi={name:`KeepAlive`,__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(e,{slots:t}){let n=Fs(),r=n.ctx;if(!r.renderer)return()=>{let e=t.default&&t.default();return e&&e.length===1?e[0]:e};let i=new Map,a=new Set,o=null,s=n.suspense,{renderer:{p:c,m:l,um:u,o:{createElement:d}}}=r,f=d(`div`);r.activate=(e,t,n,r,i)=>{let a=e.component;l(e,t,n,0,s),c(a.vnode,e,t,n,a,s,r,e.slotScopeIds,i),Io(()=>{a.isDeactivated=!1,a.a&&le(a.a);let t=e.props&&e.props.onVnodeMounted;t&&As(t,a.parent,e)},s)},r.deactivate=e=>{let t=e.component;Ko(t.m),Ko(t.a),l(e,f,null,1,s),Io(()=>{t.da&&le(t.da);let n=e.props&&e.props.onVnodeUnmounted;n&&As(n,t.parent,e),t.isDeactivated=!0},s)};function p(e){Ki(e),u(e,n,s,!0)}function m(e){i.forEach((t,n)=>{let r=$s(Ii(t)?t.type.__asyncResolved||{}:t.type);r&&!e(r)&&h(n)})}function h(e){let t=i.get(e);t&&(!o||!_s(t,o))?p(t):o&&Ki(o),i.delete(e),a.delete(e)}Er(()=>[e.include,e.exclude],([e,t])=>{e&&m(t=>Vi(e,t)),t&&m(e=>!Vi(t,e))},{flush:`post`,deep:!0});let g=null,_=()=>{g!=null&&(Jo(n.subTree.type)?Io(()=>{i.set(g,qi(n.subTree))},n.subTree.suspense):i.set(g,qi(n.subTree)))};return Zi(_),$i(_),ea(()=>{i.forEach(e=>{let{subTree:t,suspense:r}=n,i=qi(t);if(e.type===i.type&&e.key===i.key){Ki(i);let e=i.component.da;e&&Io(e,r);return}p(e)})}),()=>{if(g=null,!t.default)return o=null;let n=t.default(),r=n[0];if(n.length>1)return o=null,n;if(!gs(r)||!(r.shapeFlag&4)&&!(r.shapeFlag&128))return o=null,r;let s=qi(r);if(s.type===cs)return o=null,s;let c=s.type,l=$s(Ii(s)?s.type.__asyncResolved||{}:c),{include:u,exclude:d,max:f}=e;if(u&&(!l||!Vi(u,l))||d&&l&&Vi(d,l))return s.shapeFlag&=-257,o=s,r;let p=s.key==null?c:s.key,m=i.get(p);return s.el&&(s=Cs(s),r.shapeFlag&128&&(r.ssContent=s)),g=p,m?(s.el=m.el,s.component=m.component,s.transition&&ri(s,s.transition),s.shapeFlag|=512,a.delete(p),a.add(p)):(a.add(p),f&&a.size>parseInt(f,10)&&h(a.values().next().value)),s.shapeFlag|=256,o=s,Jo(r.type)?r:s}}};function Vi(e,t){return p(e)?e.some(e=>Vi(e,t)):y(e)?e.split(`,`).includes(t):_(e)?(e.lastIndex=0,e.test(t)):!1}function Hi(e,t){Wi(e,`a`,t)}function Ui(e,t){Wi(e,`da`,t)}function Wi(e,t,n=Ps){let r=e.__wdc||=()=>{let t=n;for(;t;){if(t.isDeactivated)return;t=t.parent}return e()};if(Ji(t,r,n),n){let e=n.parent;for(;e&&e.parent;)zi(e.parent.vnode)&&Gi(r,t,n,e),e=e.parent}}function Gi(e,t,n,r){let i=Ji(t,e,r,!0);ta(()=>{u(r[t],i)},n)}function Ki(e){e.shapeFlag&=-257,e.shapeFlag&=-513}function qi(e){return e.shapeFlag&128?e.ssContent:e}function Ji(e,t,n=Ps,r=!1){if(n){let i=n[e]||(n[e]=[]),a=t.__weh||=(...r)=>{nt();let i=Rs(n),a=Hn(t,n,e,r);return i(),rt(),a};return r?i.unshift(a):i.push(a),a}}var Yi=e=>(t,n=Ps)=>{(!Vs||e===`sp`)&&Ji(e,(...e)=>t(...e),n)},Xi=Yi(`bm`),Zi=Yi(`m`),Qi=Yi(`bu`),$i=Yi(`u`),ea=Yi(`bum`),ta=Yi(`um`),na=Yi(`sp`),ra=Yi(`rtg`),ia=Yi(`rtc`);function aa(e,t=Ps){Ji(`ec`,e,t)}var oa=`components`,sa=`directives`;function ca(e,t){return fa(oa,e,!0,t)||e}var la=Symbol.for(`v-ndc`);function ua(e){return y(e)?fa(oa,e,!1)||e:e||la}function da(e){return fa(sa,e)}function fa(e,t,n=!0,r=!1){let i=ur||Ps;if(i){let n=i.type;if(e===oa){let e=$s(n,!1);if(e&&(e===t||e===E(t)||e===se(E(t))))return n}let a=pa(i[e]||n[e],t)||pa(i.appContext[e],t);return!a&&r?n:a}}function pa(e,t){return e&&(e[t]||e[E(t)]||e[se(E(t))])}function ma(e,t,n,r){let i,a=n&&n[r],o=p(e);if(o||y(e)){let n=o&&nn(e),r=!1,s=!1;n&&(r=!an(e),s=rn(e),e=_t(e)),i=Array(e.length);for(let n=0,o=e.length;n<o;n++)i[n]=t(r?s?ln(cn(e[n])):cn(e[n]):e[n],n,void 0,a&&a[n])}else if(typeof e==`number`){i=Array(e);for(let n=0;n<e;n++)i[n]=t(n+1,n,void 0,a&&a[n])}else if(x(e)){if(e[Symbol.iterator])i=Array.from(e,(e,n)=>t(e,n,void 0,a&&a[n]));else{let n=Object.keys(e);i=Array(n.length);for(let r=0,o=n.length;r<o;r++){let o=n[r];i[r]=t(e[o],o,r,a&&a[r])}}}else i=[];return n&&(n[r]=i),i}function ha(e,t){for(let n=0;n<t.length;n++){let r=t[n];if(p(r))for(let t=0;t<r.length;t++)e[r[t].name]=r[t].fn;else r&&(e[r.name]=r.key?(...e)=>{let t=r.fn(...e);return t&&(t.key=r.key),t}:r.fn)}return e}function I(e,t,n,r,i,a){if(n??={},ur.ce||ur.parent&&Ii(ur.parent)&&ur.parent.ce){let e=a!=null&&n.key==null?l({},n,{key:a}):n,i=Object.keys(e).length>0;return t!=="default"&&(e.name=t),R(),B(L,null,[H(`slot`,e,r&&r())],i?-2:64)}let o=e[t];o&&o._c&&(o._d=!1);let s=us.length;R();let c;try{let i=o&&ga(o(n)),s=n.key||a||i&&i.key;c=B(L,{key:(s&&!b(s)?s:`_${t}`)+(!i&&r?`_fb`:``)},i||(r?r():[]),i&&e._===1?64:-2)}catch(e){for(let e=us.length;e>s;e--)fs();throw e}finally{o&&o._c&&(o._d=!0)}return!i&&c.scopeId&&(c.slotScopeIds=[c.scopeId+`-s`]),c}function ga(e){return e.some(e=>!gs(e)||!(e.type===cs||e.type===L&&!ga(e.children)))?e:null}function _a(e,t){let n={};for(let r in e)n[t&&/[A-Z]/.test(r)?`on:${r}`:ce(r)]=e[r];return n}var va=e=>e?Bs(e)?Qs(e):va(e.parent):null,ya=l(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>e.props,$attrs:e=>e.attrs,$slots:e=>e.slots,$refs:e=>e.refs,$parent:e=>va(e.parent),$root:e=>va(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>Ua(e),$forceUpdate:e=>e.f||=()=>{er(e.update)},$nextTick:e=>e.n||=Qn.bind(e.proxy),$watch:e=>Or.bind(e)}),ba=(e,t)=>e!==r&&!e.__isScriptSetup&&f(e,t),xa={get({_:e},t){if(t===`__v_skip`)return!0;let{ctx:n,setupState:i,data:a,props:o,accessCache:s,type:c,appContext:l}=e;if(t[0]!==`$`){let e=s[t];if(e!==void 0)switch(e){case 1:return i[t];case 2:return a[t];case 4:return n[t];case 3:return o[t]}else if(ba(i,t))return s[t]=1,i[t];else if(a!==r&&f(a,t))return s[t]=2,a[t];else if(f(o,t))return s[t]=3,o[t];else if(n!==r&&f(n,t))return s[t]=4,n[t];else Ra&&(s[t]=0)}let u=ya[t],d,p;if(u)return t===`$attrs`&&pt(e.attrs,`get`,``),u(e);if((d=c.__cssModules)&&(d=d[t]))return d;if(n!==r&&f(n,t))return s[t]=4,n[t];if(p=l.config.globalProperties,f(p,t))return p[t]},set({_:e},t,n){let{data:i,setupState:a,ctx:o}=e;return ba(a,t)?(a[t]=n,!0):i!==r&&f(i,t)?(i[t]=n,!0):f(e.props,t)||t[0]===`$`&&t.slice(1)in e?!1:(o[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:i,appContext:a,props:o,type:s}},c){let l;return!!(n[c]||e!==r&&c[0]!==`$`&&f(e,c)||ba(t,c)||f(o,c)||f(i,c)||f(ya,c)||f(a.config.globalProperties,c)||(l=s.__cssModules)&&l[c])},defineProperty(e,t,n){return n.get==null?f(n,`value`)&&this.set(e,t,n.value,null):e._.accessCache[t]=0,Reflect.defineProperty(e,t,n)}},Sa=l({},xa,{get(e,t){if(t!==Symbol.unscopables)return xa.get(e,t,e)},has(e,t){return t[0]!==`_`&&!he(t)}});function Ca(){return null}function wa(){return null}function Ta(e){}function Ea(e){}function Da(){return null}function Oa(){}function ka(e,t){return null}function Aa(){return Ma(`useSlots`).slots}function ja(){return Ma(`useAttrs`).attrs}function Ma(e){let t=Fs();return t.setupContext||=Zs(t)}function Na(e){return p(e)?e.reduce((e,t)=>(e[t]=null,e),{}):e}function Pa(e,t){let n=Na(e);for(let e in t){if(e.startsWith(`__skip`))continue;let r=n[e];r?p(r)||v(r)?r=n[e]={type:r,default:t[e]}:r.default=t[e]:r===null&&(r=n[e]={default:t[e]}),r&&t[`__skip_${e}`]&&(r.skipFactory=!0)}return n}function Fa(e,t){return!e||!t?e||t:p(e)&&p(t)?e.concat(t):l({},Na(e),Na(t))}function Ia(e,t){let n={};for(let r in e)t.includes(r)||Object.defineProperty(n,r,{enumerable:!0,get:()=>e[r]});return n}function La(e){let t=Fs(),n=Vs,r=e();zs(),n&&Ls(!1);let i=()=>{Rs(t),n&&Ls(!0)},a=()=>{Fs()!==t&&t.scope.off(),zs(),n&&Ls(!1)};return S(r)&&(r=r.catch(e=>{throw i(),Promise.resolve().then(()=>Promise.resolve().then(a)),e})),[r,()=>{i(),Promise.resolve().then(a)}]}var Ra=!0;function za(e){let t=Ua(e),n=e.proxy,r=e.ctx;Ra=!1,t.beforeCreate&&Va(t.beforeCreate,e,`bc`);let{data:i,computed:o,methods:s,watch:c,provide:l,inject:u,created:d,beforeMount:f,mounted:m,beforeUpdate:h,updated:g,activated:_,deactivated:y,beforeDestroy:b,beforeUnmount:S,destroyed:C,unmounted:w,render:ee,renderTracked:te,renderTriggered:T,errorCaptured:ne,serverPrefetch:re,expose:ie,inheritAttrs:E,components:ae,directives:oe,filters:se}=t;if(u&&Ba(u,r,null),s)for(let e in s){let t=s[e];v(t)&&(r[e]=t.bind(n))}if(i){let t=i.call(n,n);x(t)&&(e.data=Zt(t))}if(Ra=!0,o)for(let e in o){let t=o[e],i=W({get:v(t)?t.bind(n,n):v(t.get)?t.get.bind(n,n):a,set:!v(t)&&v(t.set)?t.set.bind(n):a});Object.defineProperty(r,e,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e})}if(c)for(let e in c)Ha(c[e],r,n,e);if(l){let e=v(l)?l.call(n):l;Reflect.ownKeys(e).forEach(t=>{vr(t,e[t])})}d&&Va(d,e,`c`);function ce(e,t){p(t)?t.forEach(t=>e(t.bind(n))):t&&e(t.bind(n))}if(ce(Xi,f),ce(Zi,m),ce(Qi,h),ce($i,g),ce(Hi,_),ce(Ui,y),ce(aa,ne),ce(ia,te),ce(ra,T),ce(ea,S),ce(ta,w),ce(na,re),p(ie)){if(ie.length){let t=e.exposed||={};ie.forEach(e=>{Object.defineProperty(t,e,{get:()=>n[e],set:t=>n[e]=t,enumerable:!0})})}else e.exposed||={}}ee&&e.render===a&&(e.render=ee),E!=null&&(e.inheritAttrs=E),ae&&(e.components=ae),oe&&(e.directives=oe),re&&oi(e)}function Ba(e,t,n=a){p(e)&&(e=Ja(e));for(let n in e){let r=e[n],i;i=x(r)?`default`in r?yr(r.from||n,r.default,!0):yr(r.from||n):yr(r),j(i)?Object.defineProperty(t,n,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e}):t[n]=i}}function Va(e,t,n){Hn(p(e)?e.map(e=>e.bind(t.proxy)):e.bind(t.proxy),t,n)}function Ha(e,t,n,r){let i=r.includes(`.`)?kr(n,r):()=>n[r];if(y(e)){let n=t[e];v(n)&&Er(i,n)}else if(v(e))Er(i,e.bind(n));else if(x(e)){if(p(e))e.forEach(e=>Ha(e,t,n,r));else{let r=v(e.handler)?e.handler.bind(n):t[e.handler];v(r)&&Er(i,r,e)}}}function Ua(e){let t=e.type,{mixins:n,extends:r}=t,{mixins:i,optionsCache:a,config:{optionMergeStrategies:o}}=e.appContext,s=a.get(t),c;return s?c=s:!i.length&&!n&&!r?c=t:(c={},i.length&&i.forEach(e=>Wa(c,e,o,!0)),Wa(c,t,o)),x(t)&&a.set(t,c),c}function Wa(e,t,n,r=!1){let{mixins:i,extends:a}=t;a&&Wa(e,a,n,!0),i&&i.forEach(t=>Wa(e,t,n,!0));for(let i in t)if(!(r&&i===`expose`)){let r=Ga[i]||n&&n[i];e[i]=r?r(e[i],t[i]):t[i]}return e}var Ga={data:Ka,props:Za,emits:Za,methods:Xa,computed:Xa,beforeCreate:Ya,created:Ya,beforeMount:Ya,mounted:Ya,beforeUpdate:Ya,updated:Ya,beforeDestroy:Ya,beforeUnmount:Ya,destroyed:Ya,unmounted:Ya,activated:Ya,deactivated:Ya,errorCaptured:Ya,serverPrefetch:Ya,components:Xa,directives:Xa,watch:Qa,provide:Ka,inject:qa};function Ka(e,t){return t?e?function(){return l(v(e)?e.call(this,this):e,v(t)?t.call(this,this):t)}:t:e}function qa(e,t){return Xa(Ja(e),Ja(t))}function Ja(e){if(p(e)){let t={};for(let n=0;n<e.length;n++)t[e[n]]=e[n];return t}return e}function Ya(e,t){return e?[...new Set([].concat(e,t))]:t}function Xa(e,t){return e?l(Object.create(null),e,t):t}function Za(e,t){return e?p(e)&&p(t)?[...new Set([...e,...t])]:l(Object.create(null),Na(e),Na(t??{})):t}function Qa(e,t){if(!e)return t;if(!t)return e;let n=l(Object.create(null),e);for(let r in t)n[r]=Ya(e[r],t[r]);return n}function $a(){return{app:null,config:{isNativeTag:o,performance:!1,globalProperties:{},optionMergeStrategies:{},errorHandler:void 0,warnHandler:void 0,compilerOptions:{}},mixins:[],components:{},directives:{},provides:Object.create(null),optionsCache:new WeakMap,propsCache:new WeakMap,emitsCache:new WeakMap}}var eo=0;function to(e,t){return function(n,r=null){v(n)||(n=l({},n)),r!=null&&!x(r)&&(r=null);let i=$a(),a=new WeakSet,o=[],s=!1,c=i.app={_uid:eo++,_component:n,_props:r,_container:null,_context:i,_instance:null,version:ic,get config(){return i.config},set config(e){},use(e,...t){return a.has(e)||(e&&v(e.install)?(a.add(e),e.install(c,...t)):v(e)&&(a.add(e),e(c,...t))),c},mixin(e){return i.mixins.includes(e)||i.mixins.push(e),c},component(e,t){return t?(i.components[e]=t,c):i.components[e]},directive(e,t){return t?(i.directives[e]=t,c):i.directives[e]},mount(a,o,l){if(!s){let u=c._ceVNode||H(n,r);return u.appContext=i,l===!0?l=`svg`:l===!1&&(l=void 0),o&&t?t(u,a):e(u,a,l),s=!0,c._container=a,a.__vue_app__=c,Qs(u.component)}},onUnmount(e){o.push(e)},unmount(){s&&(Hn(o,c._instance,16),e(null,c._container),delete c._container.__vue_app__)},provide(e,t){return i.provides[e]=t,c},runWithContext(e){let t=no;no=c;try{return e()}finally{no=t}}};return c}}var no=null;function ro(e,t,n=r){let i=Fs(),a=E(t),o=oe(t),s=io(e,a),c=vn((s,c)=>{let l,u=r,d;return Tr(()=>{let t=e[a];D(l,t)&&(l=t,c())}),{get(){return s(),n.get?n.get(l):l},set(e){let s=n.set?n.set(e):e;if(!D(s,l)&&!(u!==r&&D(e,u)))return;let f=i.vnode.props,p=!!(f&&(t in f||a in f||o in f)&&(`onUpdate:${t}`in f||`onUpdate:${a}`in f||`onUpdate:${o}`in f));p||(l=e,c()),i.emit(`update:${t}`,s),D(e,u)&&(D(e,s)&&!D(s,d)||p&&u!==r&&!D(s,l))&&c(),u=e,d=s}}});return c[Symbol.iterator]=()=>{let e=0;return{next(){return e<2?{value:e++?s||r:c,done:!1}:{done:!0}}}},c}var io=(e,t)=>t===`modelValue`||t===`model-value`?e.modelModifiers:e[`${t}Modifiers`]||e[`${E(t)}Modifiers`]||e[`${oe(t)}Modifiers`];function ao(e,t,...n){if(e.isUnmounted)return;let i=e.vnode.props||r,a=n,o=t.startsWith(`update:`),s=o&&io(i,t.slice(7));s&&(s.trim&&(a=n.map(e=>y(e)?e.trim():e)),s.number&&(a=n.map(de)));let c,l=i[c=ce(t)]||i[c=ce(E(t))];!l&&o&&(l=i[c=ce(oe(t))]),l&&Hn(l,e,6,a);let u=i[c+`Once`];if(u){if(!e.emitted)e.emitted={};else if(e.emitted[c])return;e.emitted[c]=!0,Hn(u,e,6,a)}}var oo=new WeakMap;function so(e,t,n=!1){let r=n?oo:t.emitsCache,i=r.get(e);if(i!==void 0)return i;let a=e.emits,o={},s=!1;if(!v(e)){let r=e=>{let n=so(e,t,!0);n&&(s=!0,l(o,n))};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}return!a&&!s?(x(e)&&r.set(e,null),null):(p(a)?a.forEach(e=>o[e]=null):l(o,a),x(e)&&r.set(e,o),o)}function co(e,t){return!e||!s(t)?!1:(t=t.slice(2),t=t===`Once`?t:t.replace(/Once$/,``),f(e,t[0].toLowerCase()+t.slice(1))||f(e,oe(t))||f(e,t))}function lo(e){let{type:t,vnode:n,proxy:r,withProxy:i,propsOptions:[a],slots:o,attrs:s,emit:l,render:u,renderCache:d,props:f,data:p,setupState:m,ctx:h,inheritAttrs:g}=e,_=fr(e),v,y;try{if(n.shapeFlag&4){let e=i||r,t=e;v=Es(u.call(t,e,d,f,m,p,h)),y=s}else{let e=t;v=Es(e.length>1?e(f,{attrs:s,slots:o,emit:l}):e(f,null)),y=t.props?s:fo(s)}}catch(t){us.length=0,Un(t,e,1),v=H(cs)}let b=v;if(y&&g!==!1){let e=Object.keys(y),{shapeFlag:t}=b;e.length&&t&7&&(a&&e.some(c)&&(y=po(y,a)),b=Cs(b,y,!1,!0))}return n.dirs&&(b=Cs(b,null,!1,!0),b.dirs=b.dirs?b.dirs.concat(n.dirs):n.dirs),n.transition&&ri(Mr(b.type)&&ni(b)||b,n.transition),v=b,fr(_),v}function uo(e,t=!0){let n;for(let t=0;t<e.length;t++){let r=e[t];if(gs(r)){if(r.type!==cs||r.children===`v-if`){if(n)return;n=r}}else return}return n}var fo=e=>{let t;for(let n in e)(n===`class`||n===`style`||s(n))&&((t||={})[n]=e[n]);return t},po=(e,t)=>{let n={};for(let r in e)(!c(r)||!(r.slice(9)in t))&&(n[r]=e[r]);return n};function mo(e,t,n){let{props:r,children:i,component:a}=e,{props:o,children:s,patchFlag:c}=t,l=a.emitsOptions;if(t.dirs||t.transition)return!0;if(n&&c>=0){if(c&1024)return!0;if(c&16)return r?ho(r,o,l):!!o;if(c&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let n=e[t];if(go(o,r,n)&&!co(l,n))return!0}}}else return(i||s)&&(!s||!s.$stable)?!0:r===o?!1:r?!o||ho(r,o,l):!!o;return!1}function ho(e,t,n){let r=Object.keys(t);if(r.length!==Object.keys(e).length)return!0;for(let i=0;i<r.length;i++){let a=r[i];if(go(t,e,a)&&!co(n,a))return!0}return!1}function go(e,t,n){let r=e[n],i=t[n];return n===`style`&&x(r)&&x(i)?!Ee(r,i):r!==i}function _o({vnode:e,parent:t,suspense:n},r){for(;t;){let n=t.subTree;if(n.suspense&&n.suspense.activeBranch===e&&(n.suspense.vnode.el=n.el=r,e=n),n===e)(e=t.vnode).el=r,t=t.parent;else break}n&&n.activeBranch===e&&(n.vnode.el=r)}var vo={},yo=()=>Object.create(vo),bo=e=>Object.getPrototypeOf(e)===vo;function xo(e,t,n,r=!1){let i={},a=yo();e.propsDefaults=Object.create(null),Co(e,t,i,a);for(let t in e.propsOptions[0])t in i||(i[t]=void 0);e.props=n?r?i:Qt(i):e.type.props?i:a,e.attrs=a}function So(e,t,n,r){let{props:i,attrs:a,vnode:{patchFlag:o}}=e,s=A(i),[c]=e.propsOptions,l=!1;if((r||o>0)&&!(o&16)){if(o&8){let n=e.vnode.dynamicProps;for(let r=0;r<n.length;r++){let o=n[r];if(co(e.emitsOptions,o))continue;let u=t[o];if(c){if(f(a,o))u!==a[o]&&(a[o]=u,l=!0);else{let t=E(o);i[t]=wo(c,s,t,u,e,!1)}}else u!==a[o]&&(a[o]=u,l=!0)}}}else{Co(e,t,i,a)&&(l=!0);let r;for(let a in s)(!t||!f(t,a)&&((r=oe(a))===a||!f(t,r)))&&(c?n&&(n[a]!==void 0||n[r]!==void 0)&&(i[a]=wo(c,s,a,void 0,e,!0)):delete i[a]);if(a!==s)for(let e in a)(!t||!f(t,e))&&(delete a[e],l=!0)}l&&mt(e.attrs,`set`,``)}function Co(e,t,n,i){let[a,o]=e.propsOptions,s=!1,c;if(t)for(let r in t){if(ne(r))continue;let l=t[r],u;a&&f(a,u=E(r))?!o||!o.includes(u)?n[u]=l:(c||={})[u]=l:co(e.emitsOptions,r)||(!(r in i)||l!==i[r])&&(i[r]=l,s=!0)}if(o){let t=A(n),i=c||r;for(let r=0;r<o.length;r++){let s=o[r];n[s]=wo(a,t,s,i[s],e,!f(i,s))}}return s}function wo(e,t,n,r,i,a){let o=e[n];if(o!=null){let e=f(o,`default`);if(e&&r===void 0){let e=o.default;if(o.type!==Function&&!o.skipFactory&&v(e)){let{propsDefaults:a}=i;if(n in a)r=a[n];else{let o=Rs(i);r=a[n]=e.call(null,t),o()}}else r=e;i.ce&&i.ce._setProp(n,r)}o[0]&&(a&&!e?r=!1:o[1]&&(r===``||r===oe(n))&&(r=!0))}return r}var To=new WeakMap;function Eo(e,t,n=!1){let a=n?To:t.propsCache,o=a.get(e);if(o)return o;let s=e.props,c={},u=[],d=!1;if(!v(e)){let r=e=>{d=!0;let[n,r]=Eo(e,t,!0);l(c,n),r&&u.push(...r)};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}if(!s&&!d)return x(e)&&a.set(e,i),i;if(p(s))for(let e=0;e<s.length;e++){let t=E(s[e]);Do(t)&&(c[t]=r)}else if(s)for(let e in s){let t=E(e);if(Do(t)){let n=s[e],r=c[t]=p(n)||v(n)?{type:n}:l({},n),i=r.type,a=!1,o=!0;if(p(i))for(let e=0;e<i.length;++e){let t=i[e],n=v(t)&&t.name;if(n===`Boolean`){a=!0;break}n===`String`&&(o=!1)}else a=v(i)&&i.name===`Boolean`;r[0]=a,r[1]=o,(a||f(r,`default`))&&u.push(t)}}let m=[c,u];return x(e)&&a.set(e,m),m}function Do(e){return e[0]!==`$`&&!ne(e)}var Oo=e=>e===`_`||e===`_ctx`||e===`$stable`,ko=e=>p(e)?e.map(Es):[Es(e)],Ao=(e,t,n)=>{if(t._n)return t;let r=P((...e)=>ko(t(...e)),n);return r._c=!1,r},jo=(e,t,n)=>{let r=e._ctx;for(let n in e){if(Oo(n))continue;let i=e[n];if(v(i))t[n]=Ao(n,i,r);else if(i!=null){let e=ko(i);t[n]=()=>e}}},Mo=(e,t)=>{let n=ko(t);e.slots.default=()=>n},No=(e,t,n)=>{for(let r in t)(n||!Oo(r))&&(e[r]=t[r])},Po=(e,t,n)=>{let r=e.slots=yo();if(e.vnode.shapeFlag&32){let e=t._;e?(No(r,t,n),n&&ue(r,`_`,e,!0)):jo(t,r)}else t&&Mo(e,t)},Fo=(e,t,n)=>{let{vnode:i,slots:a}=e,o=!0,s=r;if(i.shapeFlag&32){let e=t._;e?n&&e===1?o=!1:No(a,t,n):(o=!t.$stable,jo(t,a)),s=t}else t&&(Mo(e,t),s={default:1});if(o)for(let e in a)!Oo(e)&&s[e]==null&&delete a[e]},Io=is;function Lo(e){return zo(e)}function Ro(e){return zo(e,vi)}function zo(e,t){let n=me();n.__VUE__=!0;let{insert:o,remove:s,patchProp:c,createElement:l,createText:u,createComment:d,setText:f,setElementText:p,parentNode:m,nextSibling:h,setScopeId:g=a,insertStaticContent:_}=e,v=(e,t,n,r=null,i=null,a=null,o=void 0,s=null,c=!!t.dynamicChildren)=>{if(e===t)return;e&&!_s(e,t)&&(r=O(e),ge(e,i,a,!0),e=null),t.patchFlag===-2&&(c=!1,t.dynamicChildren=null);let{type:l,ref:u,shapeFlag:d}=t;switch(l){case ss:y(e,t,n,r);break;case cs:b(e,t,n,r);break;case ls:e??x(t,n,r,o);break;case L:ae(e,t,n,r,i,a,o,s,c);break;default:d&1?w(e,t,n,r,i,a,o,s,c):d&6?oe(e,t,n,r,i,a,o,s,c):(d&64||d&128)&&l.process(e,t,n,r,i,a,o,s,c,Ce)}u!=null&&i?ui(u,e&&e.ref,a,t||e,!t):u==null&&e&&e.ref!=null&&ui(e.ref,null,a,e,!0)},y=(e,t,n,r)=>{if(e==null)o(t.el=u(t.children),n,r);else{let n=t.el=e.el;t.children!==e.children&&f(n,t.children)}},b=(e,t,n,r)=>{e==null?o(t.el=d(t.children||``),n,r):t.el=e.el},x=(e,t,n,r)=>{[e.el,e.anchor]=_(e.children,t,n,r,e.el,e.anchor)},S=({el:e,anchor:t},n,r)=>{let i;for(;e&&e!==t;)i=h(e),o(e,n,r),e=i;o(t,n,r)},C=({el:e,anchor:t})=>{let n;for(;e&&e!==t;)n=h(e),s(e),e=n;s(t)},w=(e,t,n,r,i,a,o,s,c)=>{if(t.type===`svg`?o=`svg`:t.type===`math`&&(o=`mathml`),e==null)ee(t,n,r,i,a,o,s,c);else{let n=e.el&&e.el._isVueCE?e.el:null;try{n&&n._beginPatch(),re(e,t,i,a,o,s,c)}finally{n&&n._endPatch()}}},ee=(e,t,n,r,i,a,s,u)=>{let d,f,{props:m,shapeFlag:h,transition:g,dirs:_}=e;if(d=e.el=l(e.type,a,m&&m.is,m),h&8?p(d,e.children):h&16&&T(e.children,d,null,r,i,Bo(e,a),s,u),_&&_r(e,null,r,`created`),te(d,e,e.scopeId,s,r),m){for(let e in m)e!==`value`&&!ne(e)&&c(d,e,null,m[e],a,r);`value`in m&&c(d,`value`,null,m.value,a),(f=m.onVnodeBeforeMount)&&As(f,r,e)}_&&_r(e,null,r,`beforeMount`);let v=Ho(i,g);v&&g.beforeEnter(d),o(d,t,n),((f=m&&m.onVnodeMounted)||v||_)&&Io(()=>{try{f&&As(f,r,e),v&&g.enter(d),_&&_r(e,null,r,`mounted`)}finally{}},i)},te=(e,t,n,r,i)=>{if(n&&g(e,n),r)for(let t=0;t<r.length;t++)g(e,r[t]);if(i){let n=i.subTree;if(t===n||Jo(n.type)&&(n.ssContent===t||n.ssFallback===t)){let t=i.vnode;te(e,t,t.scopeId,t.slotScopeIds,i.parent)}}},T=(e,t,n,r,i,a,o,s,c=0)=>{for(let l=c;l<e.length;l++){let c=e[l]=s?Ds(e[l]):Es(e[l]);v(null,c,t,n,r,i,a,o,s)}},re=(e,t,n,i,a,o,s)=>{let l=t.el=e.el,{patchFlag:u,dynamicChildren:d,dirs:f}=t;u|=e.patchFlag&16;let m=e.props||r,h=t.props||r,g;if(n&&Vo(n,!1),(g=h.onVnodeBeforeUpdate)&&As(g,n,t,e),f&&_r(t,e,n,`beforeUpdate`),n&&Vo(n,!0),d&&(!e.dynamicChildren||e.dynamicChildren.length!==d.length)&&(u=0,s=!1,d=null),(m.innerHTML&&h.innerHTML==null||m.textContent&&h.textContent==null)&&p(l,``),d?ie(e.dynamicChildren,d,l,n,i,Bo(t,a),o):s||de(e,t,l,null,n,i,Bo(t,a),o,!1),u>0){if(u&16)E(l,m,h,n,a);else if(u&2&&m.class!==h.class&&c(l,`class`,null,h.class,a),u&4&&c(l,`style`,m.style,h.style,a),u&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let r=e[t],i=m[r],o=h[r];(o!==i||r===`value`)&&c(l,r,i,o,a,n)}}u&1&&e.children!==t.children&&p(l,t.children)}else!s&&d==null&&E(l,m,h,n,a);((g=h.onVnodeUpdated)||f)&&Io(()=>{g&&As(g,n,t,e),f&&_r(t,e,n,`updated`)},i)},ie=(e,t,n,r,i,a,o)=>{for(let s=0;s<t.length;s++){let c=e[s],l=t[s],u=c.el&&(c.type===L||!_s(c,l)||c.shapeFlag&198)?m(c.el):n;v(c,l,u,null,r,i,a,o,!0)}},E=(e,t,n,i,a)=>{if(t!==n){if(t!==r)for(let r in t)!ne(r)&&!(r in n)&&c(e,r,t[r],null,a,i);for(let r in n){if(ne(r))continue;let o=n[r],s=t[r];o!==s&&r!==`value`&&c(e,r,s,o,a,i)}`value`in n&&c(e,`value`,t.value,n.value,a)}},ae=(e,t,n,r,i,a,s,c,l)=>{let d=t.el=e?e.el:u(``),f=t.anchor=e?e.anchor:u(``),{patchFlag:p,dynamicChildren:m,slotScopeIds:h}=t;h&&(c=c?c.concat(h):h),e==null?(o(d,n,r),o(f,n,r),T(t.children||[],n,f,i,a,s,c,l)):p>0&&p&64&&m&&e.dynamicChildren&&e.dynamicChildren.length===m.length?(ie(e.dynamicChildren,m,n,i,a,s,c),(t.key!=null||i&&t===i.subTree)&&Uo(e,t,!0)):de(e,t,n,f,i,a,s,c,l)},oe=(e,t,n,r,i,a,o,s,c)=>{t.slotScopeIds=s,e==null?t.shapeFlag&512?i.ctx.activate(t,n,r,o,c):se(t,n,r,i,a,o,c):ce(e,t,c)},se=(e,t,n,r,i,a,o)=>{let s=e.component=Ns(e,r,i);if(zi(e)&&(s.ctx.renderer=Ce),Hs(s,!1,o),s.asyncDep){if(i&&i.registerDep(s,D,o),!e.el){let r=s.subTree=H(cs);b(null,r,t,n),e.placeholder=r.el}}else D(s,e,t,n,i,a,o)},ce=(e,t,n)=>{let r=t.component=e.component;if(mo(e,t,n)){if(r.asyncDep&&!r.asyncResolved){ue(r,t,n);return}r.next=t,r.update()}else t.el=e.el,r.vnode=t},D=(e,t,n,r,i,a,o)=>{let s=()=>{if(e.isMounted){let{next:t,bu:n,u:r,parent:s,vnode:c}=e;{let n=Go(e);if(n){t&&(t.el=c.el,ue(e,t,o)),n.asyncDep.then(()=>{Io(()=>{e.isUnmounted||l()},i)});return}}let u=t,d;Vo(e,!1),t?(t.el=c.el,ue(e,t,o)):t=c,n&&le(n),(d=t.props&&t.props.onVnodeBeforeUpdate)&&As(d,s,t,c),Vo(e,!0);let f=lo(e),p=e.subTree;e.subTree=f,v(p,f,m(p.el),O(p),e,i,a),t.el=f.el,u===null&&_o(e,f.el),r&&Io(r,i),(d=t.props&&t.props.onVnodeUpdated)&&Io(()=>As(d,s,t,c),i)}else{let o,{el:s,props:c}=t,{bm:l,m:u,parent:d,root:f,type:p}=e,m=Ii(t);if(Vo(e,!1),l&&le(l),!m&&(o=c&&c.onVnodeBeforeMount)&&As(o,d,t),Vo(e,!0),s&&Te){let t=()=>{e.subTree=lo(e),Te(s,e.subTree,e,i,null)};m&&p.__asyncHydrate?p.__asyncHydrate(s,e,t):t()}else{f.ce&&f.ce._hasShadowRoot()&&f.ce._injectChildStyle(p,e.parent?e.parent.type:void 0);let o=e.subTree=lo(e);v(null,o,n,r,e,i,a),t.el=o.el}if(u&&Io(u,i),!m&&(o=c&&c.onVnodeMounted)){let e=t;Io(()=>As(o,d,e),i)}(t.shapeFlag&256||d&&Ii(d.vnode)&&d.vnode.shapeFlag&256)&&e.a&&Io(e.a,i),e.isMounted=!0,t=n=r=null}};e.scope.on();let c=e.effect=new ze(s);e.scope.off();let l=e.update=c.run.bind(c),u=e.job=c.runIfDirty.bind(c);u.i=e,u.id=e.uid,c.scheduler=()=>er(u),Vo(e,!0),l()},ue=(e,t,n)=>{t.component=e;let r=e.vnode.props;e.vnode=t,e.next=null,So(e,t.props,r,n),Fo(e,t.children,n),nt(),rr(e),rt()},de=(e,t,n,r,i,a,o,s,c=!1)=>{let l=e&&e.children,u=e?e.shapeFlag:0,d=t.children,{patchFlag:f,shapeFlag:m}=t;if(f>0){if(f&128){pe(l,d,n,r,i,a,o,s,c);return}if(f&256){fe(l,d,n,r,i,a,o,s,c);return}}m&8?(u&16&&be(l,i,a),d!==l&&p(n,d)):u&16?m&16?pe(l,d,n,r,i,a,o,s,c):be(l,i,a,!0):(u&8&&p(n,``),m&16&&T(d,n,r,i,a,o,s,c))},fe=(e,t,n,r,a,o,s,c,l)=>{e||=i,t||=i;let u=e.length,d=t.length,f=Math.min(u,d),p;for(p=0;p<f;p++){let r=t[p]=l?Ds(t[p]):Es(t[p]);v(e[p],r,n,null,a,o,s,c,l)}u>d?be(e,a,o,!0,!1,f):T(t,n,r,a,o,s,c,l,f)},pe=(e,t,n,r,a,o,s,c,l)=>{let u=0,d=t.length,f=e.length-1,p=d-1;for(;u<=f&&u<=p;){let r=e[u],i=t[u]=l?Ds(t[u]):Es(t[u]);if(_s(r,i))v(r,i,n,null,a,o,s,c,l);else break;u++}for(;u<=f&&u<=p;){let r=e[f],i=t[p]=l?Ds(t[p]):Es(t[p]);if(_s(r,i))v(r,i,n,null,a,o,s,c,l);else break;f--,p--}if(u>f){if(u<=p){let e=p+1,i=e<d?t[e].el:r;for(;u<=p;)v(null,t[u]=l?Ds(t[u]):Es(t[u]),n,i,a,o,s,c,l),u++}}else if(u>p)for(;u<=f;)ge(e[u],a,o,!0),u++;else{let m=u,h=u,g=new Map;for(u=h;u<=p;u++){let e=t[u]=l?Ds(t[u]):Es(t[u]);e.key!=null&&g.set(e.key,u)}let _,y=0,b=p-h+1,x=!1,S=0,C=Array(b);for(u=0;u<b;u++)C[u]=0;for(u=m;u<=f;u++){let r=e[u];if(y>=b){ge(r,a,o,!0);continue}let i;if(r.key!=null)i=g.get(r.key);else for(_=h;_<=p;_++)if(C[_-h]===0&&_s(r,t[_])){i=_;break}i===void 0?ge(r,a,o,!0):(C[i-h]=u+1,i>=S?S=i:x=!0,v(r,t[i],n,null,a,o,s,c,l),y++)}let w=x?Wo(C):i;for(_=w.length-1,u=b-1;u>=0;u--){let e=h+u,i=t[e],f=t[e+1],p=e+1<d?f.el||qo(f):r;C[u]===0?v(null,i,n,p,a,o,s,c,l):x&&(_<0||u!==w[_]?he(i,n,p,2):_--)}}},he=(e,t,n,r,i=null)=>{let{el:a,type:c,transition:l,children:u,shapeFlag:d}=e;if(d&6){he(e.component.subTree,t,n,r);return}if(d&128){e.suspense.move(t,n,r);return}if(d&64){c.move(e,t,n,Ce);return}if(c===L){o(a,t,n);for(let e=0;e<u.length;e++)he(u[e],t,n,r);o(e.anchor,t,n);return}if(c===ls){S(e,t,n);return}if(r!==2&&d&1&&l){if(r===0)l.persisted&&!a[Wr]?o(a,t,n):(l.beforeEnter(a),o(a,t,n),Io(()=>l.enter(a),i));else{let{leave:r,delayLeave:i,afterLeave:c}=l,u=()=>{e.ctx.isUnmounted?s(a):o(a,t,n)},d=()=>{let e=a._isLeaving||!!a[Wr];a._isLeaving&&a[Wr](!0),l.persisted&&!e?u():r(a,()=>{u(),c&&c()})};i?i(a,u,d):d()}}else o(a,t,n)},ge=(e,t,n,r=!1,i=!1)=>{let{type:a,props:o,ref:s,children:c,dynamicChildren:l,shapeFlag:u,patchFlag:d,dirs:f,cacheIndex:p,memo:m}=e;if(d===-2&&(i=!1),s!=null&&(nt(),ui(s,null,n,e,!0),rt()),p!=null&&(t.renderCache[p]=void 0),u&256){t.ctx.deactivate(e);return}let h=u&1&&f,g=!Ii(e),_;if(g&&(_=o&&o.onVnodeBeforeUnmount)&&As(_,t,e),u&6)ye(e.component,n,r);else{if(u&128){e.suspense.unmount(n,r);return}h&&_r(e,null,t,`beforeUnmount`),u&64?e.type.remove(e,t,n,Ce,r):l&&!l.hasOnce&&(a!==L||d>0&&d&64)?be(l,t,n,!1,!0):(a===L&&d&384||!i&&u&16)&&be(c,t,n),r&&_e(e)}let v=m!=null&&p==null;(g&&(_=o&&o.onVnodeUnmounted)||h||v)&&Io(()=>{_&&As(_,t,e),h&&_r(e,null,t,`unmounted`),v&&(e.el=null)},n)},_e=e=>{let{type:t,el:n,anchor:r,transition:i}=e;if(t===L){ve(n,r);return}if(t===ls){C(e);return}let a=()=>{s(n),i&&!i.persisted&&i.afterLeave&&i.afterLeave()};if(e.shapeFlag&1&&i&&!i.persisted){let{leave:t,delayLeave:r}=i,o=()=>t(n,a);r?r(e.el,a,o):o()}else a()},ve=(e,t)=>{let n;for(;e!==t;)n=h(e),s(e),e=n;s(t)},ye=(e,t,n)=>{let{bum:r,scope:i,job:a,subTree:o,um:s,m:c,a:l}=e;Ko(c),Ko(l),r&&le(r),i.stop(),a&&(a.flags|=8,ge(o,e,t,n)),s&&Io(s,t),Io(()=>{e.isUnmounted=!0},t)},be=(e,t,n,r=!1,i=!1,a=0)=>{for(let o=a;o<e.length;o++)ge(e[o],t,n,r,i)},O=e=>{if(e.shapeFlag&6)return O(e.component.subTree);if(e.shapeFlag&128)return e.suspense.next();let t=h(e.anchor||e.el),n=t&&t[jr];return n?h(n):t},xe=!1,Se=(e,t,n)=>{let r;e==null?t._vnode&&(ge(t._vnode,null,null,!0),r=t._vnode.component):v(t._vnode||null,e,t,null,null,null,n),t._vnode=e,xe||=(xe=!0,rr(r),ir(),!1)},Ce={p:v,um:ge,m:he,r:_e,mt:se,mc:T,pc:de,pbc:ie,n:O,o:e},we,Te;return t&&([we,Te]=t(Ce)),{render:Se,hydrate:we,createApp:to(Se,we)}}function Bo({type:e,props:t},n){return n===`svg`&&e===`foreignObject`||n===`mathml`&&e===`annotation-xml`&&t&&t.encoding&&t.encoding.includes(`html`)?void 0:n}function Vo({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function Ho(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function Uo(e,t,n=!1){let r=e.children,i=t.children;if(p(r)&&p(i))for(let e=0;e<r.length;e++){let t=r[e],a=i[e];a.shapeFlag&1&&!a.dynamicChildren&&((a.patchFlag<=0||a.patchFlag===32)&&(a=i[e]=Ds(i[e]),a.el=t.el),!n&&a.patchFlag!==-2&&Uo(t,a)),a.type===ss&&(a.patchFlag===-1&&(a=i[e]=Ds(a)),a.el=t.el),a.type===cs&&!a.el&&(a.el=t.el)}}function Wo(e){let t=e.slice(),n=[0],r,i,a,o,s,c=e.length;for(r=0;r<c;r++){let c=e[r];if(c!==0){if(i=n[n.length-1],e[i]<c){t[r]=i,n.push(r);continue}for(a=0,o=n.length-1;a<o;)s=a+o>>1,e[n[s]]<c?a=s+1:o=s;c<e[n[a]]&&(a>0&&(t[r]=n[a-1]),n[a]=r)}}for(a=n.length,o=n[a-1];a-->0;)n[a]=o,o=t[o];return n}function Go(e){let t=e.subTree.component;if(t)return t.asyncDep&&!t.asyncResolved?t:Go(t)}function Ko(e){if(e)for(let t=0;t<e.length;t++)e[t].flags|=8}function qo(e){if(e.placeholder)return e.placeholder;let t=e.component;return t?qo(t.subTree):null}var Jo=e=>e.__isSuspense,Yo=0,Xo={name:`Suspense`,__isSuspense:!0,process(e,t,n,r,i,a,o,s,c,l){if(e==null)Qo(t,n,r,i,a,o,s,c,l);else{if(a&&a.deps>0&&!e.suspense.isInFallback){t.suspense=e.suspense,t.suspense.vnode=t,t.el=e.el;return}$o(e,t,n,r,i,o,s,c,l)}},hydrate:ts,normalize:ns};function Zo(e,t){let n=e.props&&e.props[t];v(n)&&n()}function Qo(e,t,n,r,i,a,o,s,c){let{p:l,o:{createElement:u}}=c,d=u(`div`),f=e.suspense=es(e,i,r,t,d,n,a,o,s,c);l(null,f.pendingBranch=e.ssContent,d,null,r,f,a,o),f.deps>0?(Zo(e,`onPending`),Zo(e,`onFallback`),l(null,e.ssFallback,t,n,r,null,a,o),as(f,e.ssFallback)):f.resolve(!1,!0)}function $o(e,t,n,r,i,a,o,s,{p:c,um:l,o:{createElement:u}}){let d=t.suspense=e.suspense;d.vnode=t,t.el=e.el;let f=t.ssContent,p=t.ssFallback,{activeBranch:m,pendingBranch:h,isInFallback:g,isHydrating:_}=d;if(h)d.pendingBranch=f,_s(h,f)?(c(h,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0?d.resolve():g&&(_||(c(m,p,n,r,i,null,a,o,s),as(d,p)))):(d.pendingId=Yo++,_?(d.isHydrating=!1,d.activeBranch=h):l(h,i,d),d.deps=0,d.effects.length=0,d.hiddenContainer=u(`div`),g?(c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0?d.resolve():(c(m,p,n,r,i,null,a,o,s),as(d,p))):m&&_s(m,f)?(c(m,f,n,r,i,d,a,o,s),d.resolve(!0)):(c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0&&d.resolve()));else if(m&&_s(m,f))c(m,f,n,r,i,d,a,o,s),as(d,f);else if(Zo(t,`onPending`),d.pendingBranch=f,d.pendingId=f.shapeFlag&512?f.component.suspenseId:Yo++,c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0)d.resolve();else{let{timeout:e,pendingId:t}=d;e>0?setTimeout(()=>{d.pendingId===t&&d.fallback(p)},e):e===0&&d.fallback(p)}}function es(e,t,n,r,i,a,o,s,c,l,u=!1){let{p:d,m:f,um:p,n:m,o:{parentNode:h,remove:g}}=l,_,v=os(e);v&&t&&t.pendingBranch&&(_=t.pendingId,t.deps++);let y=e.props?fe(e.props.timeout):void 0,b=a,x={vnode:e,parent:t,parentComponent:n,namespace:o,container:r,hiddenContainer:i,deps:0,pendingId:Yo++,timeout:typeof y==`number`?y:-1,activeBranch:null,isFallbackMountPending:!1,pendingBranch:null,isInFallback:!u,isHydrating:u,isUnmounted:!1,effects:[],resolve(e=!1,n=!1){let{vnode:r,activeBranch:i,pendingBranch:o,pendingId:s,effects:c,parentComponent:l,container:u,isInFallback:d}=x,g=!1;if(x.isHydrating)x.isHydrating=!1;else if(!e){g=i&&o.transition&&o.transition.mode===`out-in`;let e=!1;g&&(i.transition.afterLeave=()=>{s===x.pendingId&&(f(o,u,a===b&&!e?m(i):a,0),nr(c),d&&r.ssFallback&&(r.ssFallback.el=null))}),i&&!x.isFallbackMountPending&&(h(i.el)===u&&(a=m(i),e=!0),p(i,l,x,!0),!g&&d&&r.ssFallback&&Io(()=>r.ssFallback.el=null,x)),g||f(o,u,a,0)}x.isFallbackMountPending=!1,as(x,o),x.pendingBranch=null,x.isInFallback=!1;let y=x.parent,S=!1;for(;y;){if(y.pendingBranch){for(let e=0;e<c.length;e++)y.effects.push(c[e]);S=!0;break}y=y.parent}!S&&!g&&nr(c),x.effects=[],v&&t&&t.pendingBranch&&_===t.pendingId&&(t.deps--,t.deps===0&&!n&&t.resolve()),Zo(r,`onResolve`)},fallback(e){if(!x.pendingBranch)return;let{vnode:t,activeBranch:n,parentComponent:r,container:i,namespace:a}=x;Zo(t,`onFallback`);let o=m(n),l=()=>{x.isFallbackMountPending=!1,x.isInFallback&&(d(null,e,i,o,r,null,a,s,c),as(x,e))},u=e.transition&&e.transition.mode===`out-in`;u&&(x.isFallbackMountPending=!0,n.transition.afterLeave=l),x.isInFallback=!0,p(n,r,null,!0),u||l()},move(e,t,n){x.activeBranch&&f(x.activeBranch,e,t,n),x.container=e},next(){return x.activeBranch&&m(x.activeBranch)},registerDep(e,t,n){let r=!!x.pendingBranch;r&&x.deps++;let i=e.vnode.el;e.asyncDep.catch(t=>{Un(t,e,0)}).then(a=>{if(e.isUnmounted||x.isUnmounted||x.pendingId!==e.suspenseId)return;zs(),e.asyncResolved=!0;let{vnode:s}=e;Ws(e,a,!1),i&&(s.el=i);let c=!i&&e.subTree.el;t(e,s,h(i||e.subTree.el),i?null:m(e.subTree),x,o,n),c&&(s.placeholder=null,g(c)),_o(e,s.el),r&&--x.deps===0&&x.resolve()})},unmount(e,t){x.isUnmounted=!0,x.activeBranch&&p(x.activeBranch,n,e,t),x.pendingBranch&&p(x.pendingBranch,n,e,t)}};return x}function ts(e,t,n,r,i,a,o,s,c){let l=t.suspense=es(t,r,n,e.parentNode,document.createElement(`div`),null,i,a,o,s,!0),u=c(e,l.pendingBranch=t.ssContent,n,l,a,o);return l.deps===0&&l.resolve(!1,!0),u}function ns(e){let{shapeFlag:t,children:n}=e,r=t&32;e.ssContent=rs(r?n.default:n),e.ssFallback=r?rs(n.fallback):H(cs)}function rs(e){let t;if(v(e)){let n=ps&&e._c;n&&(e._d=!1,R()),e=e(),n&&(e._d=!0,t=ds,fs())}return p(e)&&(e=uo(e)),e=Es(e),t&&!e.dynamicChildren&&(e.dynamicChildren=t.filter(t=>t!==e)),e}function is(e,t){t&&t.pendingBranch?p(e)?t.effects.push(...e):t.effects.push(e):nr(e)}function as(e,t){e.activeBranch=t;let{vnode:n,parentComponent:r}=e,i=t.el;for(;!i&&t.component;)t=t.component.subTree,i=t.el;n.el=i,r&&r.subTree===n&&(r.vnode.el=i,_o(r,i))}function os(e){let t=e.props&&e.props.suspensible;return t!=null&&t!==!1}var L=Symbol.for(`v-fgt`),ss=Symbol.for(`v-txt`),cs=Symbol.for(`v-cmt`),ls=Symbol.for(`v-stc`),us=[],ds=null;function R(e=!1){us.push(ds=e?null:[])}function fs(){us.pop(),ds=us[us.length-1]||null}var ps=1;function ms(e,t=!1){ps+=e,e<0&&ds&&t&&(ds.hasOnce=!0)}function hs(e){return e.dynamicChildren=ps>0?ds||i:null,fs(),ps>0&&ds&&ds.push(e),e}function z(e,t,n,r,i,a){return hs(V(e,t,n,r,i,a,!0))}function B(e,t,n,r,i){return hs(H(e,t,n,r,i,!0))}function gs(e){return e?e.__v_isVNode===!0:!1}function _s(e,t){return e.type===t.type&&e.key===t.key}function vs(e){}var ys=({key:e})=>e??null,bs=({ref:e,ref_key:t,ref_for:n})=>(typeof e==`number`&&(e=``+e),e==null?null:y(e)||j(e)||v(e)?{i:ur,r:e,k:t,f:!!n}:e);function V(e,t=null,n=null,r=0,i=null,a=e===L?0:1,o=!1,s=!1){let c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&ys(t),ref:t&&bs(t),scopeId:dr,slotScopeIds:null,children:n,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetStart:null,targetAnchor:null,staticCount:0,shapeFlag:a,patchFlag:r,dynamicProps:i,dynamicChildren:null,appContext:null,ctx:ur};return s?(Os(c,n),a&128&&e.normalize(c)):n&&(c.shapeFlag|=y(n)?8:16),ps>0&&!o&&ds&&(c.patchFlag>0||a&6)&&c.patchFlag!==32&&ds.push(c),c}var H=xs;function xs(e,t=null,n=null,r=0,i=null,a=!1){if((!e||e===la)&&(e=cs),gs(e)){let r=Cs(e,t,!0);return n&&Os(r,n),ps>0&&!a&&ds&&(r.shapeFlag&6?ds[ds.indexOf(e)]=r:ds.push(r)),r.patchFlag=-2,r}if(ec(e)&&(e=e.__vccOpts),t){t=Ss(t);let{class:e,style:n}=t;e&&!y(e)&&(t.class=O(e)),x(n)&&(on(n)&&!p(n)&&(n=l({},n)),t.style=ge(n))}let o=y(e)?1:Jo(e)?128:Mr(e)?64:x(e)?4:v(e)?2:0;return V(e,t,n,r,i,o,a,!0)}function Ss(e){return e?on(e)||bo(e)?l({},e):e:null}function Cs(e,t,n=!1,r=!1){let{props:i,ref:a,patchFlag:o,children:s,transition:c}=e,l=t?ks(i||{},t):i,u={__v_isVNode:!0,__v_skip:!0,type:e.type,props:l,key:l&&ys(l),ref:t&&t.ref?n&&a?p(a)?a.concat(bs(t)):[a,bs(t)]:bs(t):a,scopeId:e.scopeId,slotScopeIds:e.slotScopeIds,children:s,target:e.target,targetStart:e.targetStart,targetAnchor:e.targetAnchor,staticCount:e.staticCount,shapeFlag:e.shapeFlag,patchFlag:t&&e.type!==L?o===-1?16:o|16:o,dynamicProps:e.dynamicProps,dynamicChildren:e.dynamicChildren,appContext:e.appContext,dirs:e.dirs,transition:c,component:e.component,suspense:e.suspense,ssContent:e.ssContent&&Cs(e.ssContent),ssFallback:e.ssFallback&&Cs(e.ssFallback),placeholder:e.placeholder,el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce};return c&&r&&ri(u,c.clone(u)),u}function U(e=` `,t=0){return H(ss,null,e,t)}function ws(e,t){let n=H(ls,null,e);return n.staticCount=t,n}function Ts(e=``,t=!1){return t?(R(),B(cs,null,e)):H(cs,null,e)}function Es(e){return e==null||typeof e==`boolean`?H(cs):p(e)?H(L,null,e.slice()):gs(e)?Ds(e):H(ss,null,String(e))}function Ds(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:Cs(e)}function Os(e,t){let n=0,{shapeFlag:r}=e;if(t==null)t=null;else if(p(t))n=16;else if(typeof t==`object`){if(r&65){let n=t.default;n&&(n._c&&(n._d=!1),Os(e,n()),n._c&&(n._d=!0));return}{n=32;let r=t._;!r&&!bo(t)?t._ctx=ur:r===3&&ur&&(ur.slots._===1?t._=1:(t._=2,e.patchFlag|=1024))}}else if(v(t)){if(r&65){Os(e,{default:t});return}t={default:t,_ctx:ur},n=32}else t=String(t),r&64?(n=16,t=[U(t)]):n=8;e.children=t,e.shapeFlag|=n}function ks(...e){let t={};for(let n=0;n<e.length;n++){let r=e[n];for(let e in r)if(e===`class`)t.class!==r.class&&(t.class=O([t.class,r.class]));else if(e===`style`)t.style=ge([t.style,r.style]);else if(s(e)){let n=t[e],i=r[e];i&&n!==i&&!(p(n)&&n.includes(i))?t[e]=n?[].concat(n,i):i:i==null&&n==null&&!c(e)&&(t[e]=i)}else e!==``&&(t[e]=r[e])}return t}function As(e,t,n,r=null){Hn(e,t,7,[n,r])}var js=$a(),Ms=0;function Ns(e,t,n){let i=e.type,a=(t?t.appContext:e.appContext)||js,o={uid:Ms++,vnode:e,type:i,parent:t,appContext:a,root:null,next:null,subTree:null,effect:null,update:null,job:null,scope:new Ne(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:t?t.provides:Object.create(a.provides),ids:t?t.ids:[``,0,0],accessCache:null,renderCache:[],components:null,directives:null,propsOptions:Eo(i,a),emitsOptions:so(i,a),emit:null,emitted:null,propsDefaults:r,inheritAttrs:i.inheritAttrs,ctx:r,data:r,props:r,attrs:r,slots:r,refs:r,setupState:r,setupContext:null,suspense:n,suspenseId:n?n.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return o.ctx={_:o},o.root=t?t.root:o,o.emit=ao.bind(null,o),e.ce&&e.ce(o),o}var Ps=null,Fs=()=>Ps||ur,Is,Ls;{let e=me(),t=(t,n)=>{let r;return(r=e[t])||(r=e[t]=[]),r.push(n),e=>{r.length>1?r.forEach(t=>t(e)):r[0](e)}};Is=t(`__VUE_INSTANCE_SETTERS__`,e=>Ps=e),Ls=t(`__VUE_SSR_SETTERS__`,e=>Vs=e)}var Rs=e=>{let t=Ps;return Is(e),e.scope.on(),()=>{e.scope.off(),Is(t)}},zs=()=>{Ps&&Ps.scope.off(),Is(null)};function Bs(e){return e.vnode.shapeFlag&4}var Vs=!1;function Hs(e,t=!1,n=!1){t&&Ls(t);let{props:r,children:i}=e.vnode,a=Bs(e);xo(e,r,a,t),Po(e,i,n||t);let o=a?Us(e,t):void 0;return t&&Ls(!1),o}function Us(e,t){let n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,xa);let{setup:r}=n;if(r){nt();let n=e.setupContext=r.length>1?Zs(e):null,i=Rs(e),a=Vn(r,e,0,[e.props,n]),o=S(a);if(rt(),i(),(o||e.sp)&&!Ii(e)&&oi(e),o){if(a.then(zs,zs),t)return a.then(n=>{Ls(!0);try{Ws(e,n,t)}finally{Ls(!1)}}).catch(t=>{Un(t,e,0)});e.asyncDep=a}else Ws(e,a,t)}else Ys(e,t)}function Ws(e,t,n){v(t)?e.type.__ssrInlineRender?e.ssrRender=t:e.render=t:x(t)&&(e.setupState=gn(t)),Ys(e,n)}var Gs,Ks;function qs(e){Gs=e,Ks=e=>{e.render._rc&&(e.withProxy=new Proxy(e.ctx,Sa))}}var Js=()=>!Gs;function Ys(e,t,n){let r=e.type;if(!e.render){if(!t&&Gs&&!r.render){let t=r.template||Ua(e).template;if(t){let{isCustomElement:n,compilerOptions:i}=e.appContext.config,{delimiters:a,compilerOptions:o}=r,s=l(l({isCustomElement:n,delimiters:a},i),o);r.render=Gs(t,s)}}e.render=r.render||a,Ks&&Ks(e)}{let t=Rs(e);nt();try{za(e)}finally{rt(),t()}}}var Xs={get(e,t){return pt(e,`get`,``),e[t]}};function Zs(e){return{attrs:new Proxy(e.attrs,Xs),slots:e.slots,emit:e.emit,expose:t=>{e.exposed=t||{}}}}function Qs(e){return e.exposed?e.exposeProxy||=new Proxy(gn(sn(e.exposed)),{get(t,n){if(n in t)return t[n];if(n in ya)return ya[n](e)},has(e,t){return t in e||t in ya}}):e.proxy}function $s(e,t=!0){return v(e)?e.displayName||e.name:e.name||t&&e.__name}function ec(e){return v(e)&&`__vccOpts`in e}var W=(e,t)=>Tn(e,t,Vs);function G(e,t,n){try{ms(-1);let r=arguments.length;return r===2?x(t)&&!p(t)?gs(t)?H(e,null,[t]):H(e,t):H(e,null,t):(r>3?n=Array.prototype.slice.call(arguments,2):r===3&&gs(n)&&(n=[n]),H(e,t,n))}finally{ms(1)}}function tc(){}function nc(e,t,n,r){let i=n[r];if(i&&rc(i,e))return i;let a=t();return a.memo=e.slice(),a.cacheIndex=r,n[r]=a}function rc(e,t){let n=e.memo;if(n.length!=t.length)return!1;for(let e=0;e<n.length;e++)if(D(n[e],t[e]))return!1;return ps>0&&ds&&ds.push(e),!0}var ic=`3.5.41`,ac=a,oc=Bn,sc=sr,cc=lr,lc={createComponentInstance:Ns,setupComponent:Hs,renderComponentRoot:lo,setCurrentRenderingInstance:fr,isVNode:gs,normalizeVNode:Es,getComponentPublicInstance:Qs,ensureValidVNode:ga,pushWarningContext:In,popWarningContext:Ln},uc=void 0,dc=typeof window<`u`&&window.trustedTypes;if(dc)try{uc=dc.createPolicy(`vue`,{createHTML:e=>e})}catch{}var fc=uc?e=>uc.createHTML(e):e=>e,pc=`http://www.w3.org/2000/svg`,mc=`http://www.w3.org/1998/Math/MathML`,hc=typeof document<`u`?document:null,gc=hc&&hc.createElement(`template`),_c={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{let t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,r)=>{let i=t===`svg`?hc.createElementNS(pc,e):t===`mathml`?hc.createElementNS(mc,e):n?hc.createElement(e,{is:n}):hc.createElement(e);return e===`select`&&r&&r.multiple!=null&&i.setAttribute(`multiple`,r.multiple),i},createText:e=>hc.createTextNode(e),createComment:e=>hc.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>hc.querySelector(e),setScopeId(e,t){e.setAttribute(t,``)},insertStaticContent(e,t,n,r,i,a){let o=n?n.previousSibling:t.lastChild;if(i&&(i===a||i.nextSibling))for(;t.insertBefore(i.cloneNode(!0),n),!(i===a||!(i=i.nextSibling)););else{gc.innerHTML=fc(r===`svg`?`<svg>${e}</svg>`:r===`mathml`?`<math>${e}</math>`:e);let i=gc.content;if(r===`svg`||r===`mathml`){let e=i.firstChild;for(;e.firstChild;)i.appendChild(e.firstChild);i.removeChild(e)}t.insertBefore(i,n)}return[o?o.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},vc=`transition`,yc=`animation`,bc=Symbol(`_vtc`),xc={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Sc=l({},Jr,xc),Cc=(e=>(e.displayName=`Transition`,e.props=Sc,e))((e,{slots:t})=>G(Qr,Ec(e),t)),wc=(e,t=[])=>{p(e)?e.forEach(e=>e(...t)):e&&e(...t)},Tc=e=>e?p(e)?e.some(e=>e.length>1):e.length>1:!1;function Ec(e){let t={};for(let n in e)n in xc||(t[n]=e[n]);if(e.css===!1)return t;let{name:n=`v`,type:r,duration:i,enterFromClass:a=`${n}-enter-from`,enterActiveClass:o=`${n}-enter-active`,enterToClass:s=`${n}-enter-to`,appearFromClass:c=a,appearActiveClass:u=o,appearToClass:d=s,leaveFromClass:f=`${n}-leave-from`,leaveActiveClass:p=`${n}-leave-active`,leaveToClass:m=`${n}-leave-to`}=e,h=Dc(i),g=h&&h[0],_=h&&h[1],{onBeforeEnter:v,onEnter:y,onEnterCancelled:b,onLeave:x,onLeaveCancelled:S,onBeforeAppear:C=v,onAppear:w=y,onAppearCancelled:ee=b}=t,te=(e,t,n,r)=>{e._enterCancelled=r,Ac(e,t?d:s),Ac(e,t?u:o),n&&n()},T=(e,t)=>{e._isLeaving=!1,Ac(e,f),Ac(e,m),Ac(e,p),t&&t()},ne=e=>(t,n)=>{let i=e?w:y,o=()=>te(t,e,n);wc(i,[t,o]),jc(()=>{Ac(t,e?c:a),kc(t,e?d:s),Tc(i)||Nc(t,r,g,o)})};return l(t,{onBeforeEnter(e){wc(v,[e]),kc(e,a),kc(e,o)},onBeforeAppear(e){wc(C,[e]),kc(e,c),kc(e,u)},onEnter:ne(!1),onAppear:ne(!0),onLeave(e,t){e._isLeaving=!0;let n=()=>T(e,t);kc(e,f),e._enterCancelled?(kc(e,p),Lc(e)):(Lc(e),kc(e,p)),jc(()=>{e._isLeaving&&(Ac(e,f),kc(e,m),Tc(x)||Nc(e,r,_,n))}),wc(x,[e,n])},onEnterCancelled(e){te(e,!1,void 0,!0),wc(b,[e])},onAppearCancelled(e){te(e,!0,void 0,!0),wc(ee,[e])},onLeaveCancelled(e){T(e),wc(S,[e])}})}function Dc(e){if(e==null)return null;if(x(e))return[Oc(e.enter),Oc(e.leave)];{let t=Oc(e);return[t,t]}}function Oc(e){return fe(e)}function kc(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.add(t)),(e[bc]||(e[bc]=new Set)).add(t)}function Ac(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.remove(t));let n=e[bc];n&&(n.delete(t),n.size||(e[bc]=void 0))}function jc(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}var Mc=0;function Nc(e,t,n,r){let i=e._endId=++Mc,a=()=>{i===e._endId&&r()};if(n!=null)return setTimeout(a,n);let{type:o,timeout:s,propCount:c}=Pc(e,t);if(!o)return r();let l=o+`end`,u=0,d=()=>{e.removeEventListener(l,f),a()},f=t=>{t.target===e&&++u>=c&&d()};setTimeout(()=>{u<c&&d()},s+1),e.addEventListener(l,f)}function Pc(e,t){let n=window.getComputedStyle(e),r=e=>(n[e]||``).split(`, `),i=r(`${vc}Delay`),a=r(`${vc}Duration`),o=Fc(i,a),s=r(`${yc}Delay`),c=r(`${yc}Duration`),l=Fc(s,c),u=null,d=0,f=0;t===vc?o>0&&(u=vc,d=o,f=a.length):t===yc?l>0&&(u=yc,d=l,f=c.length):(d=Math.max(o,l),u=d>0?o>l?vc:yc:null,f=u?u===vc?a.length:c.length:0);let p=u===vc&&/\b(?:transform|all)(?:,|$)/.test(r(`${vc}Property`).toString());return{type:u,timeout:d,propCount:f,hasTransform:p}}function Fc(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max(...t.map((t,n)=>Ic(t)+Ic(e[n])))}function Ic(e){return e===`auto`?0:Number(e.slice(0,-1).replace(`,`,`.`))*1e3}function Lc(e){return(e?e.ownerDocument:document).body.offsetHeight}function Rc(e,t,n){let r=e[bc];r&&(t=(t?[t,...r]:[...r]).join(` `)),t==null?e.removeAttribute(`class`):n?e.setAttribute(`class`,t):e.className=t}var zc=Symbol(`_vod`),Bc=Symbol(`_vsh`),Vc={name:`show`,beforeMount(e,{value:t},{transition:n}){e[zc]=e.style.display===`none`?``:e.style.display,n&&t?n.beforeEnter(e):Hc(e,t)},mounted(e,{value:t},{transition:n}){n&&t&&n.enter(e)},updated(e,{value:t,oldValue:n},{transition:r}){!t!=!n&&(r?t?(r.beforeEnter(e),Hc(e,!0),r.enter(e)):r.leave(e,()=>{Hc(e,!1)}):Hc(e,t))},beforeUnmount(e,{value:t}){Hc(e,t)}};function Hc(e,t){e.style.display=t?e[zc]:`none`,e[Bc]=!t}function Uc(){Vc.getSSRProps=({value:e})=>{if(!e)return{style:{display:`none`}}}}var Wc=Symbol(``);function Gc(e){let t=Fs();if(!t)return;let n=t.ut=(n=e(t.proxy))=>{Array.from(document.querySelectorAll(`[data-v-owner="${t.uid}"]`)).forEach(e=>qc(e,n))},r=()=>{let r=e(t.proxy);t.ce?qc(t.ce,r):Kc(t.subTree,r),n(r)};Qi(()=>{nr(r)}),Zi(()=>{Er(r,a,{flush:`post`});let e=new MutationObserver(r);e.observe(t.subTree.el.parentNode,{childList:!0}),ta(()=>e.disconnect())})}function Kc(e,t){if(e.shapeFlag&128){let n=e.suspense;e=n.activeBranch,n.pendingBranch&&!n.isHydrating&&n.effects.push(()=>{Kc(n.activeBranch,t)})}for(;e.component;)e=e.component.subTree;if(e.shapeFlag&1&&e.el)qc(e.el,t);else if(e.type===L)e.children.forEach(e=>Kc(e,t));else if(e.type===ls){let{el:n,anchor:r}=e;for(;n&&(qc(n,t),n!==r);)n=n.nextSibling}}function qc(e,t){if(e.nodeType===1){let n=e.style,r=``;for(let e in t){let i=je(t[e]);n.setProperty(`--${e}`,i),r+=`--${e}: ${i};`}n[Wc]=r}}var Jc=/(?:^|;)\s*display\s*:/;function Yc(e,t,n){let r=e.style,i=y(n),a=!1;if(n&&!i){if(t){if(y(t))for(let e of t.split(`;`)){let t=e.slice(0,e.indexOf(`:`)).trim();n[t]??Zc(r,t,``)}else for(let e in t)n[e]??Zc(r,e,``)}for(let i in n){i===`display`&&(a=!0);let o=n[i];o==null?Zc(r,i,``):tl(e,i,!y(t)&&t?t[i]:void 0,o)||Zc(r,i,o)}}else if(i){if(t!==n){let e=r[Wc];e&&(n+=`;`+e),r.cssText=n,a=Jc.test(n)}}else t&&e.removeAttribute(`style`);zc in e&&(e[zc]=a?r.display:``,e[Bc]&&(r.display=`none`))}var Xc=/\s*!important$/;function Zc(e,t,n){if(p(n))n.forEach(n=>Zc(e,t,n));else if(n??=``,t.startsWith(`--`))e.setProperty(t,n);else{let r=el(e,t);Xc.test(n)?e.setProperty(oe(r),n.replace(Xc,``),`important`):e[r]=n}}var Qc=[`Webkit`,`Moz`,`ms`],$c={};function el(e,t){let n=$c[t];if(n)return n;let r=E(t);if(r!==`filter`&&r in e)return $c[t]=r;r=se(r);for(let n=0;n<Qc.length;n++){let i=Qc[n]+r;if(i in e)return $c[t]=i}return t}function tl(e,t,n,r){return e.tagName===`TEXTAREA`&&(t===`width`||t===`height`)&&y(r)&&n===r}var nl=`http://www.w3.org/1999/xlink`;function rl(e,t,n,r,i,a=Ce(t)){r&&t.startsWith(`xlink:`)?n==null?e.removeAttributeNS(nl,t.slice(6,t.length)):e.setAttributeNS(nl,t,n):n==null||a&&!we(n)?e.removeAttribute(t):e.setAttribute(t,a?``:b(n)?String(n):n)}function il(e,t,n,r,i){if(t===`innerHTML`||t===`textContent`){n!=null&&(e[t]=t===`innerHTML`?fc(n):n);return}let a=e.tagName;if(t===`value`&&a!==`PROGRESS`&&!a.includes(`-`)){let r=a===`OPTION`?e.getAttribute(`value`)||``:e.value,i=n==null?e.type===`checkbox`?`on`:``:String(n);(r!==i||!(`_value`in e))&&(e.value=i),n??e.removeAttribute(t),e._value=n;return}let o=!1;if(n===``||n==null){let r=typeof e[t];r===`boolean`?n=we(n):n==null&&r===`string`?(n=``,o=!0):r===`number`&&(n=0,o=!0)}try{e[t]=n}catch{}o&&e.removeAttribute(i||t)}function al(e,t,n,r){e.addEventListener(t,n,r)}function ol(e,t,n,r){e.removeEventListener(t,n,r)}var sl=Symbol(`_vei`);function cl(e,t,n,r,i=null){let a=e[sl]||(e[sl]={}),o=a[t];if(r&&o)o.value=r;else{let[n,s]=dl(t);r?al(e,n,a[t]=hl(r,i),s):o&&(ol(e,n,o,s),a[t]=void 0)}}var ll=/(Once|Passive|Capture)$/,ul=/^on:?(?:Once|Passive|Capture)$/;function dl(e){let t,n;for(;(n=e.match(ll))&&!ul.test(e);)t||={},e=e.slice(0,e.length-n[1].length),t[n[1].toLowerCase()]=!0;return[e[2]===`:`?e.slice(3):oe(e.slice(2)),t]}var fl=0,pl=Promise.resolve(),ml=()=>fl||=(pl.then(()=>fl=0),Date.now());function hl(e,t){let n=e=>{if(!e._vts)e._vts=Date.now();else if(e._vts<=n.attached)return;let r=n.value;if(p(r)){let n=e.stopImmediatePropagation;e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0};let i=r.slice(),a=[e];for(let n=0;n<i.length&&!e._stopped;n++){let e=i[n];e&&Hn(e,t,5,a)}}else Hn(r,t,5,[e])};return n.value=e,n.attached=ml(),n}var gl=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,_l=(e,t,n,r,i,a)=>{let o=i===`svg`;t===`class`?Rc(e,r,o):t===`style`?Yc(e,n,r):s(t)?c(t)||cl(e,t,n,r,a):(t[0]===`.`?(t=t.slice(1),!0):t[0]===`^`?(t=t.slice(1),!1):vl(e,t,r,o))?(il(e,t,r),!e.tagName.includes(`-`)&&(t===`value`||t===`checked`||t===`selected`)&&rl(e,t,r,o,a,t!==`value`)):e._isVueCE&&(yl(e,t)||e._def.__asyncLoader&&(/[A-Z]/.test(t)||!y(r)))?il(e,E(t),r,a,t):(t===`true-value`?e._trueValue=r:t===`false-value`&&(e._falseValue=r),rl(e,t,r,o))};function vl(e,t,n,r){if(r)return!!(t===`innerHTML`||t===`textContent`||t in e&&gl(t)&&v(n));if(t===`spellcheck`||t===`draggable`||t===`translate`||t===`autocorrect`||t===`sandbox`&&e.tagName===`IFRAME`||t===`form`||t===`list`&&e.tagName===`INPUT`||t===`type`&&e.tagName===`TEXTAREA`)return!1;if(t===`width`||t===`height`){let t=e.tagName;if(t===`IMG`||t===`VIDEO`||t===`CANVAS`||t===`SOURCE`)return!1}return gl(t)&&y(n)?!1:t in e}function yl(e,t){let n=e._def.props;if(!n)return!1;let r=E(t);return Array.isArray(n)?n.some(e=>E(e)===r):Object.keys(n).some(e=>E(e)===r)}var bl={};function xl(e,t,n){let r=F(e,t);te(r)&&(r=l({},r,t));class i extends wl{constructor(e){super(r,e,n)}}return i.def=r,i}var Sl=((e,t)=>xl(e,t,hu)),Cl=typeof HTMLElement<`u`?HTMLElement:class{},wl=class e extends Cl{constructor(e,t={},n=mu){super(),this._def=e,this._props=t,this._createApp=n,this._isVueCE=!0,this._instance=null,this._app=null,this._nonce=this._def.nonce,this._connected=!1,this._resolved=!1,this._patching=!1,this._dirty=!1,this._numberProps=null,this._styleChildren=new WeakSet,this._styleAnchors=new WeakMap,this._ob=null,this.shadowRoot&&n!==mu?this._root=this.shadowRoot:e.shadowRoot===!1?this._root=this:(this.attachShadow(l({},e.shadowRootOptions,{mode:`open`})),this._root=this.shadowRoot)}connectedCallback(){if(!this.isConnected)return;!this.shadowRoot&&!this._resolved&&this._parseSlots(),this._connected=!0;let t=this;for(;t&&=t.assignedSlot||t.parentNode||t.host;)if(t instanceof e){this._parent=t;break}this._instance||(this._resolved?this._mount(this._def):t&&t._pendingResolve?this._pendingResolve=t._pendingResolve.then(()=>{if(this._pendingResolve=void 0,this.isConnected)return this._resolveDef()}):this._resolveDef())}_setParent(e=this._parent){e&&(this._instance.parent=e._instance,this._inheritParentContext(e))}_inheritParentContext(e=this._parent){e&&this._app&&Object.setPrototypeOf(this._app._context.provides,e._instance.provides)}disconnectedCallback(){this._connected=!1,Qn(()=>{this._connected||(this._ob&&=(this._ob.disconnect(),null),this._app&&this._app.unmount(),this._instance&&(this._instance.ce=void 0),this._app=this._instance=null,this._teleportTargets&&=(this._teleportTargets.clear(),void 0))})}_processMutations(e){for(let t of e)this._setAttr(t.attributeName)}_resolveDef(){if(this._pendingResolve)return this._pendingResolve;for(let e=0;e<this.attributes.length;e++)this._setAttr(this.attributes[e].name);this._ob=new MutationObserver(this._processMutations.bind(this)),this._ob.observe(this,{attributes:!0});let e=(e,t=!1)=>{this._resolved=!0,this._pendingResolve=void 0;let{props:n,styles:r}=e,i;if(n&&!p(n))for(let e in n){let t=n[e];(t===Number||t&&t.type===Number)&&(e in this._props&&(this._props[e]=fe(this._props[e])),(i||=Object.create(null))[E(e)]=!0)}this._numberProps=i,this._resolveProps(e),this.shadowRoot&&this._applyStyles(r),this._mount(e)},t=this._def.__asyncLoader;if(t)return this._pendingResolve=t().then(t=>{t.configureApp=this._def.configureApp,e(this._def=t,!0)}),this._pendingResolve;e(this._def)}_mount(e){this._app=this._createApp(e),this._inheritParentContext(),e.configureApp&&e.configureApp(this._app),this._app._ceVNode=this._createVNode(),this._app.mount(this._root);let t=this._instance&&this._instance.exposed;if(t)for(let e in t)f(this,e)||Object.defineProperty(this,e,{get:()=>N(t[e])})}_resolveProps(e){let{props:t}=e,n=p(t)?t:Object.keys(t||{});for(let e of Object.keys(this))e[0]!==`_`&&n.includes(e)&&this._setProp(e,this[e]);for(let e of n.map(E))Object.defineProperty(this,e,{get(){return this._getProp(e)},set(t){this._setProp(e,t,!0,!this._patching)}})}_setAttr(e){if(e.startsWith(`data-v-`))return;let t=this.hasAttribute(e),n=t?this.getAttribute(e):bl,r=E(e);t&&this._numberProps&&this._numberProps[r]&&(n=fe(n)),this._setProp(r,n,!1,!0)}_getProp(e){return this._props[e]}_setProp(e,t,n=!0,r=!1){if(t!==this._props[e]&&(this._dirty=!0,t===bl?delete this._props[e]:(this._props[e]=t,e===`key`&&this._app&&(this._app._ceVNode.key=t)),r&&this._instance&&this._update(),n)){let n=this._ob;n&&(this._processMutations(n.takeRecords()),n.disconnect()),t===!0?this.setAttribute(oe(e),``):typeof t==`string`||typeof t==`number`?this.setAttribute(oe(e),t+``):t||this.removeAttribute(oe(e)),n&&n.observe(this,{attributes:!0})}}_update(){let e=this._createVNode();this._app&&(e.appContext=this._app._context),fu(e,this._root)}_createVNode(){let e={};this.shadowRoot||(e.onVnodeMounted=e.onVnodeUpdated=this._renderSlots.bind(this));let t=H(this._def,l(e,this._props));return this._instance||(t.ce=e=>{this._instance=e,e.ce=this,e.isCE=!0;let t=(e,t)=>{this.dispatchEvent(new CustomEvent(e,te(t[0])?l({detail:t},t[0]):{detail:t}))};e.emit=(e,...n)=>{t(e,n),oe(e)!==e&&t(oe(e),n)},this._setParent()}),t}_applyStyles(e,t,n){if(!e)return;if(t){if(t===this._def||this._styleChildren.has(t))return;this._styleChildren.add(t)}let r=this._nonce,i=this.shadowRoot,a=n?this._getStyleAnchor(n)||this._getStyleAnchor(this._def):this._getRootStyleInsertionAnchor(i),o=null;for(let s=e.length-1;s>=0;s--){let c=document.createElement(`style`);r&&c.setAttribute(`nonce`,r),c.textContent=e[s],i.insertBefore(c,o||a),o=c,s===0&&(n||this._styleAnchors.set(this._def,c),t&&this._styleAnchors.set(t,c))}}_getStyleAnchor(e){if(!e)return null;let t=this._styleAnchors.get(e);return t&&t.parentNode===this.shadowRoot?t:(t&&this._styleAnchors.delete(e),null)}_getRootStyleInsertionAnchor(e){for(let t=0;t<e.childNodes.length;t++){let n=e.childNodes[t];if(!(n instanceof HTMLStyleElement))return n}return null}_parseSlots(){let e=this._slots={},t;for(;t=this.firstChild;){let n=t.nodeType===1&&t.getAttribute(`slot`)||`default`;(e[n]||(e[n]=[])).push(t),this.removeChild(t)}}_renderSlots(){let e=this._getSlots(),t=this._instance.type.__scopeId;for(let n=0;n<e.length;n++){let r=e[n],i=r.getAttribute(`name`)||`default`,a=this._slots[i],o=r.parentNode;if(a)for(let e of a){if(t&&e.nodeType===1){let n=t+`-s`,r=document.createTreeWalker(e,1);e.setAttribute(n,``);let i;for(;i=r.nextNode();)i.setAttribute(n,``)}o.insertBefore(e,r)}else for(;r.firstChild;)o.insertBefore(r.firstChild,r);o.removeChild(r)}}_getSlots(){let e=[this];this._teleportTargets&&e.push(...this._teleportTargets);let t=new Set;for(let n of e){let e=n.querySelectorAll(`slot`);for(let n=0;n<e.length;n++)t.add(e[n])}return Array.from(t)}_injectChildStyle(e,t){this._applyStyles(e.styles,e,t)}_beginPatch(){this._patching=!0,this._dirty=!1}_endPatch(){this._patching=!1,this._dirty&&this._instance&&this._update()}_hasShadowRoot(){return this._def.shadowRoot!==!1}_removeChildStyle(e){}};function Tl(e){let t=Fs();return t&&t.ce||null}function El(){let e=Tl();return e&&e.shadowRoot}function Dl(e=`$style`){{let t=Fs();if(!t)return r;let n=t.type.__cssModules;return n&&n[e]||r}}var Ol=new WeakMap,kl=new WeakMap,Al=Symbol(`_moveCb`),jl=Symbol(`_enterCb`),Ml=(e=>(delete e.props.mode,e))({name:`TransitionGroup`,props:l({},Sc,{tag:String,moveClass:String}),setup(e,{slots:t}){let n=Fs(),r=Kr(),i,a;return $i(()=>{if(!i.length)return;let t=e.moveClass||`${e.name||`v`}-move`;if(!Ll(i[0].el,n.vnode.el,t)){i=[];return}i.forEach(Nl),i.forEach(Pl);let r=i.filter(Fl);Lc(n.vnode.el),r.forEach(e=>{let n=e.el,r=n.style;kc(n,t),r.transform=r.webkitTransform=r.transitionDuration=``;let i=n[Al]=e=>{e&&e.target!==n||(!e||e.propertyName.endsWith(`transform`))&&(n.removeEventListener(`transitionend`,i),n[Al]=null,Ac(n,t))};n.addEventListener(`transitionend`,i)}),i=[]}),()=>{let o=A(e),s=Ec(o),c=o.tag||L;if(i=[],a)for(let e=0;e<a.length;e++){let t=a[e];t.el&&t.el instanceof Element&&!t.el[Bc]&&(i.push(t),ri(t,ei(t,s,r,n)),Ol.set(t,Il(t.el)))}a=t.default?ii(t.default()):[];for(let e=0;e<a.length;e++){let t=a[e];t.key!=null&&ri(t,ei(t,s,r,n))}return H(c,null,a)}}});function Nl(e){let t=e.el;t[Al]&&t[Al](),t[jl]&&t[jl]()}function Pl(e){kl.set(e,Il(e.el))}function Fl(e){let t=Ol.get(e),n=kl.get(e),r=t.left-n.left,i=t.top-n.top;if(r||i){let t=e.el,n=t.style,a=t.getBoundingClientRect(),o=1,s=1;return t.offsetWidth&&(o=a.width/t.offsetWidth),t.offsetHeight&&(s=a.height/t.offsetHeight),(!Number.isFinite(o)||o===0)&&(o=1),(!Number.isFinite(s)||s===0)&&(s=1),Math.abs(o-1)<.01&&(o=1),Math.abs(s-1)<.01&&(s=1),n.transform=n.webkitTransform=`translate(${r/o}px,${i/s}px)`,n.transitionDuration=`0s`,e}}function Il(e){let t=e.getBoundingClientRect();return{left:t.left,top:t.top}}function Ll(e,t,n){let r=e.cloneNode(),i=e[bc];i&&i.forEach(e=>{e.split(/\s+/).forEach(e=>e&&r.classList.remove(e))}),n.split(/\s+/).forEach(e=>e&&r.classList.add(e)),r.style.display=`none`;let a=t.nodeType===1?t:t.parentNode;a.appendChild(r);let{hasTransform:o}=Pc(r);return a.removeChild(r),o}var Rl=e=>{let t=e.props[`onUpdate:modelValue`]||!1;return p(t)?e=>le(t,e):t};function zl(e){e.target.composing=!0}function Bl(e){let t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event(`input`)))}var Vl=Symbol(`_assign`),Hl=Symbol(`_initialValue`);function Ul(e,t,n){return t&&(e=e.trim()),n&&(e=de(e)),e}var Wl={created(e,{modifiers:{lazy:t,trim:n,number:r}},i){e.parentNode&&(e.type===`text`?e[Hl]=e.defaultValue.replace(/[\r\n]/g,``):e.type===`textarea`&&(e[Hl]=e.defaultValue.replace(/\r\n?/g,`
`))),e[Vl]=Rl(i);let a=r||i.props&&i.props.type===`number`;al(e,t?`change`:`input`,t=>{t.target.composing||e[Vl](Ul(e.value,n,a))}),(n||a)&&al(e,`change`,()=>{e.value=Ul(e.value,n,a)}),t||(al(e,`compositionstart`,zl),al(e,`compositionend`,Bl),al(e,`change`,Bl))},mounted(e,{value:t,modifiers:{trim:n,number:r}}){let i=t??``,a=e[Hl];delete e[Hl],a!==void 0&&(e.type===`text`||e.type===`textarea`)&&e.value!==a?e[Vl](Ul(e.value,n,r)):e.value=i},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:r,trim:i,number:a}},o){if(e[Vl]=Rl(o),e.composing)return;let s=(a||e.type===`number`)&&!/^0\d/.test(e.value)?de(e.value):e.value,c=t??``;if(s===c)return;let l=e.getRootNode();(l instanceof Document||l instanceof ShadowRoot)&&l.activeElement===e&&e.type!==`range`&&(r&&t===n||i&&e.value.trim()===c)||(e.value=c)}},Gl={deep:!0,created(e,t,n){e[Vl]=Rl(n),al(e,`change`,()=>{let t=e._modelValue,n=Xl(e),r=e.checked,i=e[Vl];if(p(t)){let e=De(t,n),a=e!==-1;if(r&&!a)i(t.concat(n));else if(!r&&a){let n=[...t];n.splice(e,1),i(n)}}else if(h(t)){let e=new Set(t);r?e.add(n):e.delete(n),i(e)}else i(Zl(e,r))})},mounted:Kl,beforeUpdate(e,t,n){e[Vl]=Rl(n),Kl(e,t,n)}};function Kl(e,{value:t,oldValue:n},r){e._modelValue=t;let i;if(p(t))i=De(t,r.props.value)>-1;else if(h(t))i=t.has(r.props.value);else{if(t===n)return;i=Ee(t,Zl(e,!0))}e.checked!==i&&(e.checked=i)}var ql={created(e,{value:t},n){e.checked=Ee(t,n.props.value),e[Vl]=Rl(n),al(e,`change`,()=>{e[Vl](Xl(e))})},beforeUpdate(e,{value:t,oldValue:n},r){e[Vl]=Rl(r),t!==n&&(e.checked=Ee(t,r.props.value))}},Jl={deep:!0,created(e,{value:t,modifiers:{number:n}},r){e._modelValue=t,al(e,`change`,()=>{let t=Array.prototype.filter.call(e.options,e=>e.selected).map(e=>n?de(Xl(e)):Xl(e));e[Vl](e.multiple?h(e._modelValue)?new Set(t):t:t[0]),e._assigning=!0,Qn(()=>{e._assigning=!1})}),e[Vl]=Rl(r)},mounted(e,{value:t}){Yl(e,t)},beforeUpdate(e,{value:t},n){e._modelValue=t,e[Vl]=Rl(n)},updated(e,{value:t}){e._assigning||Yl(e,t)}};function Yl(e,t){let n=e.multiple,r=p(t);if(!(n&&!r&&!h(t))){for(let i=0,a=e.options.length;i<a;i++){let a=e.options[i],o=Xl(a);if(n){if(r){let e=typeof o;a.selected=e===`string`||e===`number`?t.some(e=>String(e)===String(o)):De(t,o)>-1}else a.selected=t.has(o)}else if(Ee(Xl(a),t)){e.selectedIndex!==i&&(e.selectedIndex=i);return}}!n&&e.selectedIndex!==-1&&(e.selectedIndex=-1)}}function Xl(e){return`_value`in e?e._value:e.value}function Zl(e,t){let n=t?`_trueValue`:`_falseValue`;return n in e?e[n]:t}var Ql={created(e,t,n){eu(e,t,n,null,`created`)},mounted(e,t,n){eu(e,t,n,null,`mounted`)},beforeUpdate(e,t,n,r){eu(e,t,n,r,`beforeUpdate`)},updated(e,t,n,r){eu(e,t,n,r,`updated`)}};function $l(e,t){switch(e){case`SELECT`:return Jl;case`TEXTAREA`:return Wl;default:switch(t){case`checkbox`:return Gl;case`radio`:return ql;default:return Wl}}}function eu(e,t,n,r,i){let a=$l(e.tagName,n.props&&n.props.type)[i];a&&a(e,t,n,r)}function tu(){Wl.getSSRProps=({value:e})=>({value:e}),ql.getSSRProps=({value:e},t)=>{if(t.props&&Ee(t.props.value,e))return{checked:!0}},Gl.getSSRProps=({value:e},t)=>{if(p(e)){if(t.props&&De(e,t.props.value)>-1)return{checked:!0}}else if(h(e)){if(t.props&&e.has(t.props.value))return{checked:!0}}else if(e)return{checked:!0}},Ql.getSSRProps=(e,t)=>{if(typeof t.type!=`string`)return;let n=$l(t.type.toUpperCase(),t.props&&t.props.type);if(n.getSSRProps)return n.getSSRProps(e,t)}}var nu=[`ctrl`,`shift`,`alt`,`meta`],ru={stop:e=>e.stopPropagation(),prevent:e=>e.preventDefault(),self:e=>e.target!==e.currentTarget,ctrl:e=>!e.ctrlKey,shift:e=>!e.shiftKey,alt:e=>!e.altKey,meta:e=>!e.metaKey,left:e=>`button`in e&&e.button!==0,middle:e=>`button`in e&&e.button!==1,right:e=>`button`in e&&e.button!==2,exact:(e,t)=>nu.some(n=>e[`${n}Key`]&&!t.includes(n))},iu=(e,t)=>{if(!e)return e;let n=e._withMods||={},r=t.join(`.`);return n[r]||(n[r]=((n,...r)=>{for(let e=0;e<t.length;e++){let r=ru[t[e]];if(r&&r(n,t))return}return e(n,...r)}))},au={esc:`escape`,space:` `,up:`arrow-up`,left:`arrow-left`,right:`arrow-right`,down:`arrow-down`,delete:`backspace`},ou=(e,t)=>{let n=e._withKeys||={},r=t.join(`.`);return n[r]||(n[r]=(n=>{if(!(`key`in n))return;let r=oe(n.key);if(t.some(e=>e===r||au[e]===r))return e(n)}))},su=l({patchProp:_l},_c),cu,lu=!1;function uu(){return cu||=Lo(su)}function du(){return cu=lu?cu:Ro(su),lu=!0,cu}var fu=((...e)=>{uu().render(...e)}),pu=((...e)=>{du().hydrate(...e)}),mu=((...e)=>{let t=uu().createApp(...e),{mount:n}=t;return t.mount=e=>{let r=_u(e);if(!r)return;let i=t._component;!v(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent=``);let a=n(r,!1,gu(r));return r instanceof Element&&(r.removeAttribute(`v-cloak`),r.setAttribute(`data-v-app`,``)),a},t}),hu=((...e)=>{let t=du().createApp(...e),{mount:n}=t;return t.mount=e=>{let t=_u(e);if(t)return n(t,!0,gu(t))},t});function gu(e){if(e instanceof SVGElement)return`svg`;if(typeof MathMLElement==`function`&&e instanceof MathMLElement)return`mathml`}function _u(e){return y(e)?document.querySelector(e):e}var vu=!1,yu=()=>{vu||(vu=!0,tu(),Uc())},bu=t({BaseTransition:()=>Qr,BaseTransitionPropsValidators:()=>Jr,Comment:()=>cs,DeprecationTypes:()=>null,EffectScope:()=>Ne,ErrorCodes:()=>zn,ErrorTypeStrings:()=>oc,Fragment:()=>L,KeepAlive:()=>Bi,ReactiveEffect:()=>ze,Static:()=>ls,Suspense:()=>Xo,Teleport:()=>Vr,Text:()=>ss,TrackOpTypes:()=>En,Transition:()=>Cc,TransitionGroup:()=>Ml,TriggerOpTypes:()=>Dn,VueElement:()=>wl,assertNumber:()=>Rn,callWithAsyncErrorHandling:()=>Hn,callWithErrorHandling:()=>Vn,camelize:()=>E,capitalize:()=>se,cloneVNode:()=>Cs,compatUtils:()=>null,compile:()=>xu,computed:()=>W,createApp:()=>mu,createBlock:()=>B,createCommentVNode:()=>Ts,createElementBlock:()=>z,createElementVNode:()=>V,createHydrationRenderer:()=>Ro,createPropsRestProxy:()=>Ia,createRenderer:()=>Lo,createSSRApp:()=>hu,createSlots:()=>ha,createStaticVNode:()=>ws,createTextVNode:()=>U,createVNode:()=>H,customRef:()=>vn,defineAsyncComponent:()=>Li,defineComponent:()=>F,defineCustomElement:()=>xl,defineEmits:()=>wa,defineExpose:()=>Ta,defineModel:()=>Oa,defineOptions:()=>Ea,defineProps:()=>Ca,defineSSRCustomElement:()=>Sl,defineSlots:()=>Da,devtools:()=>sc,effect:()=>Qe,effectScope:()=>Pe,getCurrentInstance:()=>Fs,getCurrentScope:()=>Fe,getCurrentWatcher:()=>jn,getTransitionRawChildren:()=>ii,guardReactiveProps:()=>Ss,h:()=>G,handleError:()=>Un,hasInjectionContext:()=>br,hydrate:()=>pu,hydrateOnIdle:()=>Ai,hydrateOnInteraction:()=>Pi,hydrateOnMediaQuery:()=>Ni,hydrateOnVisible:()=>Mi,initCustomFormatter:()=>tc,initDirectivesForSSR:()=>yu,inject:()=>yr,isMemoSame:()=>rc,isProxy:()=>on,isReactive:()=>nn,isReadonly:()=>rn,isRef:()=>j,isRuntimeOnly:()=>Js,isShallow:()=>an,isVNode:()=>gs,markRaw:()=>sn,mergeDefaults:()=>Pa,mergeModels:()=>Fa,mergeProps:()=>ks,nextTick:()=>Qn,nodeOps:()=>_c,normalizeClass:()=>O,normalizeProps:()=>xe,normalizeStyle:()=>ge,onActivated:()=>Hi,onBeforeMount:()=>Xi,onBeforeUnmount:()=>ea,onBeforeUpdate:()=>Qi,onDeactivated:()=>Ui,onErrorCaptured:()=>aa,onMounted:()=>Zi,onRenderTracked:()=>ia,onRenderTriggered:()=>ra,onScopeDispose:()=>Ie,onServerPrefetch:()=>na,onUnmounted:()=>ta,onUpdated:()=>$i,onWatcherCleanup:()=>Mn,openBlock:()=>R,patchProp:()=>_l,popScopeId:()=>mr,provide:()=>vr,proxyRefs:()=>gn,pushScopeId:()=>pr,queuePostFlushCb:()=>nr,reactive:()=>Zt,readonly:()=>$t,ref:()=>M,registerRuntimeCompiler:()=>qs,render:()=>fu,renderList:()=>ma,renderSlot:()=>I,resolveComponent:()=>ca,resolveDirective:()=>da,resolveDynamicComponent:()=>ua,resolveFilter:()=>null,resolveTransitionHooks:()=>ei,setBlockTracking:()=>ms,setDevtoolsHook:()=>cc,setTransitionHooks:()=>ri,shallowReactive:()=>Qt,shallowReadonly:()=>en,shallowRef:()=>un,ssrContextKey:()=>xr,ssrUtils:()=>lc,stop:()=>$e,toDisplayString:()=>k,toHandlerKey:()=>ce,toHandlers:()=>_a,toRaw:()=>A,toRef:()=>Sn,toRefs:()=>yn,toValue:()=>mn,transformVNodeArgs:()=>vs,triggerRef:()=>pn,unref:()=>N,useAttrs:()=>ja,useCssModule:()=>Dl,useCssVars:()=>Gc,useHost:()=>Tl,useId:()=>ai,useModel:()=>ro,useSSRContext:()=>Sr,useShadowRoot:()=>El,useSlots:()=>Aa,useTemplateRef:()=>si,useTransitionState:()=>Kr,vModelCheckbox:()=>Gl,vModelDynamic:()=>Ql,vModelRadio:()=>ql,vModelSelect:()=>Jl,vModelText:()=>Wl,vShow:()=>Vc,version:()=>ic,warn:()=>ac,watch:()=>Er,watchEffect:()=>Cr,watchPostEffect:()=>wr,watchSyncEffect:()=>Tr,withAsyncContext:()=>La,withCtx:()=>P,withDefaults:()=>ka,withDirectives:()=>gr,withKeys:()=>ou,withMemo:()=>nc,withModifiers:()=>iu,withScopeId:()=>hr}),xu=()=>{};function Su(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function Cu(e){if(Array.isArray(e))return e}function wu(e){if(Array.isArray(e))return Su(e)}function Tu(e,t){if(!(e instanceof t))throw TypeError(`Cannot call a class as a function`)}function Eu(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,`value`in r&&(r.writable=!0),Object.defineProperty(e,Lu(r.key),r)}}function Du(e,t,n){return t&&Eu(e.prototype,t),n&&Eu(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function Ou(e,t){var n=typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(!n){if(Array.isArray(e)||(n=zu(e))||t&&e&&typeof e.length==`number`){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw TypeError(`Invalid attempt to iterate non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||n.return==null||n.return()}finally{if(s)throw a}}}}function K(e,t,n){return(t=Lu(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function ku(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function Au(e,t){var n=e==null?null:typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(n!=null){var r,i,a,o,s=[],c=!0,l=!1;try{if(a=(n=n.call(e)).next,t===0){if(Object(n)!==n)return;c=!1}else for(;!(c=(r=a.call(n)).done)&&(s.push(r.value),s.length!==t);c=!0);}catch(e){l=!0,i=e}finally{try{if(!c&&n.return!=null&&(o=n.return(),Object(o)!==o))return}finally{if(l)throw i}}return s}}function ju(){throw TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Mu(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Nu(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function q(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Nu(Object(n),!0).forEach(function(t){K(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Nu(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function Pu(e,t){return Cu(e)||Au(e,t)||zu(e,t)||ju()}function Fu(e){return wu(e)||ku(e)||zu(e)||Mu()}function Iu(e,t){if(typeof e!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(typeof r!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function Lu(e){var t=Iu(e,`string`);return typeof t==`symbol`?t:t+``}function Ru(e){"@babel/helpers - typeof";return Ru=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},Ru(e)}function zu(e,t){if(e){if(typeof e==`string`)return Su(e,t);var n={}.toString.call(e).slice(8,-1);return n===`Object`&&e.constructor&&(n=e.constructor.name),n===`Map`||n===`Set`?Array.from(e):n===`Arguments`||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?Su(e,t):void 0}}var Bu=function(){},Vu={},Hu={},Uu=null,Wu={mark:Bu,measure:Bu};try{typeof window<`u`&&(Vu=window),typeof document<`u`&&(Hu=document),typeof MutationObserver<`u`&&(Uu=MutationObserver),typeof performance<`u`&&(Wu=performance)}catch{}var Gu=(Vu.navigator||{}).userAgent,Ku=Gu===void 0?``:Gu,qu=Vu,Ju=Hu,Yu=Uu,Xu=Wu;qu.document;var Zu=!!Ju.documentElement&&!!Ju.head&&typeof Ju.addEventListener==`function`&&typeof Ju.createElement==`function`,Qu=~Ku.indexOf(`MSIE`)||~Ku.indexOf(`Trident/`),$u,ed=/fa(k|kd|s|r|l|t|d|dr|dl|dt|b|slr|slpr|wsb|tl|ns|nds|es|gt|jr|jfr|jdr|usb|ufsb|udsb|cr|ss|sr|sl|st|sds|sdr|sdl|sdt|sldr|slpdr|pr|ms|vs)?[\-\ ]/,td=/Font ?Awesome ?([567 ]*)(Solid|Regular|Light|Thin|Duotone|Brands|Free|Pro|Sharp Duotone|Sharp|Kit|Notdog Duo|Notdog|Chisel|Etch|Graphite|Thumbprint|Jelly Fill|Jelly Duo|Jelly|Utility|Utility Fill|Utility Duo|Slab Press|Slab|Slab Duo|Slab Press Duo|Pixel|Mosaic|Vellum|Whiteboard)?.*/i,nd={classic:{fa:`solid`,fas:`solid`,"fa-solid":`solid`,far:`regular`,"fa-regular":`regular`,fal:`light`,"fa-light":`light`,fat:`thin`,"fa-thin":`thin`,fab:`brands`,"fa-brands":`brands`},duotone:{fa:`solid`,fad:`solid`,"fa-solid":`solid`,"fa-duotone":`solid`,fadr:`regular`,"fa-regular":`regular`,fadl:`light`,"fa-light":`light`,fadt:`thin`,"fa-thin":`thin`},sharp:{fa:`solid`,fass:`solid`,"fa-solid":`solid`,fasr:`regular`,"fa-regular":`regular`,fasl:`light`,"fa-light":`light`,fast:`thin`,"fa-thin":`thin`},"sharp-duotone":{fa:`solid`,fasds:`solid`,"fa-solid":`solid`,fasdr:`regular`,"fa-regular":`regular`,fasdl:`light`,"fa-light":`light`,fasdt:`thin`,"fa-thin":`thin`},slab:{"fa-regular":`regular`,faslr:`regular`},"slab-press":{"fa-regular":`regular`,faslpr:`regular`},"slab-duo":{"fa-regular":`regular`,fasldr:`regular`},"slab-press-duo":{"fa-regular":`regular`,faslpdr:`regular`},thumbprint:{"fa-light":`light`,fatl:`light`},vellum:{"fa-solid":`solid`,favs:`solid`},pixel:{"fa-regular":`regular`,fapr:`regular`},mosaic:{"fa-solid":`solid`,fams:`solid`},whiteboard:{"fa-semibold":`semibold`,fawsb:`semibold`},notdog:{"fa-solid":`solid`,fans:`solid`},"notdog-duo":{"fa-solid":`solid`,fands:`solid`},etch:{"fa-solid":`solid`,faes:`solid`},graphite:{"fa-thin":`thin`,fagt:`thin`},jelly:{"fa-regular":`regular`,fajr:`regular`},"jelly-fill":{"fa-regular":`regular`,fajfr:`regular`},"jelly-duo":{"fa-regular":`regular`,fajdr:`regular`},chisel:{"fa-regular":`regular`,facr:`regular`},utility:{"fa-semibold":`semibold`,fausb:`semibold`},"utility-duo":{"fa-semibold":`semibold`,faudsb:`semibold`},"utility-fill":{"fa-semibold":`semibold`,faufsb:`semibold`}},rd={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},id=[`fa-classic`,`fa-duotone`,`fa-sharp`,`fa-sharp-duotone`,`fa-thumbprint`,`fa-whiteboard`,`fa-notdog`,`fa-notdog-duo`,`fa-chisel`,`fa-etch`,`fa-graphite`,`fa-jelly`,`fa-jelly-fill`,`fa-jelly-duo`,`fa-slab`,`fa-slab-press`,`fa-slab-press-duo`,`fa-slab-duo`,`fa-mosaic`,`fa-pixel`,`fa-vellum`,`fa-utility`,`fa-utility-duo`,`fa-utility-fill`],ad=`classic`,od=`duotone`,sd=`sharp`,cd=`sharp-duotone`,ld=`chisel`,ud=`etch`,dd=`graphite`,fd=`jelly`,pd=`jelly-duo`,md=`jelly-fill`,hd=`mosaic`,gd=`notdog`,_d=`notdog-duo`,vd=`pixel`,yd=`slab`,bd=`slab-duo`,xd=`slab-press`,Sd=`slab-press-duo`,Cd=`thumbprint`,wd=`utility`,Td=`utility-duo`,Ed=`utility-fill`,Dd=`vellum`,Od=`whiteboard`,kd=`Classic`,Ad=`Duotone`,jd=`Sharp`,Md=`Sharp Duotone`,Nd=`Chisel`,Pd=`Etch`,Fd=`Graphite`,Id=`Jelly`,Ld=`Jelly Duo`,Rd=`Jelly Fill`,zd=`Mosaic`,Bd=`Notdog`,Vd=`Notdog Duo`,Hd=`Pixel`,Ud=`Slab`,Wd=`Slab Duo`,Gd=`Slab Press`,Kd=`Slab Press Duo`,qd=`Thumbprint`,Jd=`Utility`,Yd=`Utility Duo`,Xd=`Utility Fill`,Zd=`Vellum`,Qd=`Whiteboard`,$d=[ad,od,sd,cd,ld,ud,dd,fd,pd,md,hd,gd,_d,vd,yd,bd,xd,Sd,Cd,wd,Td,Ed,Dd,Od];$u={},K(K(K(K(K(K(K(K(K(K($u,ad,kd),od,Ad),sd,jd),cd,Md),ld,Nd),ud,Pd),dd,Fd),fd,Id),pd,Ld),md,Rd),K(K(K(K(K(K(K(K(K(K($u,hd,zd),gd,Bd),_d,Vd),vd,Hd),yd,Ud),bd,Wd),xd,Gd),Sd,Kd),Cd,qd),wd,Jd),K(K(K(K($u,Td,Yd),Ed,Xd),Dd,Zd),Od,Qd);var ef={classic:{900:`fas`,400:`far`,normal:`far`,300:`fal`,100:`fat`},duotone:{900:`fad`,400:`fadr`,300:`fadl`,100:`fadt`},sharp:{900:`fass`,400:`fasr`,300:`fasl`,100:`fast`},"sharp-duotone":{900:`fasds`,400:`fasdr`,300:`fasdl`,100:`fasdt`},slab:{400:`faslr`},"slab-press":{400:`faslpr`},"slab-duo":{400:`fasldr`},"slab-press-duo":{400:`faslpdr`},vellum:{900:`favs`},mosaic:{900:`fams`},pixel:{400:`fapr`},whiteboard:{600:`fawsb`},thumbprint:{300:`fatl`},notdog:{900:`fans`},"notdog-duo":{900:`fands`},etch:{900:`faes`},graphite:{100:`fagt`},chisel:{400:`facr`},jelly:{400:`fajr`},"jelly-fill":{400:`fajfr`},"jelly-duo":{400:`fajdr`},utility:{600:`fausb`},"utility-duo":{600:`faudsb`},"utility-fill":{600:`faufsb`}},tf={"Font Awesome 7 Free":{900:`fas`,400:`far`},"Font Awesome 7 Pro":{900:`fas`,400:`far`,normal:`far`,300:`fal`,100:`fat`},"Font Awesome 7 Brands":{400:`fab`,normal:`fab`},"Font Awesome 7 Duotone":{900:`fad`,400:`fadr`,normal:`fadr`,300:`fadl`,100:`fadt`},"Font Awesome 7 Sharp":{900:`fass`,400:`fasr`,normal:`fasr`,300:`fasl`,100:`fast`},"Font Awesome 7 Sharp Duotone":{900:`fasds`,400:`fasdr`,normal:`fasdr`,300:`fasdl`,100:`fasdt`},"Font Awesome 7 Jelly":{400:`fajr`,normal:`fajr`},"Font Awesome 7 Jelly Fill":{400:`fajfr`,normal:`fajfr`},"Font Awesome 7 Jelly Duo":{400:`fajdr`,normal:`fajdr`},"Font Awesome 7 Slab":{400:`faslr`,normal:`faslr`},"Font Awesome 7 Slab Press":{400:`faslpr`,normal:`faslpr`},"Font Awesome 7 Slab Duo":{400:`fasldr`,normal:`fasldr`},"Font Awesome 7 Slab Press Duo":{400:`faslpdr`,normal:`faslpdr`},"Font Awesome 7 Pixel":{400:`fapr`,normal:`fapr`},"Font Awesome 7 Mosaic":{900:`fams`,normal:`fams`},"Font Awesome 7 Vellum":{900:`favs`,normal:`favs`},"Font Awesome 7 Thumbprint":{300:`fatl`,normal:`fatl`},"Font Awesome 7 Notdog":{900:`fans`,normal:`fans`},"Font Awesome 7 Notdog Duo":{900:`fands`,normal:`fands`},"Font Awesome 7 Etch":{900:`faes`,normal:`faes`},"Font Awesome 7 Graphite":{100:`fagt`,normal:`fagt`},"Font Awesome 7 Chisel":{400:`facr`,normal:`facr`},"Font Awesome 7 Whiteboard":{600:`fawsb`,normal:`fawsb`},"Font Awesome 7 Utility":{600:`fausb`,normal:`fausb`},"Font Awesome 7 Utility Duo":{600:`faudsb`,normal:`faudsb`},"Font Awesome 7 Utility Fill":{600:`faufsb`,normal:`faufsb`}},nf=new Map([[`classic`,{defaultShortPrefixId:`fas`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`,`brands`],futureStyleIds:[],defaultFontWeight:900}],[`duotone`,{defaultShortPrefixId:`fad`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`sharp`,{defaultShortPrefixId:`fass`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`sharp-duotone`,{defaultShortPrefixId:`fasds`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`chisel`,{defaultShortPrefixId:`facr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`etch`,{defaultShortPrefixId:`faes`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`graphite`,{defaultShortPrefixId:`fagt`,defaultStyleId:`thin`,styleIds:[`thin`],futureStyleIds:[],defaultFontWeight:100}],[`jelly`,{defaultShortPrefixId:`fajr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`jelly-duo`,{defaultShortPrefixId:`fajdr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`jelly-fill`,{defaultShortPrefixId:`fajfr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`mosaic`,{defaultShortPrefixId:`fams`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`notdog`,{defaultShortPrefixId:`fans`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`notdog-duo`,{defaultShortPrefixId:`fands`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`pixel`,{defaultShortPrefixId:`fapr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab`,{defaultShortPrefixId:`faslr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-duo`,{defaultShortPrefixId:`fasldr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-press`,{defaultShortPrefixId:`faslpr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-press-duo`,{defaultShortPrefixId:`faslpdr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`thumbprint`,{defaultShortPrefixId:`fatl`,defaultStyleId:`light`,styleIds:[`light`],futureStyleIds:[],defaultFontWeight:300}],[`utility`,{defaultShortPrefixId:`fausb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`utility-duo`,{defaultShortPrefixId:`faudsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`utility-fill`,{defaultShortPrefixId:`faufsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`vellum`,{defaultShortPrefixId:`favs`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`whiteboard`,{defaultShortPrefixId:`fawsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}]]),rf={chisel:{regular:`facr`},classic:{brands:`fab`,light:`fal`,regular:`far`,solid:`fas`,thin:`fat`},duotone:{light:`fadl`,regular:`fadr`,solid:`fad`,thin:`fadt`},etch:{solid:`faes`},graphite:{thin:`fagt`},jelly:{regular:`fajr`},"jelly-duo":{regular:`fajdr`},"jelly-fill":{regular:`fajfr`},mosaic:{solid:`fams`},notdog:{solid:`fans`},"notdog-duo":{solid:`fands`},pixel:{regular:`fapr`},sharp:{light:`fasl`,regular:`fasr`,solid:`fass`,thin:`fast`},"sharp-duotone":{light:`fasdl`,regular:`fasdr`,solid:`fasds`,thin:`fasdt`},slab:{regular:`faslr`},"slab-duo":{regular:`fasldr`},"slab-press":{regular:`faslpr`},"slab-press-duo":{regular:`faslpdr`},thumbprint:{light:`fatl`},utility:{semibold:`fausb`},"utility-duo":{semibold:`faudsb`},"utility-fill":{semibold:`faufsb`},vellum:{solid:`favs`},whiteboard:{semibold:`fawsb`}},af=[`fak`,`fa-kit`,`fakd`,`fa-kit-duotone`],of={kit:{fak:`kit`,"fa-kit":`kit`},"kit-duotone":{fakd:`kit-duotone`,"fa-kit-duotone":`kit-duotone`}},sf=[`kit`];K(K({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var cf={kit:{"fa-kit":`fak`},"kit-duotone":{"fa-kit-duotone":`fakd`}},lf={"Font Awesome Kit":{400:`fak`,normal:`fak`},"Font Awesome Kit Duotone":{400:`fakd`,normal:`fakd`}},uf={kit:{fak:`fa-kit`},"kit-duotone":{fakd:`fa-kit-duotone`}},df={kit:{kit:`fak`},"kit-duotone":{"kit-duotone":`fakd`}},ff,pf={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},mf=[`fa-classic`,`fa-duotone`,`fa-sharp`,`fa-sharp-duotone`,`fa-thumbprint`,`fa-whiteboard`,`fa-notdog`,`fa-notdog-duo`,`fa-chisel`,`fa-etch`,`fa-graphite`,`fa-jelly`,`fa-jelly-fill`,`fa-jelly-duo`,`fa-slab`,`fa-slab-press`,`fa-slab-press-duo`,`fa-slab-duo`,`fa-mosaic`,`fa-pixel`,`fa-vellum`,`fa-utility`,`fa-utility-duo`,`fa-utility-fill`];ff={},K(K(K(K(K(K(K(K(K(K(ff,`classic`,`Classic`),`duotone`,`Duotone`),`sharp`,`Sharp`),`sharp-duotone`,`Sharp Duotone`),`chisel`,`Chisel`),`etch`,`Etch`),`graphite`,`Graphite`),`jelly`,`Jelly`),`jelly-duo`,`Jelly Duo`),`jelly-fill`,`Jelly Fill`),K(K(K(K(K(K(K(K(K(K(ff,`mosaic`,`Mosaic`),`notdog`,`Notdog`),`notdog-duo`,`Notdog Duo`),`pixel`,`Pixel`),`slab`,`Slab`),`slab-duo`,`Slab Duo`),`slab-press`,`Slab Press`),`slab-press-duo`,`Slab Press Duo`),`thumbprint`,`Thumbprint`),`utility`,`Utility`),K(K(K(K(ff,`utility-duo`,`Utility Duo`),`utility-fill`,`Utility Fill`),`vellum`,`Vellum`),`whiteboard`,`Whiteboard`),K(K({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var hf={classic:{"fa-brands":`fab`,"fa-duotone":`fad`,"fa-light":`fal`,"fa-regular":`far`,"fa-solid":`fas`,"fa-thin":`fat`},duotone:{"fa-regular":`fadr`,"fa-light":`fadl`,"fa-thin":`fadt`},sharp:{"fa-solid":`fass`,"fa-regular":`fasr`,"fa-light":`fasl`,"fa-thin":`fast`},"sharp-duotone":{"fa-solid":`fasds`,"fa-regular":`fasdr`,"fa-light":`fasdl`,"fa-thin":`fasdt`},slab:{"fa-regular":`faslr`},"slab-press":{"fa-regular":`faslpr`},"slab-duo":{"fa-regular":`fasldr`},"slab-press-duo":{"fa-regular":`faslpdr`},pixel:{"fa-regular":`fapr`},mosaic:{"fa-solid":`fams`},vellum:{"fa-solid":`favs`},whiteboard:{"fa-semibold":`fawsb`},thumbprint:{"fa-light":`fatl`},notdog:{"fa-solid":`fans`},"notdog-duo":{"fa-solid":`fands`},etch:{"fa-solid":`faes`},graphite:{"fa-thin":`fagt`},jelly:{"fa-regular":`fajr`},"jelly-fill":{"fa-regular":`fajfr`},"jelly-duo":{"fa-regular":`fajdr`},chisel:{"fa-regular":`facr`},utility:{"fa-semibold":`fausb`},"utility-duo":{"fa-semibold":`faudsb`},"utility-fill":{"fa-semibold":`faufsb`}},gf={classic:[`fas`,`far`,`fal`,`fat`,`fad`],duotone:[`fadr`,`fadl`,`fadt`],sharp:[`fass`,`fasr`,`fasl`,`fast`],"sharp-duotone":[`fasds`,`fasdr`,`fasdl`,`fasdt`],slab:[`faslr`],"slab-press":[`faslpr`],"slab-duo":[`fasldr`],"slab-press-duo":[`faslpdr`],pixel:[`fapr`],mosaic:[`fams`],vellum:[`favs`],whiteboard:[`fawsb`],thumbprint:[`fatl`],notdog:[`fans`],"notdog-duo":[`fands`],etch:[`faes`],graphite:[`fagt`],jelly:[`fajr`],"jelly-fill":[`fajfr`],"jelly-duo":[`fajdr`],chisel:[`facr`],utility:[`fausb`],"utility-duo":[`faudsb`],"utility-fill":[`faufsb`]},_f={classic:{fab:`fa-brands`,fad:`fa-duotone`,fal:`fa-light`,far:`fa-regular`,fas:`fa-solid`,fat:`fa-thin`},duotone:{fadr:`fa-regular`,fadl:`fa-light`,fadt:`fa-thin`},sharp:{fass:`fa-solid`,fasr:`fa-regular`,fasl:`fa-light`,fast:`fa-thin`},"sharp-duotone":{fasds:`fa-solid`,fasdr:`fa-regular`,fasdl:`fa-light`,fasdt:`fa-thin`},slab:{faslr:`fa-regular`},"slab-press":{faslpr:`fa-regular`},"slab-duo":{fasldr:`fa-regular`},"slab-press-duo":{faslpdr:`fa-regular`},pixel:{fapr:`fa-regular`},mosaic:{fams:`fa-solid`},vellum:{favs:`fa-solid`},whiteboard:{fawsb:`fa-semibold`},thumbprint:{fatl:`fa-light`},notdog:{fans:`fa-solid`},"notdog-duo":{fands:`fa-solid`},etch:{faes:`fa-solid`},graphite:{fagt:`fa-thin`},jelly:{fajr:`fa-regular`},"jelly-fill":{fajfr:`fa-regular`},"jelly-duo":{fajdr:`fa-regular`},chisel:{facr:`fa-regular`},utility:{fausb:`fa-semibold`},"utility-duo":{faudsb:`fa-semibold`},"utility-fill":{faufsb:`fa-semibold`}},vf=`fa.fas.far.fal.fat.fad.fadr.fadl.fadt.fab.fass.fasr.fasl.fast.fasds.fasdr.fasdl.fasdt.faslr.faslpr.fasldr.faslpdr.fapr.fams.favs.fawsb.fatl.fans.fands.faes.fagt.fajr.fajfr.fajdr.facr.fausb.faudsb.faufsb`.split(`.`).concat(mf,[`fa-solid`,`fa-regular`,`fa-light`,`fa-thin`,`fa-duotone`,`fa-brands`,`fa-semibold`]),yf=[`solid`,`regular`,`light`,`thin`,`duotone`,`brands`,`semibold`],bf=[1,2,3,4,5,6,7,8,9,10],xf=bf.concat([11,12,13,14,15,16,17,18,19,20]),Sf=[].concat(Fu(Object.keys(gf)),yf,[`aw`,`fw`,`pull-left`,`pull-right`],[`2xs`,`xs`,`sm`,`lg`,`xl`,`2xl`,`beat`,`beat-fade`,`border`,`bounce`,`buzz`,`canvas-square`,`canvas-roomy`,`fade`,`flip-360`,`flip-both`,`flip-horizontal`,`flip-vertical`,`flip`,`float`,`inverse`,`jello`,`layers`,`layers-bottom-left`,`layers-bottom-right`,`layers-counter`,`layers-text`,`layers-top-left`,`layers-top-right`,`li`,`pull-end`,`pull-start`,`pulse`,`rotate-180`,`rotate-270`,`rotate-90`,`rotate-by`,`shake`,`spin-pulse`,`spin-reverse`,`spin`,`spin-snap`,`spin-snap-4`,`spin-snap-8`,`stack-1x`,`stack-2x`,`stack`,`swing`,`ul`,`wag`,`width-auto`,`width-fixed`,pf.GROUP,pf.SWAP_OPACITY,pf.PRIMARY,pf.SECONDARY],bf.map(function(e){return`${e}x`}),xf.map(function(e){return`w-${e}`})),Cf={"Font Awesome 5 Free":{900:`fas`,400:`far`},"Font Awesome 5 Pro":{900:`fas`,400:`far`,normal:`far`,300:`fal`},"Font Awesome 5 Brands":{400:`fab`,normal:`fab`},"Font Awesome 5 Duotone":{900:`fad`}},wf=`___FONT_AWESOME___`,Tf=16,Ef=`fa`,Df=`svg-inline--fa`,Of=`data-fa-i2svg`,kf=`data-fa-pseudo-element`,Af=`data-fa-pseudo-element-pending`,jf=`data-prefix`,Mf=`data-icon`,Nf=`fontawesome-i2svg`,Pf=`async`,Ff=[`HTML`,`HEAD`,`STYLE`,`SCRIPT`],If=[`::before`,`::after`,`:before`,`:after`],Lf=function(){try{return!0}catch{return!1}}();function Rf(e){return new Proxy(e,{get:function(e,t){return t in e?e[t]:e[ad]}})}var zf=q({},nd);zf[ad]=q(q(q(q({},{"fa-duotone":`duotone`}),nd[ad]),of.kit),of[`kit-duotone`]);var Bf=Rf(zf),Vf=q({},rf);Vf[ad]=q(q(q(q({},{duotone:`fad`}),Vf[ad]),df.kit),df[`kit-duotone`]);var Hf=Rf(Vf),Uf=q({},_f);Uf[ad]=q(q({},Uf[ad]),uf.kit);var Wf=Rf(Uf),Gf=q({},hf);Gf[ad]=q(q({},Gf[ad]),cf.kit),Rf(Gf);var Kf=ed,qf=`fa-layers-text`,Jf=td;Rf(q({},ef));var Yf=[`class`,`data-prefix`,`data-icon`,`data-fa-transform`,`data-fa-mask`],Xf=rd,Zf=[].concat(Fu(sf),Fu(Sf)),Qf=qu.FontAwesomeConfig||{};function $f(e){var t=Ju.querySelector(`script[`+e+`]`);if(t)return t.getAttribute(e)}function ep(e){return e===``?!0:e===`false`?!1:e===`true`||e}Ju&&typeof Ju.querySelector==`function`&&[[`data-family-prefix`,`familyPrefix`],[`data-css-prefix`,`cssPrefix`],[`data-family-default`,`familyDefault`],[`data-style-default`,`styleDefault`],[`data-replacement-class`,`replacementClass`],[`data-auto-replace-svg`,`autoReplaceSvg`],[`data-auto-add-css`,`autoAddCss`],[`data-search-pseudo-elements`,`searchPseudoElements`],[`data-search-pseudo-elements-warnings`,`searchPseudoElementsWarnings`],[`data-search-pseudo-elements-full-scan`,`searchPseudoElementsFullScan`],[`data-observe-mutations`,`observeMutations`],[`data-mutate-approach`,`mutateApproach`],[`data-keep-original-source`,`keepOriginalSource`],[`data-measure-performance`,`measurePerformance`],[`data-show-missing-icons`,`showMissingIcons`]].forEach(function(e){var t=Pu(e,2),n=t[0],r=t[1],i=ep($f(n));i!=null&&(Qf[r]=i)});var tp={styleDefault:`solid`,familyDefault:ad,cssPrefix:Ef,replacementClass:Df,autoReplaceSvg:!0,autoAddCss:!0,searchPseudoElements:!1,searchPseudoElementsWarnings:!0,searchPseudoElementsFullScan:!1,observeMutations:!0,mutateApproach:`async`,keepOriginalSource:!0,measurePerformance:!1,showMissingIcons:!0};Qf.familyPrefix&&(Qf.cssPrefix=Qf.familyPrefix);var np=q(q({},tp),Qf);np.autoReplaceSvg||(np.observeMutations=!1);var J={};Object.keys(tp).forEach(function(e){Object.defineProperty(J,e,{enumerable:!0,set:function(t){np[e]=t,rp.forEach(function(e){return e(J)})},get:function(){return np[e]}})}),Object.defineProperty(J,"familyPrefix",{enumerable:!0,set:function(e){np.cssPrefix=e,rp.forEach(function(e){return e(J)})},get:function(){return np.cssPrefix}}),qu.FontAwesomeConfig=J;var rp=[];function ip(e){return rp.push(e),function(){rp.splice(rp.indexOf(e),1)}}var ap=Tf,op={size:16,x:0,y:0,rotate:0,flipX:!1,flipY:!1};function sp(e){if(!(!e||!Zu)){var t=Ju.createElement(`style`);t.setAttribute(`type`,`text/css`),t.innerHTML=e;for(var n=Ju.head.childNodes,r=null,i=n.length-1;i>-1;i--){var a=n[i],o=(a.tagName||``).toUpperCase();[`STYLE`,`LINK`].indexOf(o)>-1&&(r=a)}return Ju.head.insertBefore(t,r),e}}var cp=`0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`;function lp(){for(var e=12,t=``;e-->0;)t+=cp[Math.random()*62|0];return t}function up(e){for(var t=[],n=(e||[]).length>>>0;n--;)t[n]=e[n];return t}function dp(e){return e.classList?up(e.classList):(e.getAttribute(`class`)||``).split(` `).filter(function(e){return e})}function fp(e){return`${e}`.replace(/&/g,`&amp;`).replace(/"/g,`&quot;`).replace(/'/g,`&#39;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`)}function pp(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}="${fp(e[n])}" `},``).trim()}function mp(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}: ${e[n].trim()};`},``)}function hp(e){return e.size!==op.size||e.x!==op.x||e.y!==op.y||e.rotate!==op.rotate||e.flipX||e.flipY}function gp(e){var t=e.transform,n=e.containerWidth,r=e.iconWidth;return{outer:{transform:`translate(${n/2} 256)`},inner:{transform:`${`translate(${t.x*32}, ${t.y*32}) `} ${`scale(${t.size/16*(t.flipX?-1:1)}, ${t.size/16*(t.flipY?-1:1)}) `} ${`rotate(${t.rotate} 0 0)`}`},path:{transform:`translate(${r/2*-1} -256)`}}}function _p(e){var t=e.transform,n=e.width,r=n===void 0?Tf:n,i=e.height,a=i===void 0?Tf:i,o=e.startCentered,s=o!==void 0&&o,c=``;return c+=s&&Qu?`translate(${t.x/ap-r/2}em, ${t.y/ap-a/2}em) `:s?`translate(calc(-50% + ${t.x/ap}em), calc(-50% + ${t.y/ap}em)) `:`translate(${t.x/ap}em, ${t.y/ap}em) `,c+=`scale(${t.size/ap*(t.flipX?-1:1)}, ${t.size/ap*(t.flipY?-1:1)}) `,c+=`rotate(${t.rotate}deg) `,c}var vp=`:root, :host {
  --fa-font-solid: normal 900 1em/1 'Font Awesome 7 Free';
  --fa-font-regular: normal 400 1em/1 'Font Awesome 7 Free';
  --fa-font-light: normal 300 1em/1 'Font Awesome 7 Pro';
  --fa-font-thin: normal 100 1em/1 'Font Awesome 7 Pro';
  --fa-font-duotone: normal 900 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-regular: normal 400 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-light: normal 300 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-thin: normal 100 1em/1 'Font Awesome 7 Duotone';
  --fa-font-brands: normal 400 1em/1 'Font Awesome 7 Brands';
  --fa-font-sharp-solid: normal 900 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-regular: normal 400 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-light: normal 300 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-thin: normal 100 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-duotone-solid: normal 900 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-regular: normal 400 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-light: normal 300 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-thin: normal 100 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-slab-regular: normal 400 1em/1 'Font Awesome 7 Slab';
  --fa-font-slab-press-regular: normal 400 1em/1 'Font Awesome 7 Slab Press';
  --fa-font-slab-duo-regular: normal 400 1em/1 'Font Awesome 7 Slab Duo';
  --fa-font-slab-press-duo-regular: normal 400 1em/1 'Font Awesome 7 Slab Press Duo';
  --fa-font-pixel-regular: normal 400 1em/1 'Font Awesome 7 Pixel';
  --fa-font-mosaic-solid: normal 900 1em/1 'Font Awesome 7 Mosaic';
  --fa-font-vellum-solid: normal 900 1em/1 'Font Awesome 7 Vellum';
  --fa-font-whiteboard-semibold: normal 600 1em/1 'Font Awesome 7 Whiteboard';
  --fa-font-thumbprint-light: normal 300 1em/1 'Font Awesome 7 Thumbprint';
  --fa-font-notdog-solid: normal 900 1em/1 'Font Awesome 7 Notdog';
  --fa-font-notdog-duo-solid: normal 900 1em/1 'Font Awesome 7 Notdog Duo';
  --fa-font-etch-solid: normal 900 1em/1 'Font Awesome 7 Etch';
  --fa-font-graphite-thin: normal 100 1em/1 'Font Awesome 7 Graphite';
  --fa-font-jelly-regular: normal 400 1em/1 'Font Awesome 7 Jelly';
  --fa-font-jelly-fill-regular: normal 400 1em/1 'Font Awesome 7 Jelly Fill';
  --fa-font-jelly-duo-regular: normal 400 1em/1 'Font Awesome 7 Jelly Duo';
  --fa-font-chisel-regular: normal 400 1em/1 'Font Awesome 7 Chisel';
  --fa-font-utility-semibold: normal 600 1em/1 'Font Awesome 7 Utility';
  --fa-font-utility-duo-semibold: normal 600 1em/1 'Font Awesome 7 Utility Duo';
  --fa-font-utility-fill-semibold: normal 600 1em/1 'Font Awesome 7 Utility Fill';
}

.svg-inline--fa {
  box-sizing: content-box;
  display: var(--fa-display, inline-block);
  height: 1em;
  overflow: visible;
  vertical-align: -0.125em;
  width: var(--fa-width, 1.25em);
}
.svg-inline--fa.fa-2xs {
  vertical-align: 0.1em;
}
.svg-inline--fa.fa-xs {
  vertical-align: 0em;
}
.svg-inline--fa.fa-sm {
  vertical-align: -0.0714285714em;
}
.svg-inline--fa.fa-lg {
  vertical-align: -0.2em;
}
.svg-inline--fa.fa-xl {
  vertical-align: -0.25em;
}
.svg-inline--fa.fa-2xl {
  vertical-align: -0.3125em;
}
.svg-inline--fa.fa-pull-left,
.svg-inline--fa .fa-pull-start {
  float: inline-start;
  margin-inline-end: var(--fa-pull-margin, 0.3em);
}
.svg-inline--fa.fa-pull-right,
.svg-inline--fa .fa-pull-end {
  float: inline-end;
  margin-inline-start: var(--fa-pull-margin, 0.3em);
}
.svg-inline--fa.fa-li {
  width: var(--fa-li-width, 2em);
  inset-inline-start: calc(-1 * var(--fa-li-width, 2em));
  inset-block-start: 0.25em; /* syncing vertical alignment with Web Font rendering */
}

.fa-layers-counter, .fa-layers-text {
  display: inline-block;
  position: absolute;
  text-align: center;
}

.fa-layers {
  display: inline-block;
  height: 1em;
  position: relative;
  text-align: center;
  vertical-align: -0.125em;
  width: var(--fa-width, 1.25em);
}
.fa-layers .svg-inline--fa {
  inset: 0;
  margin: auto;
  position: absolute;
  transform-origin: center center;
}

.fa-layers-text {
  left: 50%;
  top: 50%;
  transform: translate(-50%, -50%);
  transform-origin: center center;
}

.fa-layers-counter {
  background-color: var(--fa-counter-background-color, #ff253a);
  border-radius: var(--fa-counter-border-radius, 1em);
  box-sizing: border-box;
  color: var(--fa-inverse, #fff);
  line-height: var(--fa-counter-line-height, 1);
  max-width: var(--fa-counter-max-width, 5em);
  min-width: var(--fa-counter-min-width, 1.5em);
  overflow: hidden;
  padding: var(--fa-counter-padding, 0.25em 0.5em);
  right: var(--fa-right, 0);
  text-overflow: ellipsis;
  top: var(--fa-top, 0);
  transform: scale(var(--fa-counter-scale, 0.25));
  transform-origin: top right;
}

.fa-layers-bottom-right {
  bottom: var(--fa-bottom, 0);
  right: var(--fa-right, 0);
  top: auto;
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: bottom right;
}

.fa-layers-bottom-left {
  bottom: var(--fa-bottom, 0);
  left: var(--fa-left, 0);
  right: auto;
  top: auto;
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: bottom left;
}

.fa-layers-top-right {
  top: var(--fa-top, 0);
  right: var(--fa-right, 0);
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: top right;
}

.fa-layers-top-left {
  left: var(--fa-left, 0);
  right: auto;
  top: var(--fa-top, 0);
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: top left;
}

.fa-1x {
  font-size: 1em;
}

.fa-2x {
  font-size: 2em;
}

.fa-3x {
  font-size: 3em;
}

.fa-4x {
  font-size: 4em;
}

.fa-5x {
  font-size: 5em;
}

.fa-6x {
  font-size: 6em;
}

.fa-7x {
  font-size: 7em;
}

.fa-8x {
  font-size: 8em;
}

.fa-9x {
  font-size: 9em;
}

.fa-10x {
  font-size: 10em;
}

.fa-2xs {
  font-size: calc(10 / 16 * 1em); /* converts a 10px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 10 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 10 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-xs {
  font-size: calc(12 / 16 * 1em); /* converts a 12px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 12 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 12 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-sm {
  font-size: calc(14 / 16 * 1em); /* converts a 14px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 14 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 14 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-lg {
  font-size: calc(20 / 16 * 1em); /* converts a 20px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 20 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 20 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-xl {
  font-size: calc(24 / 16 * 1em); /* converts a 24px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 24 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 24 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-2xl {
  font-size: calc(32 / 16 * 1em); /* converts a 32px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 32 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 32 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-width-auto {
  --fa-width: auto;
}

.fa-fw,
.fa-width-fixed {
  --fa-width: 1.25em;
}

.fa-canvas-square {
  padding-block: 0.125em;
  margin-block-end: -0.125em;
}

.fa-canvas-roomy {
  padding-block: 0.25em;
  padding-inline: 0.125em;
  margin-block-end: -0.25em;
  box-sizing: content-box;
}

.fa-ul {
  list-style-type: none;
  margin-inline-start: var(--fa-li-margin, 2.5em);
  padding-inline-start: 0;
}
.fa-ul > li {
  position: relative;
}

.fa-li {
  inset-inline-start: calc(-1 * var(--fa-li-width, 2em));
  position: absolute;
  text-align: center;
  width: var(--fa-li-width, 2em);
  line-height: inherit;
}

/* Heads Up: Bordered Icons will not be supported in the future!
  - This feature will be deprecated in the next major release of Font Awesome (v8)!
  - You may continue to use it in this version *v7), but it will not be supported in Font Awesome v8.
*/
/* Notes:
* --@{v.$css-prefix}-border-width = 1/16 by default (to render as ~1px based on a 16px default font-size)
* --@{v.$css-prefix}-border-padding =
  ** 3/16 for vertical padding (to give ~2px of vertical whitespace around an icon considering it's vertical alignment)
  ** 4/16 for horizontal padding (to give ~4px of horizontal whitespace around an icon)
*/
.fa-border {
  border-color: var(--fa-border-color, #eee);
  border-radius: var(--fa-border-radius, 0.1em);
  border-style: var(--fa-border-style, solid);
  border-width: var(--fa-border-width, 0.0625em);
  box-sizing: var(--fa-border-box-sizing, content-box);
  padding: var(--fa-border-padding, 0.1875em 0.25em);
}

.fa-pull-left,
.fa-pull-start {
  float: inline-start;
  margin-inline-end: var(--fa-pull-margin, 0.3em);
}

.fa-pull-right,
.fa-pull-end {
  float: inline-end;
  margin-inline-start: var(--fa-pull-margin, 0.3em);
}

.fa-beat {
  animation-name: fa-beat;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-bounce {
  animation-name: fa-bounce;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, cubic-bezier(0.28, 0.84, 0.42, 1));
}

.fa-fade {
  animation-name: fa-fade;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-beat-fade {
  animation-name: fa-beat-fade;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-flip {
  animation-name: fa-flip;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1.5s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-flip-360 {
  animation-name: fa-flip-360;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-shake {
  animation-name: fa-shake;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.75s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-spin {
  animation-name: fa-spin;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 2s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-reverse {
  --fa-animation-direction: reverse;
}

.fa-pulse,
.fa-spin-pulse {
  animation-name: fa-spin;
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, steps(8));
}

.fa-spin-snap {
  animation-name: fa-spin-snap;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 3s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-snap-4 {
  animation-name: fa-spin-snap-4;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 2.4s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-snap-8 {
  animation-name: fa-spin-snap-8;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 4s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-buzz {
  animation-name: fa-buzz;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.6s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-wag {
  animation-name: fa-wag;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.9s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
  transform-origin: bottom center;
}

.fa-float {
  animation-name: fa-float;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 3s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
  will-change: transform;
}

.fa-swing {
  animation-name: fa-swing;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1.2s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
  transform-origin: top center;
}

.fa-jello {
  animation-name: fa-jello;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.9s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
}

@media (prefers-reduced-motion: reduce) {
  .fa-beat,
  .fa-bounce,
  .fa-fade,
  .fa-beat-fade,
  .fa-flip,
  .fa-flip-360,
  .fa-pulse,
  .fa-shake,
  .fa-spin,
  .fa-spin-pulse,
  .fa-buzz,
  .fa-float,
  .fa-jello,
  .fa-spin-snap,
  .fa-spin-snap-4,
  .fa-spin-snap-8,
  .fa-swing,
  .fa-wag {
    animation: none !important;
    transition: none !important;
  }
}
@keyframes fa-beat {
  0% {
    transform: scale(1);
  }
  25% {
    transform: scale(calc(1.25 * var(--fa-beat-scale, 1.25)));
  }
  45% {
    transform: scale(calc(1.22 * var(--fa-beat-scale, 1.22)));
  }
  65% {
    transform: scale(calc(1.25 * var(--fa-beat-scale, 1.25)));
  }
  90% {
    transform: scale(1);
  }
}
@keyframes fa-bounce {
  0% {
    transform: scale(1, 1) translateY(0);
    animation-timing-function: var(--fa-animation-timing);
  }
  14% {
    transform: scale(var(--fa-bounce-start-scale-x, 1.06), var(--fa-bounce-start-scale-y, 0.94)) translateY(var(--fa-bounce-anticipation, 3px));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  32% {
    transform: scale(var(--fa-bounce-jump-scale-x, 0.94), var(--fa-bounce-jump-scale-y, 1.12)) translateY(calc(-1 * var(--fa-bounce-height, 0.5em)));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  52% {
    transform: scale(1, 1) translateY(calc(-1 * var(--fa-bounce-height, 0.5em) * 1.1));
    animation-timing-function: cubic-bezier(0.5, 0, 1, 0.5);
  }
  70% {
    transform: scale(var(--fa-bounce-land-scale-x, 1.06), var(--fa-bounce-land-scale-y, 0.92)) translateY(0);
    animation-timing-function: cubic-bezier(0.33, 0.33, 0.66, 1);
  }
  85% {
    transform: scale(0.98, 1.04) translateY(calc(-2px * var(--fa-bounce-rebound, 1)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: scale(1, 1) translateY(0);
  }
}
@keyframes fa-fade {
  0% {
    opacity: 1;
    transform: scale(1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  40% {
    opacity: var(--fa-fade-opacity, 0.4);
    transform: scale(0.98);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  100% {
    opacity: 1;
    transform: scale(1);
  }
}
@keyframes fa-beat-fade {
  0% {
    opacity: var(--fa-beat-fade-opacity, 0.4);
    transform: scale(1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  25% {
    opacity: calc(var(--fa-beat-fade-opacity, 0.4) + 0.4);
    transform: scale(var(--fa-beat-fade-scale, 1.28));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  45% {
    opacity: 1;
    transform: scale(var(--fa-beat-fade-scale, 1.25));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  65% {
    opacity: calc(var(--fa-beat-fade-opacity, 0.4) + 0.4);
    transform: scale(var(--fa-beat-fade-scale, 1.28));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  100% {
    opacity: var(--fa-beat-fade-opacity, 0.4);
    transform: scale(1);
  }
}
@keyframes fa-flip {
  0% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  8% {
    transform: perspective(2em) scale(var(--fa-flip-anticipation-scale, 0.95)) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  35% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.6));
    animation-timing-function: linear;
  }
  65% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.5));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  92% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * var(--fa-flip-overshoot, 1.04)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), var(--fa-flip-angle, -360deg));
  }
}
@keyframes fa-flip-360 {
  0% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  8% {
    transform: perspective(2em) scale(var(--fa-flip-anticipation-scale, 0.95)) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  50% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.6));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  80% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * var(--fa-flip-overshoot, 1.04)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), var(--fa-flip-angle, -360deg));
  }
}
@keyframes fa-shake {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  8% {
    transform: rotate(35deg) translateX(1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  20% {
    transform: rotate(-22deg) translateX(-1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  35% {
    transform: rotate(15deg) translateX(1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  50% {
    transform: rotate(-9deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  65% {
    transform: rotate(5deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  78% {
    transform: rotate(-3deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  90% {
    transform: rotate(1deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-spin {
  0% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  12% {
    transform: rotate(60deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  16.67% {
    transform: rotate(60deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  28.67% {
    transform: rotate(120deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  33.33% {
    transform: rotate(120deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  45.33% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  62% {
    transform: rotate(240deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  66.67% {
    transform: rotate(240deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  78.67% {
    transform: rotate(300deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  83.33% {
    transform: rotate(300deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  95.33% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap-4 {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  15% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  25% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  40% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  65% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  75% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  90% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap-8 {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  9% {
    transform: rotate(45deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  12.5% {
    transform: rotate(45deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  21.5% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  25% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  34% {
    transform: rotate(135deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  37.5% {
    transform: rotate(135deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  46.5% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  59% {
    transform: rotate(225deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  62.5% {
    transform: rotate(225deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  71.5% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  75% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  84% {
    transform: rotate(315deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  87.5% {
    transform: rotate(315deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  96.5% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-buzz {
  0% {
    transform: translateX(0) rotate(0deg);
    animation-timing-function: cubic-bezier(0.1, 0, 0.9, 1);
  }
  5% {
    transform: translateX(var(--fa-buzz-distance, 4px)) rotate(0.5deg);
  }
  10% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px))) rotate(-0.5deg);
  }
  15% {
    transform: translateX(var(--fa-buzz-distance, 4px)) rotate(0.3deg);
  }
  20% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px))) rotate(-0.3deg);
  }
  25% {
    transform: translateX(calc(var(--fa-buzz-distance, 4px) * 0.7)) rotate(0.2deg);
  }
  30% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px) * 0.7)) rotate(-0.2deg);
  }
  35% {
    transform: translateX(calc(var(--fa-buzz-distance, 4px) * 0.4)) rotate(0.1deg);
  }
  40% {
    transform: translateX(0) rotate(0deg);
  }
  100% {
    transform: translateX(0) rotate(0deg);
  }
}
@keyframes fa-wag {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  12% {
    transform: rotate(var(--fa-wag-angle, 12deg));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  24% {
    transform: rotate(2deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  36% {
    transform: rotate(calc(var(--fa-wag-angle, 12deg) * 0.85));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  48% {
    transform: rotate(1deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  58% {
    transform: rotate(calc(var(--fa-wag-angle, 12deg) * 0.6));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  68% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-float {
  0% {
    transform: translateY(0) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  15% {
    transform: translateY(calc(-0.4 * var(--fa-float-height, 6px))) translateX(var(--fa-float-drift, 1px)) rotate(var(--fa-float-tilt, 1deg)) scale(1, 1);
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  35% {
    transform: translateY(calc(-1 * var(--fa-float-height, 6px))) translateX(0) rotate(0deg) scale(var(--fa-float-stretch-x, 0.98), var(--fa-float-stretch-y, 1.03));
    animation-timing-function: cubic-bezier(0.5, 0, 0.5, 0);
  }
  50% {
    transform: translateY(calc(-0.92 * var(--fa-float-height, 6px))) translateX(calc(-0.5 * var(--fa-float-drift, 1px))) rotate(calc(-0.5 * var(--fa-float-tilt, 1deg))) scale(0.995, 1.01);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  70% {
    transform: translateY(calc(-0.3 * var(--fa-float-height, 6px))) translateX(calc(-1 * var(--fa-float-drift, 1px))) rotate(calc(-1 * var(--fa-float-tilt, 1deg))) scale(1, 1);
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  90% {
    transform: translateY(calc(0.05 * var(--fa-float-height, 6px))) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: translateY(0) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
  }
}
@keyframes fa-swing {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  8% {
    transform: rotate(var(--fa-swing-angle, 22deg));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  18% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.85));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  28% {
    transform: rotate(calc(var(--fa-swing-angle, 22deg) * 0.65));
    animation-timing-function: cubic-bezier(0.35, 0, 0.65, 1);
  }
  38% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.45));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  48% {
    transform: rotate(calc(var(--fa-swing-angle, 22deg) * 0.25));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  56% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.1));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  64% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-jello {
  0% {
    transform: scale(1, 1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  12% {
    transform: scale(var(--fa-jello-scale-x, 1.15), calc(2 - var(--fa-jello-scale-x, 1.15)));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  24% {
    transform: scale(calc(2 - var(--fa-jello-scale-y, 1.12)), var(--fa-jello-scale-y, 1.12));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  36% {
    transform: scale(calc(1 + (var(--fa-jello-scale-x, 1.15) - 1) * 0.5), calc(2 - (1 + (var(--fa-jello-scale-x, 1.15) - 1) * 0.5)));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  48% {
    transform: scale(calc(2 - (1 + (var(--fa-jello-scale-y, 1.12) - 1) * 0.3)), calc(1 + (var(--fa-jello-scale-y, 1.12) - 1) * 0.3));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  58% {
    transform: scale(1.02, 0.98);
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  68% {
    transform: scale(1, 1);
  }
  100% {
    transform: scale(1, 1);
  }
}
.fa-rotate-90 {
  transform: rotate(90deg);
}

.fa-rotate-180 {
  transform: rotate(180deg);
}

.fa-rotate-270 {
  transform: rotate(270deg);
}

.fa-flip-horizontal {
  transform: scale(-1, 1);
}

.fa-flip-vertical {
  transform: scale(1, -1);
}

.fa-flip-both,
.fa-flip-horizontal.fa-flip-vertical {
  transform: scale(-1, -1);
}

.fa-rotate-by {
  transform: rotate(var(--fa-rotate-angle, 0));
}

.svg-inline--fa .fa-primary {
  fill: var(--fa-primary-color, currentColor);
  opacity: var(--fa-primary-opacity, 1);
}

.svg-inline--fa .fa-secondary {
  fill: var(--fa-secondary-color, currentColor);
  opacity: var(--fa-secondary-opacity, 0.4);
}

.svg-inline--fa.fa-swap-opacity .fa-primary {
  opacity: var(--fa-secondary-opacity, 0.4);
}

.svg-inline--fa.fa-swap-opacity .fa-secondary {
  opacity: var(--fa-primary-opacity, 1);
}

.svg-inline--fa mask .fa-primary,
.svg-inline--fa mask .fa-secondary {
  fill: black;
}

.svg-inline--fa.fa-inverse {
  fill: var(--fa-inverse, #fff);
}

.fa-stack {
  display: inline-block;
  height: 2em;
  line-height: 2em;
  position: relative;
  vertical-align: middle;
  width: 2.5em;
}

.fa-inverse {
  color: var(--fa-inverse, #fff);
}

.svg-inline--fa.fa-stack-1x {
  --fa-width: 1.25em;
  height: 1em;
  width: var(--fa-width);
}
.svg-inline--fa.fa-stack-2x {
  --fa-width: 2.5em;
  height: 2em;
  width: var(--fa-width);
}

.fa-stack-1x,
.fa-stack-2x {
  inset: 0;
  margin: auto;
  position: absolute;
  z-index: var(--fa-stack-z-index, auto);
}`;function yp(){var e=Ef,t=Df,n=J.cssPrefix,r=J.replacementClass,i=vp;if(n!==e||r!==t){var a=RegExp(`\\.${e}\\-`,`g`),o=RegExp(`\\--${e}\\-`,`g`),s=RegExp(`\\.${t}`,`g`);i=i.replace(a,`.${n}-`).replace(o,`--${n}-`).replace(s,`.${r}`)}return i}var bp=!1;function xp(){J.autoAddCss&&!bp&&(sp(yp()),bp=!0)}var Sp={mixout:function(){return{dom:{css:yp,insertCss:xp}}},hooks:function(){return{beforeDOMElementCreation:function(){xp()},beforeI2svg:function(){xp()}}}},Cp=qu||{};Cp[wf]||(Cp[wf]={}),Cp[wf].styles||(Cp[wf].styles={}),Cp[wf].hooks||(Cp[wf].hooks={}),Cp[wf].shims||(Cp[wf].shims=[]);var wp=Cp[wf],Tp=[],Ep=function(){Ju.removeEventListener(`DOMContentLoaded`,Ep),Dp=1,Tp.map(function(e){return e()})},Dp=!1;Zu&&(Dp=(Ju.documentElement.doScroll?/^loaded|^c/:/^loaded|^i|^c/).test(Ju.readyState),Dp||Ju.addEventListener(`DOMContentLoaded`,Ep));function Op(e){Zu&&(Dp?setTimeout(e,0):Tp.push(e))}function kp(e){var t=e.tag,n=e.attributes,r=n===void 0?{}:n,i=e.children,a=i===void 0?[]:i;return typeof e==`string`?fp(e):`<${t} ${pp(r)}>${a.map(kp).join(``)}</${t}>`}function Ap(e,t,n){if(e&&e[t]&&e[t][n])return{prefix:t,iconName:n,icon:e[t][n]}}var jp=function(e,t){return function(n,r,i,a){return e.call(t,n,r,i,a)}},Mp=function(e,t,n,r){var i=Object.keys(e),a=i.length,o=r===void 0?t:jp(t,r),s,c,l;for(n===void 0?(s=1,l=e[i[0]]):(s=0,l=n);s<a;s++)c=i[s],l=o(l,e[c],c,e);return l};function Np(e){return Fu(e).length===1?e.codePointAt(0).toString(16):null}function Pp(e){return Object.keys(e).reduce(function(t,n){var r=e[n];return r.icon?t[r.iconName]=r.icon:t[n]=r,t},{})}function Fp(e,t){var n=(arguments.length>2&&arguments[2]!==void 0?arguments[2]:{}).skipHooks,r=n!==void 0&&n,i=Pp(t);typeof wp.hooks.addPack==`function`&&!r?wp.hooks.addPack(e,Pp(t)):wp.styles[e]=q(q({},wp.styles[e]||{}),i),e===`fas`&&Fp(`fa`,t)}var Ip=wp.styles,Lp=wp.shims,Rp=Object.keys(Wf),zp=Rp.reduce(function(e,t){return e[t]=Object.keys(Wf[t]),e},{}),Bp=null,Vp={},Hp={},Up={},Wp={},Gp={};function Kp(e){return~Zf.indexOf(e)}function qp(e,t){var n=t.split(`-`),r=n[0],i=n.slice(1).join(`-`);return r===e&&i!==``&&!Kp(i)?i:null}var Jp=function(){var e=function(e){return Mp(Ip,function(t,n,r){return t[r]=Mp(n,e,{}),t},{})};Vp=e(function(e,t,n){return t[3]&&(e[t[3]]=n),t[2]&&t[2].filter(function(e){return typeof e==`number`}).forEach(function(t){e[t.toString(16)]=n}),e}),Hp=e(function(e,t,n){return e[n]=n,t[2]&&t[2].filter(function(e){return typeof e==`string`}).forEach(function(t){e[t]=n}),e}),Gp=e(function(e,t,n){var r=t[2];return e[n]=n,r.forEach(function(t){e[t]=n}),e});var t=`far`in Ip||J.autoFetchSvg,n=Mp(Lp,function(e,n){var r=n[0],i=n[1],a=n[2];return i===`far`&&!t&&(i=`fas`),typeof r==`string`&&(e.names[r]={prefix:i,iconName:a}),typeof r==`number`&&(e.unicodes[r.toString(16)]={prefix:i,iconName:a}),e},{names:{},unicodes:{}});Up=n.names,Wp=n.unicodes,Bp=rm(J.styleDefault,{family:J.familyDefault})};ip(function(e){Bp=rm(e.styleDefault,{family:J.familyDefault})}),Jp();function Yp(e,t){return(Vp[e]||{})[t]}function Xp(e,t){return(Hp[e]||{})[t]}function Zp(e,t){return(Gp[e]||{})[t]}function Qp(e){return Up[e]||{prefix:null,iconName:null}}function $p(e){var t=Wp[e],n=Yp(`fas`,e);return t||(n?{prefix:`fas`,iconName:n}:null)||{prefix:null,iconName:null}}function em(){return Bp}var tm=function(){return{prefix:null,iconName:null,rest:[]}};function nm(e){var t=ad,n=Rp.reduce(function(e,t){return e[t]=`${J.cssPrefix}-${t}`,e},{});return $d.forEach(function(r){(e.includes(n[r])||e.some(function(e){return zp[r].includes(e)}))&&(t=r)}),t}function rm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).family,n=t===void 0?ad:t,r=Bf[n][e];if(n===od&&!e)return`fad`;var i=Hf[n][e]||Hf[n][r],a=e in wp.styles?e:null;return i||a||null}function im(e){var t=[],n=null;return e.forEach(function(e){var r=qp(J.cssPrefix,e);r?n=r:e&&t.push(e)}),{iconName:n,rest:t}}function am(e){return e.sort().filter(function(e,t,n){return n.indexOf(e)===t})}var om=vf.concat(af);function sm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).skipLookups,n=t!==void 0&&t,r=null,i=am(e.filter(function(e){return om.includes(e)})),a=am(e.filter(function(e){return!om.includes(e)})),o=Pu(i.filter(function(e){return r=e,!id.includes(e)}),1)[0],s=o===void 0?null:o,c=nm(i),l=q(q({},im(a)),{},{prefix:rm(s,{family:c})});return q(q(q({},l),dm({values:e,family:c,styles:Ip,config:J,canonical:l,givenPrefix:r})),cm(n,r,l))}function cm(e,t,n){var r=n.prefix,i=n.iconName;if(e||!r||!i)return{prefix:r,iconName:i};var a=t===`fa`?Qp(i):{},o=Zp(r,i);return i=a.iconName||o||i,r=a.prefix||r,r===`far`&&!Ip.far&&Ip.fas&&!J.autoFetchSvg&&(r=`fas`),{prefix:r,iconName:i}}var lm=$d.filter(function(e){return e!==ad||e!==od}),um=Object.keys(_f).filter(function(e){return e!==ad}).map(function(e){return Object.keys(_f[e])}).flat();function dm(e){var t=e.values,n=e.family,r=e.canonical,i=e.givenPrefix,a=i===void 0?``:i,o=e.styles,s=o===void 0?{}:o,c=e.config,l=c===void 0?{}:c,u=n===od,d=t.includes(`fa-duotone`)||t.includes(`fad`),f=l.familyDefault===`duotone`,p=r.prefix===`fad`||r.prefix===`fa-duotone`;return!u&&(d||f||p)&&(r.prefix=`fad`),(t.includes(`fa-brands`)||t.includes(`fab`))&&(r.prefix=`fab`),!r.prefix&&lm.includes(n)&&(Object.keys(s).find(function(e){return um.includes(e)})||l.autoFetchSvg)&&(r.prefix=nf.get(n).defaultShortPrefixId,r.iconName=Zp(r.prefix,r.iconName)||r.iconName),(r.prefix===`fa`||a===`fa`)&&(r.prefix=em()||`fas`),r}var fm=function(){function e(){Tu(this,e),this.definitions={}}return Du(e,[{key:`add`,value:function(){var e=this,t=[...arguments].reduce(this._pullDefinitions,{});Object.keys(t).forEach(function(n){e.definitions[n]=q(q({},e.definitions[n]||{}),t[n]),Fp(n,t[n]);var r=Wf[ad][n];r&&Fp(r,t[n]),Jp()})}},{key:`reset`,value:function(){this.definitions={}}},{key:`_pullDefinitions`,value:function(e,t){var n=t.prefix&&t.iconName&&t.icon?{0:t}:t;return Object.keys(n).map(function(t){var r=n[t],i=r.prefix,a=r.iconName,o=r.icon,s=o[2];e[i]||(e[i]={}),s.length>0&&s.forEach(function(t){typeof t==`string`&&(e[i][t]=o)}),e[i][a]=o}),e}}])}(),pm=[],mm={},hm={},gm=Object.keys(hm);function _m(e,t){var n=t.mixoutsTo;return pm=e,mm={},Object.keys(hm).forEach(function(e){gm.indexOf(e)===-1&&delete hm[e]}),pm.forEach(function(e){var t=e.mixout?e.mixout():{};if(Object.keys(t).forEach(function(e){typeof t[e]==`function`&&(n[e]=t[e]),Ru(t[e])===`object`&&Object.keys(t[e]).forEach(function(r){n[e]||(n[e]={}),n[e][r]=t[e][r]})}),e.hooks){var r=e.hooks();Object.keys(r).forEach(function(e){mm[e]||(mm[e]=[]),mm[e].push(r[e])})}e.provides&&e.provides(hm)}),n}function vm(e,t){var n=[...arguments].slice(2);return(mm[e]||[]).forEach(function(e){t=e.apply(null,[t].concat(n))}),t}function ym(e){var t=[...arguments].slice(1);(mm[e]||[]).forEach(function(e){e.apply(null,t)})}function bm(){var e=arguments[0],t=Array.prototype.slice.call(arguments,1);return hm[e]?hm[e].apply(null,t):void 0}function xm(e){e.prefix===`fa`&&(e.prefix=`fas`);var t=e.iconName,n=e.prefix||em();if(t)return t=Zp(n,t)||t,Ap(Sm.definitions,n,t)||Ap(wp.styles,n,t)}var Sm=new fm,Cm={noAuto:function(){J.autoReplaceSvg=!1,J.observeMutations=!1,ym(`noAuto`)},config:J,dom:{i2svg:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return Zu?(ym(`beforeI2svg`,e),bm(`pseudoElements2svg`,e),bm(`i2svg`,e)):Promise.reject(Error(`Operation requires a DOM of some kind.`))},watch:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},t=e.autoReplaceSvgRoot;J.autoReplaceSvg===!1&&(J.autoReplaceSvg=!0),J.observeMutations=!0,Op(function(){wm({autoReplaceSvgRoot:t}),ym(`watch`,e)})}},parse:{icon:function(e){if(e===null)return null;if(Ru(e)===`object`&&e.prefix&&e.iconName)return{prefix:e.prefix,iconName:Zp(e.prefix,e.iconName)||e.iconName};if(Array.isArray(e)&&e.length===2){var t=e[1].indexOf(`fa-`)===0?e[1].slice(3):e[1],n=rm(e[0]);return{prefix:n,iconName:Zp(n,t)||t}}if(typeof e==`string`&&(e.indexOf(`${J.cssPrefix}-`)>-1||e.match(Kf))){var r=sm(e.split(` `),{skipLookups:!0});return{prefix:r.prefix||em(),iconName:Zp(r.prefix,r.iconName)||r.iconName}}if(typeof e==`string`){var i=em();return{prefix:i,iconName:Zp(i,e)||e}}}},library:Sm,findIconDefinition:xm,toHtml:kp},wm=function(){var e=(arguments.length>0&&arguments[0]!==void 0?arguments[0]:{}).autoReplaceSvgRoot,t=e===void 0?Ju:e;(Object.keys(wp.styles).length>0||J.autoFetchSvg)&&Zu&&J.autoReplaceSvg&&Cm.dom.i2svg({node:t})};function Tm(e,t){return Object.defineProperty(e,"abstract",{get:t}),Object.defineProperty(e,"html",{get:function(){return e.abstract.map(function(e){return kp(e)})}}),Object.defineProperty(e,"node",{get:function(){if(Zu){var t=Ju.createElement(`div`);return t.innerHTML=e.html,t.children}}}),e}function Em(e){var t=e.children,n=e.main,r=e.mask,i=e.attributes,a=e.styles,o=e.transform;if(hp(o)&&n.found&&!r.found){var s={x:n.width/n.height/2,y:.5};i.style=mp(q(q({},a),{},{"transform-origin":`${s.x+o.x/16}em ${s.y+o.y/16}em`}))}return[{tag:`svg`,attributes:i,children:t}]}function Dm(e){var t=e.prefix,n=e.iconName,r=e.children,i=e.attributes,a=e.symbol,o=a===!0?`${t}-${J.cssPrefix}-${n}`:a;return[{tag:`svg`,attributes:{style:`display: none;`},children:[{tag:`symbol`,attributes:q(q({},i),{},{id:o}),children:r}]}]}function Om(e){return[`aria-label`,`aria-labelledby`,`title`,`role`].some(function(t){return t in e})}function km(e){var t=e.icons,n=t.main,r=t.mask,i=e.prefix,a=e.iconName,o=e.transform,s=e.symbol,c=e.maskId,l=e.extra,u=e.watchable,d=u!==void 0&&u,f=r.found?r:n,p=f.width,m=f.height,h=[J.replacementClass,a?`${J.cssPrefix}-${a}`:``].filter(function(e){return l.classes.indexOf(e)===-1}).filter(function(e){return e!==``||!!e}).concat(l.classes).join(` `),g={children:[],attributes:q(q({},l.attributes),{},{"data-prefix":i,"data-icon":a,class:h,role:l.attributes.role||`img`,viewBox:`0 0 ${p} ${m}`})};!Om(l.attributes)&&!l.attributes[`aria-hidden`]&&(g.attributes[`aria-hidden`]=`true`),d&&(g.attributes[Of]=``);var _=q(q({},g),{},{prefix:i,iconName:a,main:n,mask:r,maskId:c,transform:o,symbol:s,styles:q({},l.styles)}),v=r.found&&n.found?bm(`generateAbstractMask`,_)||{children:[],attributes:{}}:bm(`generateAbstractIcon`,_)||{children:[],attributes:{}},y=v.children,b=v.attributes;return _.children=y,_.attributes=b,s?Dm(_):Em(_)}function Am(e){var t=e.content,n=e.width,r=e.height,i=e.transform,a=e.extra,o=e.watchable,s=o!==void 0&&o,c=q(q({},a.attributes),{},{class:a.classes.join(` `)});s&&(c[Of]=``);var l=q({},a.styles);hp(i)&&(l.transform=_p({transform:i,startCentered:!0,width:n,height:r}),l[`-webkit-transform`]=l.transform);var u=mp(l);u.length>0&&(c.style=u);var d=[];return d.push({tag:`span`,attributes:c,children:[t]}),d}function jm(e){var t=e.content,n=e.extra,r=q(q({},n.attributes),{},{class:n.classes.join(` `)}),i=mp(n.styles);i.length>0&&(r.style=i);var a=[];return a.push({tag:`span`,attributes:r,children:[t]}),a}var Mm=wp.styles;function Nm(e){var t=e[0],n=e[1],r=Pu(e.slice(4),1)[0],i=null;return i=Array.isArray(r)?{tag:`g`,attributes:{class:`${J.cssPrefix}-${Xf.GROUP}`},children:[{tag:`path`,attributes:{class:`${J.cssPrefix}-${Xf.SECONDARY}`,fill:`currentColor`,d:r[0]}},{tag:`path`,attributes:{class:`${J.cssPrefix}-${Xf.PRIMARY}`,fill:`currentColor`,d:r[1]}}]}:{tag:`path`,attributes:{fill:`currentColor`,d:r}},{found:!0,width:t,height:n,icon:i}}var Pm={found:!1,width:512,height:512};function Fm(e,t){!Lf&&!J.showMissingIcons&&e&&console.error(`Icon with name "${e}" and prefix "${t}" is missing.`)}function Im(e,t){var n=t;return t===`fa`&&J.styleDefault!==null&&(t=em()),new Promise(function(r,i){if(n===`fa`){var a=Qp(e)||{};e=a.iconName||e,t=a.prefix||t}if(e&&t&&Mm[t]&&Mm[t][e]){var o=Mm[t][e];return r(Nm(o))}Fm(e,t),r(q(q({},Pm),{},{icon:J.showMissingIcons&&e&&bm(`missingIconAbstract`)||{}}))})}var Lm=function(){},Rm=J.measurePerformance&&Xu&&Xu.mark&&Xu.measure?Xu:{mark:Lm,measure:Lm},zm=`FA "7.3.1"`,Bm=function(e){return Rm.mark(`${zm} ${e} begins`),function(){return Vm(e)}},Vm=function(e){Rm.mark(`${zm} ${e} ends`),Rm.measure(`${zm} ${e}`,`${zm} ${e} begins`,`${zm} ${e} ends`)},Hm={begin:Bm,end:Vm},Um=function(){};function Wm(e){return typeof(e.getAttribute?e.getAttribute(Of):null)==`string`}function Gm(e){var t=e.getAttribute?e.getAttribute(jf):null,n=e.getAttribute?e.getAttribute(Mf):null;return t&&n}function Km(e){return e&&e.classList&&e.classList.contains&&e.classList.contains(J.replacementClass)}function qm(){return J.autoReplaceSvg===!0?Qm.replace:Qm[J.autoReplaceSvg]||Qm.replace}function Jm(e){return Ju.createElementNS(`http://www.w3.org/2000/svg`,e)}function Ym(e){return Ju.createElement(e)}function Xm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).ceFn,n=t===void 0?e.tag===`svg`?Jm:Ym:t;if(typeof e==`string`)return Ju.createTextNode(e);var r=n(e.tag);return Object.keys(e.attributes||[]).forEach(function(t){r.setAttribute(t,e.attributes[t])}),(e.children||[]).forEach(function(e){r.appendChild(Xm(e,{ceFn:n}))}),r}function Zm(e){var t=` ${e.outerHTML} `;return t=`${t}Font Awesome fontawesome.com `,t}var Qm={replace:function(e){var t=e[0];if(t.parentNode){if(e[1].forEach(function(e){t.parentNode.insertBefore(Xm(e),t)}),t.getAttribute(Of)===null&&J.keepOriginalSource){var n=Ju.createComment(Zm(t));t.parentNode.replaceChild(n,t)}else t.remove()}},nest:function(e){var t=e[0],n=e[1];if(~dp(t).indexOf(J.replacementClass))return Qm.replace(e);var r=RegExp(`${J.cssPrefix}-.*`);if(delete n[0].attributes.id,n[0].attributes.class){var i=n[0].attributes.class.split(` `).reduce(function(e,t){return t===J.replacementClass||t.match(r)?e.toSvg.push(t):e.toNode.push(t),e},{toNode:[],toSvg:[]});n[0].attributes.class=i.toSvg.join(` `),i.toNode.length===0?t.removeAttribute(`class`):t.setAttribute(`class`,i.toNode.join(` `))}var a=n.map(function(e){return kp(e)}).join(`
`);t.setAttribute(Of,``),t.innerHTML=a}};function $m(e){e()}function eh(e,t){var n=typeof t==`function`?t:Um;if(e.length===0)n();else{var r=$m;J.mutateApproach===Pf&&(r=qu.requestAnimationFrame||$m),r(function(){var t=qm(),r=Hm.begin(`mutate`);e.map(t),r(),n()})}}var th=!1;function nh(){th=!0}function rh(){th=!1}var ih=null;function ah(e){if(Yu&&J.observeMutations){var t=e.treeCallback,n=t===void 0?Um:t,r=e.nodeCallback,i=r===void 0?Um:r,a=e.pseudoElementsCallback,o=a===void 0?Um:a,s=e.observeMutationsRoot,c=s===void 0?Ju:s;ih=new Yu(function(e){if(!th){var t=em();up(e).forEach(function(e){if(e.type===`childList`&&e.addedNodes.length>0&&!Wm(e.addedNodes[0])&&(J.searchPseudoElements&&o(e.target),n(e.target)),e.type===`attributes`&&e.target.parentNode&&J.searchPseudoElements&&o([e.target],!0),e.type===`attributes`&&Wm(e.target)&&~Yf.indexOf(e.attributeName)){if(e.attributeName===`class`&&Gm(e.target)){var r=sm(dp(e.target)),a=r.prefix,s=r.iconName;e.target.setAttribute(jf,a||t),s&&e.target.setAttribute(Mf,s)}else Km(e.target)&&i(e.target)}})}}),Zu&&ih.observe(c,{childList:!0,attributes:!0,characterData:!0,subtree:!0})}}function oh(){ih&&ih.disconnect()}function sh(e){var t=e.getAttribute(`style`),n=[];return t&&(n=t.split(`;`).reduce(function(e,t){var n=t.split(`:`),r=n[0],i=n.slice(1);return r&&i.length>0&&(e[r]=i.join(`:`).trim()),e},{})),n}function ch(e){var t=e.getAttribute(`data-prefix`),n=e.getAttribute(`data-icon`),r=e.innerText===void 0?``:e.innerText.trim(),i=sm(dp(e));return i.prefix||=em(),t&&n&&(i.prefix=t,i.iconName=n),i.iconName&&i.prefix?i:(i.prefix&&r.length>0&&(i.iconName=Xp(i.prefix,e.innerText)||Yp(i.prefix,Np(e.innerText))),!i.iconName&&J.autoFetchSvg&&e.firstChild&&e.firstChild.nodeType===Node.TEXT_NODE&&(i.iconName=e.firstChild.data),i)}function lh(e){return up(e.attributes).reduce(function(e,t){return e.name!==`class`&&e.name!==`style`&&(e[t.name]=t.value),e},{})}function uh(){return{iconName:null,prefix:null,transform:op,symbol:!1,mask:{iconName:null,prefix:null,rest:[]},maskId:null,extra:{classes:[],styles:{},attributes:{}}}}function dh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{styleParser:!0},n=ch(e),r=n.iconName,i=n.prefix,a=n.rest,o=lh(e),s=vm(`parseNodeAttributes`,{},e);return q({iconName:r,prefix:i,transform:op,mask:{iconName:null,prefix:null,rest:[]},maskId:null,symbol:!1,extra:{classes:a,styles:t.styleParser?sh(e):[],attributes:o}},s)}var fh=wp.styles;function ph(e){var t=J.autoReplaceSvg===`nest`?dh(e,{styleParser:!1}):dh(e);return~t.extra.classes.indexOf(qf)?bm(`generateLayersText`,e,t):bm(`generateSvgReplacementMutation`,e,t)}function mh(){return[].concat(Fu(af),Fu(vf))}function hh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(!Zu)return Promise.resolve();var n=Ju.documentElement.classList,r=function(e){return n.add(`${Nf}-${e}`)},i=function(e){return n.remove(`${Nf}-${e}`)},a=J.autoFetchSvg?mh():id.concat(Object.keys(fh));a.includes(`fa`)||a.push(`fa`);var o=[`.${qf}:not([${Of}])`].concat(a.map(function(e){return`.${e}:not([${Of}])`})).join(`, `);if(o.length===0)return Promise.resolve();var s=[];try{s=up(e.querySelectorAll(o))}catch{}if(s.length>0)r(`pending`),i(`complete`);else return Promise.resolve();var c=Hm.begin(`onTree`),l=s.reduce(function(e,t){try{var n=ph(t);n&&e.push(n)}catch(e){Lf||e.name===`MissingIcon`&&console.error(e)}return e},[]);return new Promise(function(e,n){Promise.all(l).then(function(n){eh(n,function(){r(`active`),r(`complete`),i(`pending`),typeof t==`function`&&t(),c(),e()})}).catch(function(e){c(),n(e)})})}function gh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;ph(e).then(function(e){e&&eh([e],t)})}function _h(e){return function(t){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},r=(t||{}).icon?t:xm(t||{}),i=n.mask;return i&&=(i||{}).icon?i:xm(i||{}),e(r,q(q({},n),{},{mask:i}))}}var vh=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?op:n,i=t.symbol,a=i!==void 0&&i,o=t.mask,s=o===void 0?null:o,c=t.maskId,l=c===void 0?null:c,u=t.classes,d=u===void 0?[]:u,f=t.attributes,p=f===void 0?{}:f,m=t.styles,h=m===void 0?{}:m;if(e){var g=e.prefix,_=e.iconName,v=e.icon;return Tm(q({type:`icon`},e),function(){return ym(`beforeDOMElementCreation`,{iconDefinition:e,params:t}),km({icons:{main:Nm(v),mask:s?Nm(s.icon):{found:!1,width:null,height:null,icon:{}}},prefix:g,iconName:_,transform:q(q({},op),r),symbol:a,maskId:l,extra:{attributes:p,styles:h,classes:d}})})}},yh={mixout:function(){return{icon:_h(vh)}},hooks:function(){return{mutationObserverCallbacks:function(e){return e.treeCallback=hh,e.nodeCallback=gh,e}}},provides:function(e){e.i2svg=function(e){var t=e.node,n=t===void 0?Ju:t,r=e.callback;return hh(n,r===void 0?function(){}:r)},e.generateSvgReplacementMutation=function(e,t){var n=t.iconName,r=t.prefix,i=t.transform,a=t.symbol,o=t.mask,s=t.maskId,c=t.extra;return new Promise(function(t,l){Promise.all([Im(n,r),o.iconName?Im(o.iconName,o.prefix):Promise.resolve({found:!1,width:512,height:512,icon:{}})]).then(function(o){var l=Pu(o,2),u=l[0],d=l[1];t([e,km({icons:{main:u,mask:d},prefix:r,iconName:n,transform:i,symbol:a,maskId:s,extra:c,watchable:!0})])}).catch(l)})},e.generateAbstractIcon=function(e){var t=e.children,n=e.attributes,r=e.main,i=e.transform,a=e.styles,o=mp(a);o.length>0&&(n.style=o);var s;return hp(i)&&(s=bm(`generateAbstractTransformGrouping`,{main:r,transform:i,containerWidth:r.width,iconWidth:r.width})),t.push(s||r.icon),{children:t,attributes:n}}}},bh={mixout:function(){return{layer:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.classes,r=n===void 0?[]:n;return Tm({type:`layer`},function(){ym(`beforeDOMElementCreation`,{assembler:e,params:t});var n=[];return e(function(e){Array.isArray(e)?e.map(function(e){n=n.concat(e.abstract)}):n=n.concat(e.abstract)}),[{tag:`span`,attributes:{class:[`${J.cssPrefix}-layers`].concat(Fu(r)).join(` `)},children:n}]})}}}},xh={mixout:function(){return{counter:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.title,r=n===void 0?null:n,i=t.classes,a=i===void 0?[]:i,o=t.attributes,s=o===void 0?{}:o,c=t.styles,l=c===void 0?{}:c;return Tm({type:`counter`,content:e},function(){return ym(`beforeDOMElementCreation`,{content:e,params:t}),jm({content:e.toString(),title:r,extra:{attributes:s,styles:l,classes:[`${J.cssPrefix}-layers-counter`].concat(Fu(a))}})})}}}},Sh={mixout:function(){return{text:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?op:n,i=t.classes,a=i===void 0?[]:i,o=t.attributes,s=o===void 0?{}:o,c=t.styles,l=c===void 0?{}:c;return Tm({type:`text`,content:e},function(){return ym(`beforeDOMElementCreation`,{content:e,params:t}),Am({content:e,transform:q(q({},op),r),extra:{attributes:s,styles:l,classes:[`${J.cssPrefix}-layers-text`].concat(Fu(a))}})})}}},provides:function(e){e.generateLayersText=function(e,t){var n=t.transform,r=t.extra,i=null,a=null;if(Qu){var o=parseInt(getComputedStyle(e).fontSize,10),s=e.getBoundingClientRect();i=s.width/o,a=s.height/o}return Promise.resolve([e,Am({content:e.innerHTML,width:i,height:a,transform:n,extra:r,watchable:!0})])}}},Ch=RegExp(`"`,`ug`),wh=[1105920,1112319],Th=q(q(q(q({},{FontAwesome:{normal:`fas`,400:`fas`}}),tf),Cf),lf),Eh=Object.keys(Th).reduce(function(e,t){return e[t.toLowerCase()]=Th[t],e},{}),Dh=Object.keys(Eh).reduce(function(e,t){var n=Eh[t];return e[t]=n[900]||Fu(Object.entries(n))[0][1],e},{});function Oh(e){return Np(Fu(e.replace(Ch,``))[0]||``)}function kh(e){var t=e.getPropertyValue(`font-feature-settings`).includes(`ss01`),n=e.getPropertyValue(`content`).replace(Ch,``),r=n.codePointAt(0),i=r>=wh[0]&&r<=wh[1],a=n.length===2&&n[0]===n[1];return i||a||t}function Ah(e,t){var n=e.replace(/^['"]|['"]$/g,``).toLowerCase(),r=parseInt(t),i=isNaN(r)?`normal`:r;return(Eh[n]||{})[i]||Dh[n]}function jh(e,t){var n=`${Af}${t.replace(`:`,`-`)}`;return new Promise(function(r,i){if(e.getAttribute(n)!==null)return r();var a=up(e.children).filter(function(e){return e.getAttribute(kf)===t})[0],o=qu.getComputedStyle(e,t),s=o.getPropertyValue(`font-family`),c=s.match(Jf),l=o.getPropertyValue(`font-weight`),u=o.getPropertyValue(`content`);if(a&&!c)return e.removeChild(a),r();if(c&&u!==`none`&&u!==``){var d=o.getPropertyValue(`content`),f=Ah(s,l),p=Oh(d),m=c[0].startsWith(`FontAwesome`),h=kh(o),g=Yp(f,p),_=g;if(m){var v=$p(p);v.iconName&&v.prefix&&(g=v.iconName,f=v.prefix)}if(g&&!h&&(!a||a.getAttribute(jf)!==f||a.getAttribute(Mf)!==_)){e.setAttribute(n,_),a&&e.removeChild(a);var y=uh(),b=y.extra;b.attributes[kf]=t,Im(g,f).then(function(i){var a=km(q(q({},y),{},{icons:{main:i,mask:tm()},prefix:f,iconName:_,extra:b,watchable:!0})),o=Ju.createElementNS(`http://www.w3.org/2000/svg`,`svg`);t===`::before`?e.insertBefore(o,e.firstChild):e.appendChild(o),o.outerHTML=a.map(function(e){return kp(e)}).join(`
`),e.removeAttribute(n),r()}).catch(i)}else r()}else r()})}function Mh(e){return Promise.all([jh(e,`::before`),jh(e,`::after`)])}function Nh(e){return e.parentNode!==document.head&&!~Ff.indexOf(e.tagName.toUpperCase())&&!e.getAttribute(kf)&&(!e.parentNode||e.parentNode.tagName!==`svg`)}var Ph=function(e){return!!e&&If.some(function(t){return e.includes(t)})},Fh=function(e){if(!e)return[];var t=new Set,n=e.split(/,(?![^()]*\))/).map(function(e){return e.trim()});n=n.flatMap(function(e){return e.includes(`(`)?e:e.split(`,`).map(function(e){return e.trim()})});var r=Ou(n),i;try{for(r.s();!(i=r.n()).done;){var a=i.value;if(Ph(a)){var o=If.reduce(function(e,t){return e.replace(t,``)},a);o!==``&&o!==`*`&&t.add(o)}}}catch(e){r.e(e)}finally{r.f()}return t};function Ih(e){var t=arguments.length>1&&arguments[1]!==void 0&&arguments[1];if(Zu){var n;if(t)n=e;else if(J.searchPseudoElementsFullScan)n=e.querySelectorAll(`*`);else{var r=new Set,i=Ou(document.styleSheets),a;try{for(i.s();!(a=i.n()).done;){var o=a.value;try{var s=Ou(o.cssRules),c;try{for(s.s();!(c=s.n()).done;){var l=c.value,u=Ou(Fh(l.selectorText)),d;try{for(u.s();!(d=u.n()).done;){var f=d.value;r.add(f)}}catch(e){u.e(e)}finally{u.f()}}}catch(e){s.e(e)}finally{s.f()}}catch(e){J.searchPseudoElementsWarnings&&console.warn(`Font Awesome: cannot parse stylesheet: ${o.href} (${e.message})
If it declares any Font Awesome CSS pseudo-elements, they will not be rendered as SVG icons. Add crossorigin="anonymous" to the <link>, enable searchPseudoElementsFullScan for slower but more thorough DOM parsing, or suppress this warning by setting searchPseudoElementsWarnings to false.`)}}}catch(e){i.e(e)}finally{i.f()}if(!r.size)return;var p=Array.from(r).join(`, `);try{n=e.querySelectorAll(p)}catch{}}return new Promise(function(e,t){var r=up(n).filter(Nh).map(Mh),i=Hm.begin(`searchPseudoElements`);nh(),Promise.all(r).then(function(){i(),rh(),e()}).catch(function(){i(),rh(),t()})})}}var Lh={hooks:function(){return{mutationObserverCallbacks:function(e){return e.pseudoElementsCallback=Ih,e}}},provides:function(e){e.pseudoElements2svg=function(e){var t=e.node,n=t===void 0?Ju:t;J.searchPseudoElements&&Ih(n)}}},Rh=!1,zh={mixout:function(){return{dom:{unwatch:function(){nh(),Rh=!0}}}},hooks:function(){return{bootstrap:function(){ah(vm(`mutationObserverCallbacks`,{}))},noAuto:function(){oh()},watch:function(e){var t=e.observeMutationsRoot;Rh?rh():ah(vm(`mutationObserverCallbacks`,{observeMutationsRoot:t}))}}}},Bh=function(e){return e.toLowerCase().split(` `).reduce(function(e,t){var n=t.toLowerCase().split(`-`),r=n[0],i=n.slice(1).join(`-`);if(r&&i===`h`)return e.flipX=!0,e;if(r&&i===`v`)return e.flipY=!0,e;if(i=parseFloat(i),isNaN(i))return e;switch(r){case`grow`:e.size+=i;break;case`shrink`:e.size-=i;break;case`left`:e.x-=i;break;case`right`:e.x+=i;break;case`up`:e.y-=i;break;case`down`:e.y+=i;break;case`rotate`:e.rotate+=i}return e},{size:16,x:0,y:0,flipX:!1,flipY:!1,rotate:0})},Vh={mixout:function(){return{parse:{transform:function(e){return Bh(e)}}}},hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-transform`);return n&&(e.transform=Bh(n)),e}}},provides:function(e){e.generateAbstractTransformGrouping=function(e){var t=e.main,n=e.transform,r=e.containerWidth,i=e.iconWidth,a={outer:{transform:`translate(${r/2} 256)`},inner:{transform:`${`translate(${n.x*32}, ${n.y*32}) `} ${`scale(${n.size/16*(n.flipX?-1:1)}, ${n.size/16*(n.flipY?-1:1)}) `} ${`rotate(${n.rotate} 0 0)`}`},path:{transform:`translate(${i/2*-1} -256)`}};return{tag:`g`,attributes:q({},a.outer),children:[{tag:`g`,attributes:q({},a.inner),children:[{tag:t.icon.tag,children:t.icon.children,attributes:q(q({},t.icon.attributes),a.path)}]}]}}}},Hh={x:0,y:0,width:`100%`,height:`100%`};function Uh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return e.attributes&&(e.attributes.fill||t)&&(e.attributes.fill=`black`),e}function Wh(e){return e.tag===`g`?e.children:[e]}_m([Sp,yh,bh,xh,Sh,Lh,zh,Vh,{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-mask`),r=n?sm(n.split(` `).map(function(e){return e.trim()})):tm();return r.prefix||=em(),e.mask=r,e.maskId=t.getAttribute(`data-fa-mask-id`),e}}},provides:function(e){e.generateAbstractMask=function(e){var t=e.children,n=e.attributes,r=e.main,i=e.mask,a=e.maskId,o=e.transform,s=r.width,c=r.icon,l=i.width,u=i.icon,d=gp({transform:o,containerWidth:l,iconWidth:s}),f={tag:`rect`,attributes:q(q({},Hh),{},{fill:`white`})},p=c.children?{children:c.children.map(Uh)}:{},m={tag:`g`,attributes:q({},d.inner),children:[Uh(q({tag:c.tag,attributes:q(q({},c.attributes),d.path)},p))]},h={tag:`g`,attributes:q({},d.outer),children:[m]},g=`mask-${a||lp()}`,_=`clip-${a||lp()}`,v={tag:`mask`,attributes:q(q({},Hh),{},{id:g,maskUnits:`userSpaceOnUse`,maskContentUnits:`userSpaceOnUse`}),children:[f,h]},y={tag:`defs`,children:[{tag:`clipPath`,attributes:{id:_},children:Wh(u)},v]};return t.push(y,{tag:`rect`,attributes:q({fill:`currentColor`,"clip-path":`url(#${_})`,mask:`url(#${g})`},Hh)}),{children:t,attributes:n}}}},{provides:function(e){var t=!1;qu.matchMedia&&(t=qu.matchMedia(`(prefers-reduced-motion: reduce)`).matches),e.missingIconAbstract=function(){var e=[],n={fill:`currentColor`},r={attributeType:`XML`,repeatCount:`indefinite`,dur:`2s`};e.push({tag:`path`,attributes:q(q({},n),{},{d:`M156.5,447.7l-12.6,29.5c-18.7-9.5-35.9-21.2-51.5-34.9l22.7-22.7C127.6,430.5,141.5,440,156.5,447.7z M40.6,272H8.5 c1.4,21.2,5.4,41.7,11.7,61.1L50,321.2C45.1,305.5,41.8,289,40.6,272z M40.6,240c1.4-18.8,5.2-37,11.1-54.1l-29.5-12.6 C14.7,194.3,10,216.7,8.5,240H40.6z M64.3,156.5c7.8-14.9,17.2-28.8,28.1-41.5L69.7,92.3c-13.7,15.6-25.5,32.8-34.9,51.5 L64.3,156.5z M397,419.6c-13.9,12-29.4,22.3-46.1,30.4l11.9,29.8c20.7-9.9,39.8-22.6,56.9-37.6L397,419.6z M115,92.4 c13.9-12,29.4-22.3,46.1-30.4l-11.9-29.8c-20.7,9.9-39.8,22.6-56.8,37.6L115,92.4z M447.7,355.5c-7.8,14.9-17.2,28.8-28.1,41.5 l22.7,22.7c13.7-15.6,25.5-32.9,34.9-51.5L447.7,355.5z M471.4,272c-1.4,18.8-5.2,37-11.1,54.1l29.5,12.6 c7.5-21.1,12.2-43.5,13.6-66.8H471.4z M321.2,462c-15.7,5-32.2,8.2-49.2,9.4v32.1c21.2-1.4,41.7-5.4,61.1-11.7L321.2,462z M240,471.4c-18.8-1.4-37-5.2-54.1-11.1l-12.6,29.5c21.1,7.5,43.5,12.2,66.8,13.6V471.4z M462,190.8c5,15.7,8.2,32.2,9.4,49.2h32.1 c-1.4-21.2-5.4-41.7-11.7-61.1L462,190.8z M92.4,397c-12-13.9-22.3-29.4-30.4-46.1l-29.8,11.9c9.9,20.7,22.6,39.8,37.6,56.9 L92.4,397z M272,40.6c18.8,1.4,36.9,5.2,54.1,11.1l12.6-29.5C317.7,14.7,295.3,10,272,8.5V40.6z M190.8,50 c15.7-5,32.2-8.2,49.2-9.4V8.5c-21.2,1.4-41.7,5.4-61.1,11.7L190.8,50z M442.3,92.3L419.6,115c12,13.9,22.3,29.4,30.5,46.1 l29.8-11.9C470,128.5,457.3,109.4,442.3,92.3z M397,92.4l22.7-22.7c-15.6-13.7-32.8-25.5-51.5-34.9l-12.6,29.5 C370.4,72.1,384.4,81.5,397,92.4z`})});var i=q(q({},r),{},{attributeName:`opacity`}),a={tag:`circle`,attributes:q(q({},n),{},{cx:`256`,cy:`364`,r:`28`}),children:[]};return t||a.children.push({tag:`animate`,attributes:q(q({},r),{},{attributeName:`r`,values:`28;14;28;28;14;28;`})},{tag:`animate`,attributes:q(q({},i),{},{values:`1;0;1;1;0;1;`})}),e.push(a),e.push({tag:`path`,attributes:q(q({},n),{},{opacity:`1`,d:`M263.7,312h-16c-6.6,0-12-5.4-12-12c0-71,77.4-63.9,77.4-107.8c0-20-17.8-40.2-57.4-40.2c-29.1,0-44.3,9.6-59.2,28.7 c-3.9,5-11.1,6-16.2,2.4l-13.1-9.2c-5.6-3.9-6.9-11.8-2.6-17.2c21.2-27.2,46.4-44.7,91.2-44.7c52.3,0,97.4,29.8,97.4,80.2 c0,67.6-77.4,63.5-77.4,107.8C275.7,306.6,270.3,312,263.7,312z`}),children:t?[]:[{tag:`animate`,attributes:q(q({},i),{},{values:`1;0;0;0;0;1;`})}]}),t||e.push({tag:`path`,attributes:q(q({},n),{},{opacity:`0`,d:`M232.5,134.5l7,168c0.3,6.4,5.6,11.5,12,11.5h9c6.4,0,11.7-5.1,12-11.5l7-168c0.3-6.8-5.2-12.5-12-12.5h-23 C237.7,122,232.2,127.7,232.5,134.5z`}),children:[{tag:`animate`,attributes:q(q({},i),{},{values:`0;0;1;1;0;0;`})}]}),{tag:`g`,attributes:{class:`missing`},children:e}}}},{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-symbol`);return e.symbol=n===null?!1:n===``||n,e}}}}],{mixoutsTo:Cm}),Cm.noAuto,Cm.config,Cm.library,Cm.dom;var Gh=Cm.parse;Cm.findIconDefinition,Cm.toHtml;var Kh=Cm.icon;Cm.layer,Cm.text,Cm.counter;function qh(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function Jh(e){if(Array.isArray(e))return qh(e)}function Yh(e,t,n){return(t=ig(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function Xh(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function Zh(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Qh(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function $h(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Qh(Object(n),!0).forEach(function(t){Yh(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Qh(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function eg(e,t){if(e==null)return{};var n,r,i=tg(e,t);if(Object.getOwnPropertySymbols){var a=Object.getOwnPropertySymbols(e);for(r=0;r<a.length;r++)n=a[r],t.indexOf(n)===-1&&{}.propertyIsEnumerable.call(e,n)&&(i[n]=e[n])}return i}function tg(e,t){if(e==null)return{};var n={};for(var r in e)if({}.hasOwnProperty.call(e,r)){if(t.indexOf(r)!==-1)continue;n[r]=e[r]}return n}function ng(e){return Jh(e)||Xh(e)||og(e)||Zh()}function rg(e,t){if(typeof e!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(typeof r!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function ig(e){var t=rg(e,`string`);return typeof t==`symbol`?t:t+``}function ag(e){"@babel/helpers - typeof";return ag=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},ag(e)}function og(e,t){if(e){if(typeof e==`string`)return qh(e,t);var n={}.toString.call(e).slice(8,-1);return n===`Object`&&e.constructor&&(n=e.constructor.name),n===`Map`||n===`Set`?Array.from(e):n===`Arguments`||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?qh(e,t):void 0}}function sg(e,t){return Array.isArray(t)&&t.length>0||!Array.isArray(t)&&t?Yh({},e,t):{}}function cg(e){var t,n=(t={"fa-spin":e.spin,"fa-pulse":e.pulse,"fa-fw":e.fixedWidth,"fa-border":e.border,"fa-li":e.listItem,"fa-inverse":e.inverse,"fa-flip":e.flip===!0,"fa-flip-horizontal":e.flip===`horizontal`||e.flip===`both`,"fa-flip-vertical":e.flip===`vertical`||e.flip===`both`},Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(t,`fa-${e.size}`,e.size!==null),`fa-rotate-${e.rotation}`,e.rotation!==null),`fa-rotate-by`,e.rotateBy),`fa-pull-${e.pull}`,e.pull!==null),`fa-swap-opacity`,e.swapOpacity),`fa-bounce`,e.bounce),`fa-shake`,e.shake),`fa-beat`,e.beat),`fa-fade`,e.fade),`fa-beat-fade`,e.beatFade),Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(t,`fa-flash`,e.flash),`fa-spin-pulse`,e.spinPulse),`fa-spin-reverse`,e.spinReverse),`fa-width-auto`,e.widthAuto),`fa-canvas-square`,e.canvasSquare),`fa-canvas-roomy`,e.canvasRoomy),`fa-flip-360`,e.flip360),`fa-buzz`,e.buzz),`fa-float`,e.float),`fa-jello`,e.jello),Yh(Yh(Yh(Yh(Yh(t,`fa-spin-snap`,e.spinSnap),`fa-spin-snap-4`,e.spinSnap4),`fa-spin-snap-8`,e.spinSnap8),`fa-swing`,e.swing),`fa-wag`,e.wag));return Object.keys(n).map(function(e){return n[e]?e:null}).filter(function(e){return e})}var lg=typeof globalThis<`u`?globalThis:typeof window<`u`?window:typeof global<`u`?global:typeof self<`u`?self:{},ug={exports:{}};(function(e){(function(t){var n=function(e,t,r){if(!l(t)||d(t)||f(t)||p(t)||c(t))return t;var i,a=0,o=0;if(u(t))for(i=[],o=t.length;a<o;a++)i.push(n(e,t[a],r));else for(var s in i={},t)Object.prototype.hasOwnProperty.call(t,s)&&(i[e(s,r)]=n(e,t[s],r));return i},r=function(e,t){t||={};var n=t.separator||`_`,r=t.split||/(?=[A-Z])/;return e.split(r).join(n)},i=function(e){return m(e)?e:(e=e.replace(/[\-_\s]+(.)?/g,function(e,t){return t?t.toUpperCase():``}),e.substr(0,1).toLowerCase()+e.substr(1))},a=function(e){var t=i(e);return t.substr(0,1).toUpperCase()+t.substr(1)},o=function(e,t){return r(e,t).toLowerCase()},s=Object.prototype.toString,c=function(e){return typeof e==`function`},l=function(e){return e===Object(e)},u=function(e){return s.call(e)==`[object Array]`},d=function(e){return s.call(e)==`[object Date]`},f=function(e){return s.call(e)==`[object RegExp]`},p=function(e){return s.call(e)==`[object Boolean]`},m=function(e){return e-=0,e===e},h=function(e,t){var n=t&&`process`in t?t.process:t;return typeof n==`function`?function(t,r){return n(t,e,r)}:e},g={camelize:i,decamelize:o,pascalize:a,depascalize:o,camelizeKeys:function(e,t){return n(h(i,t),e)},decamelizeKeys:function(e,t){return n(h(o,t),e,t)},pascalizeKeys:function(e,t){return n(h(a,t),e)},depascalizeKeys:function(){return this.decamelizeKeys.apply(this,arguments)}};e.exports?e.exports=g:t.humps=g})(lg)})(ug);var dg=ug.exports,fg=[`gradientFill`],pg=[`class`,`style`],mg=[`type`,`stops`,`id`];function hg(e){return e.split(`;`).map(function(e){return e.trim()}).filter(function(e){return e}).reduce(function(e,t){var n=t.indexOf(`:`),r=dg.camelize(t.slice(0,n));return e[r]=t.slice(n+1).trim(),e},{})}function gg(e){return e.split(/\s+/).reduce(function(e,t){return e[t]=!0,e},{})}function _g(e,t){return G(`stop`,$h({key:`${t}-${e.offset}`,offset:e.offset,"stop-color":e.color},e.opacity!==void 0&&{"stop-opacity":e.opacity}))}function vg(e){if(typeof e==`string`)return e;var t=(e.children||[]).map(vg);return e.tag===`path`&&e.attributes&&`fill`in e.attributes?$h($h({},e),{},{attributes:$h($h({},e.attributes),{},{fill:void 0}),children:t}):$h($h({},e),{},{children:t})}function yg(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{};if(typeof e==`string`)return e;var r=t.gradientFill,i=r===void 0?null:r,a=eg(t,fg),o=i||`fill`in n?vg(e):e,s=(o.children||[]).map(function(e){return yg(e,{},{})}),c=Object.keys(o.attributes||{}).reduce(function(e,t){var n=o.attributes[t];switch(t){case`class`:e.class=gg(n);break;case`style`:e.style=hg(n);break;default:e.attrs[t]=n}return e},{attrs:{},class:{},style:{}});n.class;var l=n.style,u=l===void 0?{}:l,d=eg(n,pg);if(i&&i.id&&(i.type===`linear`||i.type===`radial`)){var f=i.type,p=i.stops,m=p===void 0?[]:p,h=i.id,g=eg(i,mg),_=G(f===`linear`?`linearGradient`:`radialGradient`,$h($h({},g),{},{id:h}),m.map(_g));return G(o.tag,$h($h($h($h({},a),{},{class:c.class,style:$h($h({},c.style),u)},c.attrs),d),{},{fill:`url(#${h})`}),[_].concat(ng(s)))}return G(e.tag,$h($h($h({},a),{},{class:c.class,style:$h($h({},c.style),u)},c.attrs),d),s)}var bg=!1;try{bg=!0}catch{}function xg(){if(!bg&&console&&typeof console.error==`function`){var e;(e=console).error.apply(e,arguments)}}function Sg(e){if(e&&ag(e)===`object`&&e.prefix&&e.iconName&&e.icon)return e;if(Gh.icon)return Gh.icon(e);if(e===null)return null;if(ag(e)===`object`&&e.prefix&&e.iconName)return e;if(Array.isArray(e)&&e.length===2)return{prefix:e[0],iconName:e[1]};if(typeof e==`string`)return{prefix:`fas`,iconName:e}}var Cg=F({name:`FontAwesomeIcon`,props:{border:{type:Boolean,default:!1},fixedWidth:{type:Boolean,default:!1},flip:{type:[Boolean,String],default:!1,validator:function(e){return[!0,!1,`horizontal`,`vertical`,`both`].indexOf(e)>-1}},icon:{type:[Object,Array,String],required:!0},mask:{type:[Object,Array,String],default:null},maskId:{type:String,default:null},listItem:{type:Boolean,default:!1},pull:{type:String,default:null,validator:function(e){return[`right`,`left`].indexOf(e)>-1}},pulse:{type:Boolean,default:!1},rotation:{type:[String,Number],default:null,validator:function(e){return[90,180,270].indexOf(Number.parseInt(e,10))>-1}},rotateBy:{type:Boolean,default:!1},swapOpacity:{type:Boolean,default:!1},size:{type:String,default:null,validator:function(e){return[`2xs`,`xs`,`sm`,`lg`,`xl`,`2xl`,`1x`,`2x`,`3x`,`4x`,`5x`,`6x`,`7x`,`8x`,`9x`,`10x`].indexOf(e)>-1}},spin:{type:Boolean,default:!1},transform:{type:[String,Object],default:null},symbol:{type:[Boolean,String],default:!1},title:{type:String,default:null},titleId:{type:String,default:null},inverse:{type:Boolean,default:!1},bounce:{type:Boolean,default:!1},shake:{type:Boolean,default:!1},beat:{type:Boolean,default:!1},fade:{type:Boolean,default:!1},beatFade:{type:Boolean,default:!1},flash:{type:Boolean,default:!1},spinPulse:{type:Boolean,default:!1},spinReverse:{type:Boolean,default:!1},widthAuto:{type:Boolean,default:!1},canvasSquare:{type:Boolean,default:!1},canvasRoomy:{type:Boolean,default:!1},gradientFill:{type:Object,default:null,validator:function(e){return typeof e.id!=`string`||!e.id?(console.warn(`FontAwesomeIcon: gradientFill.id must be a non-empty string`),!1):e.type!==`linear`&&e.type!==`radial`?(console.warn(`FontAwesomeIcon: gradientFill.type must be "linear" or "radial"`),!1):!0}},flip360:{type:Boolean,default:!1},buzz:{type:Boolean,default:!1},float:{type:Boolean,default:!1},jello:{type:Boolean,default:!1},spinSnap:{type:Boolean,default:!1},spinSnap4:{type:Boolean,default:!1},spinSnap8:{type:Boolean,default:!1},swing:{type:Boolean,default:!1},wag:{type:Boolean,default:!1}},setup:function(e,t){var n=t.attrs,r=W(function(){return Sg(e.icon)}),i=W(function(){return sg(`classes`,cg(e))}),a=W(function(){return sg(`transform`,typeof e.transform==`string`?Gh.transform(e.transform):e.transform)}),o=W(function(){return sg(`mask`,Sg(e.mask))}),s=W(function(){var t=$h($h($h($h({},i.value),a.value),o.value),{},{symbol:e.symbol,maskId:e.maskId});return t.title=e.title,t.titleId=e.titleId,Kh(r.value,t)});Er(s,function(e){if(!e)return xg(`Could not find one or more icon(s)`,r.value,o.value)},{immediate:!0}),e.gradientFill&&e.symbol&&xg(`gradientFill is not supported when symbol is true and will be ignored`);var c=W(function(){return s.value?yg(s.value.abstract[0],{gradientFill:e.symbol?null:e.gradientFill},n):null});return function(){return c.value}}}),wg=typeof window<`u`,Tg,Eg=e=>Tg=e,Dg=Symbol();function Og(e){return e&&typeof e==`object`&&Object.prototype.toString.call(e)===`[object Object]`&&typeof e.toJSON!=`function`}var kg=typeof window==`object`&&window.window===window?window:typeof self==`object`&&self.self===self?self:typeof global==`object`&&global.global===global?global:typeof globalThis==`object`?globalThis:{HTMLElement:null};function Ag(e,{autoBom:t=!1}={}){return t&&/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(e.type)?new Blob([`﻿`,e],{type:e.type}):e}function jg(e,t,n){let r=new XMLHttpRequest;r.open(`GET`,e),r.responseType=`blob`,r.onload=function(){Ig(r.response,t,n)},r.onerror=function(){console.error(`could not download file`)},r.send()}function Mg(e){let t=new XMLHttpRequest;t.open(`HEAD`,e,!1);try{t.send()}catch{}return t.status>=200&&t.status<=299}function Ng(e){try{e.dispatchEvent(new MouseEvent(`click`))}catch{let t=new MouseEvent(`click`,{bubbles:!0,cancelable:!0,view:window,detail:0,screenX:80,screenY:20,clientX:80,clientY:20,ctrlKey:!1,altKey:!1,shiftKey:!1,metaKey:!1,button:0,relatedTarget:null});e.dispatchEvent(t)}}var Pg=typeof navigator==`object`?navigator:{userAgent:``},Fg=/Macintosh/.test(Pg.userAgent)&&/AppleWebKit/.test(Pg.userAgent)&&!/Safari/.test(Pg.userAgent),Ig=wg?typeof HTMLAnchorElement<`u`&&`download`in HTMLAnchorElement.prototype&&!Fg?Lg:`msSaveOrOpenBlob`in Pg?Rg:zg:()=>{};function Lg(e,t=`download`,n){let r=document.createElement(`a`);r.download=t,r.rel=`noopener`,typeof e==`string`?(r.href=e,r.origin===location.origin?Ng(r):Mg(r.href)?jg(e,t,n):(r.target=`_blank`,Ng(r))):(r.href=URL.createObjectURL(e),setTimeout(function(){URL.revokeObjectURL(r.href)},4e4),setTimeout(function(){Ng(r)},0))}function Rg(e,t=`download`,n){if(typeof e==`string`){if(Mg(e))jg(e,t,n);else{let t=document.createElement(`a`);t.href=e,t.target=`_blank`,setTimeout(function(){Ng(t)})}}else navigator.msSaveOrOpenBlob(Ag(e,n),t)}function zg(e,t,n,r){if(r||=open(``,`_blank`),r&&(r.document.title=r.document.body.innerText=`downloading...`),typeof e==`string`)return jg(e,t,n);let i=e.type===`application/octet-stream`,a=/constructor/i.test(String(kg.HTMLElement))||`safari`in kg,o=/CriOS\/[\d]+/.test(navigator.userAgent);if((o||i&&a||Fg)&&typeof FileReader<`u`){let t=new FileReader;t.onloadend=function(){let e=t.result;if(typeof e!=`string`)throw r=null,Error(`Wrong reader.result type`);e=o?e:e.replace(/^data:[^;]*;/,`data:attachment/file;`),r?r.location.href=e:location.assign(e),r=null},t.readAsDataURL(e)}else{let t=URL.createObjectURL(e);r?r.location.assign(t):location.href=t,r=null,setTimeout(function(){URL.revokeObjectURL(t)},4e4)}}var{assign:Bg}=Object;function Vg(){let e=Pe(!0),t=e.run(()=>M({})),n=[],r=[],i=sn({install(e){Eg(i),i._a=e,e.provide(Dg,i),e.config.globalProperties.$pinia=i,r.forEach(e=>n.push(e)),r=[]},use(e){return this._a?n.push(e):r.push(e),this},_p:n,_a:null,_e:e,_s:new Map,state:t});return i}var Hg=()=>{};function Ug(e,t,n,r=Hg){e.add(t);let i=()=>{e.delete(t)&&r()};return!n&&Fe()&&Ie(i),i}function Wg(e,...t){e.forEach(e=>{e(...t)})}var Gg=e=>e(),Kg=Symbol(),qg=Symbol();function Jg(e,t){e instanceof Map&&t instanceof Map?t.forEach((t,n)=>e.set(n,t)):e instanceof Set&&t instanceof Set&&t.forEach(e.add,e);for(let n in t){if(!Object.hasOwn(t,n))continue;let r=t[n],i=e[n];e[n]=Og(i)&&Og(r)&&Object.hasOwn(e,n)&&!j(r)&&!nn(r)?Jg(i,r):r}return e}var Yg=Symbol();function Xg(e){return!e||typeof e!=`object`||!Object.hasOwn(e,Yg)}var{assign:Zg}=Object;function Qg(e){return!!(j(e)&&e.effect)}function $g(e,t,n,r){let{state:i,actions:a,getters:o}=t,s=n.state.value[e],c;function l(){return s||(n.state.value[e]=i?i():{}),Zg(yn(n.state.value[e]),a,Object.keys(o||{}).reduce((t,r)=>(t[r]=sn(W(()=>{Eg(n);let t=n._s.get(e);return o[r].call(t,t)})),t),{}))}return c=e_(e,l,t,n,r,!0),c}function e_(e,t,n={},r,i,a){let o,s=Zg({actions:{}},n),c={deep:!0},l,u,d=new Set,f=new Set,p,m=r.state.value[e];!a&&!m&&(r.state.value[e]={});let h;function g(t){let n;l=u=!1,typeof t==`function`?(t(r.state.value[e]),n={type:`patch function`,storeId:e,events:p}):(Jg(r.state.value[e],t),n={type:`patch object`,payload:t,storeId:e,events:p});let i=h=Symbol();Qn().then(()=>{h===i&&(l=!0)}),u=!0,Wg(d,n,r.state.value[e])}let _=a?function(){let{state:e}=n,t=e?e():{};this.$patch(e=>{Zg(e,t)})}:Hg;function v(){o.stop(),d.clear(),f.clear(),r._s.delete(e)}let y=(t,n=``)=>{if(Kg in t)return t[qg]=n,t;let i=function(){Eg(r);let n=Array.from(arguments),a=new Set,o=new Set;function s(e){a.add(e)}function c(e){o.add(e)}Wg(f,{args:n,name:i[qg],store:b,after:s,onError:c});let l;try{l=t.apply(this&&this.$id===e?this:b,n)}catch(e){throw Wg(o,e),e}return l instanceof Promise?l.then(e=>(Wg(a,e),e)).catch(e=>(Wg(o,e),Promise.reject(e))):(Wg(a,l),l)};return i[Kg]=!0,i[qg]=n,i},b=Zt({_p:r,$id:e,$onAction:Ug.bind(null,f),$patch:g,$reset:_,$subscribe(t,n={}){if(d.has(t))return Hg;let i=Ug(d,t,n.detached,()=>a()),a=o.run(()=>Er(()=>r.state.value[e],r=>{(n.flush===`sync`?u:l)&&t({storeId:e,type:`direct`,events:p},r)},Zg({},c,n)));return i},$dispose:v});r._s.set(e,b);let x=(r._a&&r._a.runWithContext||Gg)(()=>r._e.run(()=>(o=Pe()).run(()=>t({action:y}))));for(let t in x){let n=x[t];j(n)&&!Qg(n)||nn(n)?a||(m&&Xg(n)&&(j(n)?n.value=m[t]:((n instanceof Set||n instanceof Map)&&n.clear(),Jg(n,m[t]))),r.state.value[e][t]=n):typeof n==`function`&&(x[t]=y(n,t),s.actions[t]=n)}return Zg(b,x),Zg(A(b),x),Object.defineProperty(b,"$state",{get:()=>r.state.value[e],set:e=>{g(t=>{Zg(t,e)})}}),r._p.forEach(e=>{let t=o.run(()=>e({store:b,app:r._a,pinia:r,options:s}));Zg(b,t)}),m&&a&&n.hydrate&&n.hydrate(b.$state,m),l=!0,u=!0,b}function t_(e,t,n){let r,i=typeof t==`function`;r=i?n:t;function a(n,a){let o=br();return n||=o?yr(Dg,null):null,n&&Eg(n),n=Tg,n._s.has(e)||(i?e_(e,t,r,n):$g(e,r,n)),n._s.get(e)}return a.$id=e,a}var n_={prefix:`fab`,iconName:`github`,icon:[512,512,[],`f09b`,`M216.5 362.5c-66-8-112.5-55.5-112.5-117 0-25 9-52 24-70-6.5-16.5-5.5-51.5 2-66 20-2.5 47 8 63 22.5 19-6 39-9 63.5-9s44.5 3 62.5 8.5c15.5-14 43-24.5 63-22 7 13.5 8 48.5 1.5 65.5 16 19 24.5 44.5 24.5 70.5 0 61.5-46.5 108-113.5 116.5 17 11 28.5 35 28.5 62.5l0 52C323 491.5 335.5 500 350.5 494 441 459.5 512 369 512 257 512 115.5 397 0 255.5 0S0 115.5 0 257c0 111 70.5 203 165.5 237.5 13.5 5 26.5-4 26.5-17.5l0-40c-7 3-16 5-24 5-33 0-52.5-18-66.5-51.5-5.5-13.5-11.5-21.5-23-23-6-.5-8-3-8-6 0-6 10-10.5 20-10.5 14.5 0 27 9 40 27.5 10 14.5 20.5 21 33 21s20.5-4.5 32-16c8.5-8.5 15-16 21-21z`]},r_={prefix:`fas`,iconName:`magnifying-glass`,icon:[512,512,[128269,`search`],`f002`,`M416 208c0 45.9-14.9 88.3-40 122.7L502.6 457.4c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L330.7 376C296.3 401.1 253.9 416 208 416 93.1 416 0 322.9 0 208S93.1 0 208 0 416 93.1 416 208zM208 352a144 144 0 1 0 0-288 144 144 0 1 0 0 288z`]},i_={prefix:`fas`,iconName:`key`,icon:[512,512,[128273],`f084`,`M336 352c97.2 0 176-78.8 176-176S433.2 0 336 0 160 78.8 160 176c0 18.7 2.9 36.8 8.3 53.7L7 391c-4.5 4.5-7 10.6-7 17l0 80c0 13.3 10.7 24 24 24l80 0c13.3 0 24-10.7 24-24l0-40 40 0c13.3 0 24-10.7 24-24l0-40 40 0c6.4 0 12.5-2.5 17-7l33.3-33.3c16.9 5.4 35 8.3 53.7 8.3zM376 96a40 40 0 1 1 0 80 40 40 0 1 1 0-80z`]},a_={prefix:`fas`,iconName:`sort-up`,icon:[384,512,[`sort-asc`],`f0de`,`M32 224c-12.9 0-24.6-7.8-29.6-19.8S.2 178.5 9.4 169.4l160-160c12.5-12.5 32.8-12.5 45.3 0l160 160c9.2 9.2 11.9 22.9 6.9 34.9S364.9 224 352 224L32 224z`]},o_={prefix:`fas`,iconName:`eye`,icon:[576,512,[128065],`f06e`,`M288 32c-80.8 0-145.5 36.8-192.6 80.6-46.8 43.5-78.1 95.4-93 131.1-3.3 7.9-3.3 16.7 0 24.6 14.9 35.7 46.2 87.7 93 131.1 47.1 43.7 111.8 80.6 192.6 80.6s145.5-36.8 192.6-80.6c46.8-43.5 78.1-95.4 93-131.1 3.3-7.9 3.3-16.7 0-24.6-14.9-35.7-46.2-87.7-93-131.1-47.1-43.7-111.8-80.6-192.6-80.6zM144 256a144 144 0 1 1 288 0 144 144 0 1 1 -288 0zm144-64c0 35.3-28.7 64-64 64-11.5 0-22.3-3-31.7-8.4-1 10.9-.1 22.1 2.9 33.2 13.7 51.2 66.4 81.6 117.6 67.9s81.6-66.4 67.9-117.6c-12.2-45.7-55.5-74.8-101.1-70.8 5.3 9.3 8.4 20.1 8.4 31.7z`]},s_={prefix:`fas`,iconName:`chevron-up`,icon:[448,512,[],`f077`,`M201.4 105.4c12.5-12.5 32.8-12.5 45.3 0l192 192c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L224 173.3 54.6 342.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l192-192z`]},c_={prefix:`fas`,iconName:`circle-xmark`,icon:[512,512,[61532,`times-circle`,`xmark-circle`],`f057`,`M256 512a256 256 0 1 0 0-512 256 256 0 1 0 0 512zM167 167c9.4-9.4 24.6-9.4 33.9 0l55 55 55-55c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9l-55 55 55 55c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0l-55-55-55 55c-9.4 9.4-24.6 9.4-33.9 0s-9.4-24.6 0-33.9l55-55-55-55c-9.4-9.4-9.4-24.6 0-33.9z`]},l_={prefix:`fas`,iconName:`circle-exclamation`,icon:[512,512,[`exclamation-circle`],`f06a`,`M256 512a256 256 0 1 1 0-512 256 256 0 1 1 0 512zm0-192a32 32 0 1 0 0 64 32 32 0 1 0 0-64zm0-192c-18.2 0-32.7 15.5-31.4 33.7l7.4 104c.9 12.6 11.4 22.3 23.9 22.3 12.6 0 23-9.7 23.9-22.3l7.4-104c1.3-18.2-13.1-33.7-31.4-33.7z`]},u_={prefix:`fas`,iconName:`check`,icon:[448,512,[10003,10004],`f00c`,`M434.8 70.1c14.3 10.4 17.5 30.4 7.1 44.7l-256 352c-5.5 7.6-14 12.3-23.4 13.1s-18.5-2.7-25.1-9.3l-128-128c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0l101.5 101.5 234-321.7c10.4-14.3 30.4-17.5 44.7-7.1z`]},d_={prefix:`fas`,iconName:`sort`,icon:[384,512,[`unsorted`],`f0dc`,`M2.4 204.2c5 12 16.6 19.8 29.6 19.8l320 0c12.9 0 24.6-7.8 29.6-19.8s2.2-25.7-6.9-34.9l-160-160c-12.5-12.5-32.8-12.5-45.3 0l-160 160c-9.2 9.2-11.9 22.9-6.9 34.9zm0 103.5c-5 12-2.2 25.7 6.9 34.9l160 160c12.5 12.5 32.8 12.5 45.3 0l160-160c9.2-9.2 11.9-22.9 6.9-34.9S364.9 288 352 288L32 288c-12.9 0-24.6 7.8-29.6 19.8z`]},f_={prefix:`fas`,iconName:`xmark`,icon:[384,512,[128473,10005,10006,10060,215,`close`,`multiply`,`remove`,`times`],`f00d`,`M55.1 73.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3L147.2 256 9.9 393.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0L192.5 301.3 329.9 438.6c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L237.8 256 375.1 118.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L192.5 210.7 55.1 73.4z`]},p_={prefix:`fas`,iconName:`circle-check`,icon:[512,512,[61533,`check-circle`],`f058`,`M256 512a256 256 0 1 1 0-512 256 256 0 1 1 0 512zM374 145.7c-10.7-7.8-25.7-5.4-33.5 5.3L221.1 315.2 169 263.1c-9.4-9.4-24.6-9.4-33.9 0s-9.4 24.6 0 33.9l72 72c5 5 11.8 7.5 18.8 7s13.4-4.1 17.5-9.8L379.3 179.2c7.8-10.7 5.4-25.7-5.3-33.5z`]},m_={prefix:`fas`,iconName:`chevron-down`,icon:[448,512,[],`f078`,`M201.4 406.6c12.5 12.5 32.8 12.5 45.3 0l192-192c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 338.7 54.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l192 192z`]},h_={prefix:`fas`,iconName:`triangle-exclamation`,icon:[512,512,[9888,`exclamation-triangle`,`warning`],`f071`,`M256 0c14.7 0 28.2 8.1 35.2 21l216 400c6.7 12.4 6.4 27.4-.8 39.5S486.1 480 472 480L40 480c-14.1 0-27.2-7.4-34.4-19.5s-7.5-27.1-.8-39.5l216-400c7-12.9 20.5-21 35.2-21zm0 352a32 32 0 1 0 0 64 32 32 0 1 0 0-64zm0-192c-18.2 0-32.7 15.5-31.4 33.7l7.4 104c.9 12.5 11.4 22.3 23.9 22.3 12.6 0 23-9.7 23.9-22.3l7.4-104c1.3-18.2-13.1-33.7-31.4-33.7z`]},g_={prefix:`fas`,iconName:`copy`,icon:[448,512,[],`f0c5`,`M192 0c-35.3 0-64 28.7-64 64l0 256c0 35.3 28.7 64 64 64l192 0c35.3 0 64-28.7 64-64l0-200.6c0-17.4-7.1-34.1-19.7-46.2L370.6 17.8C358.7 6.4 342.8 0 326.3 0L192 0zM64 128c-35.3 0-64 28.7-64 64L0 448c0 35.3 28.7 64 64 64l192 0c35.3 0 64-28.7 64-64l0-16-64 0 0 16-192 0 0-256 16 0 0-64-16 0z`]},__={prefix:`fas`,iconName:`eye-slash`,icon:[576,512,[],`f070`,`M41-24.9c-9.4-9.4-24.6-9.4-33.9 0S-2.3-.3 7 9.1l528 528c9.4 9.4 24.6 9.4 33.9 0s9.4-24.6 0-33.9l-96.4-96.4c2.7-2.4 5.4-4.8 8-7.2 46.8-43.5 78.1-95.4 93-131.1 3.3-7.9 3.3-16.7 0-24.6-14.9-35.7-46.2-87.7-93-131.1-47.1-43.7-111.8-80.6-192.6-80.6-56.8 0-105.6 18.2-146 44.2L41-24.9zM204.5 138.7c23.5-16.8 52.4-26.7 83.5-26.7 79.5 0 144 64.5 144 144 0 31.1-9.9 59.9-26.7 83.5l-34.7-34.7c12.7-21.4 17-47.7 10.1-73.7-13.7-51.2-66.4-81.6-117.6-67.9-8.6 2.3-16.7 5.7-24 10l-34.7-34.7zM325.3 395.1c-11.9 3.2-24.4 4.9-37.3 4.9-79.5 0-144-64.5-144-144 0-12.9 1.7-25.4 4.9-37.3L69.4 139.2c-32.6 36.8-55 75.8-66.9 104.5-3.3 7.9-3.3 16.7 0 24.6 14.9 35.7 46.2 87.7 93 131.1 47.1 43.7 111.8 80.6 192.6 80.6 37.3 0 71.2-7.9 101.5-20.6l-64.2-64.2z`]},v_={prefix:`fas`,iconName:`sort-down`,icon:[384,512,[`sort-desc`],`f0dd`,`M32 288c-12.9 0-24.6 7.8-29.6 19.8S.2 333.5 9.4 342.6l160 160c12.5 12.5 32.8 12.5 45.3 0l160-160c9.2-9.2 11.9-22.9 6.9-34.9S364.9 288 352 288L32 288z`]};function y_(e){var t,n,r=``;if(typeof e==`string`||typeof e==`number`)r+=e;else if(typeof e==`object`){if(Array.isArray(e)){var i=e.length;for(t=0;t<i;t++)e[t]&&(n=y_(e[t]))&&(r&&(r+=` `),r+=n)}else for(n in e)e[n]&&(r&&(r+=` `),r+=n)}return r}function b_(){for(var e,t,n=0,r=``,i=arguments.length;n<i;n++)(e=arguments[n])&&(t=y_(e))&&(r&&(r+=` `),r+=t);return r}var x_=e=>typeof e==`boolean`?`${e}`:e===0?`0`:e,S_=b_,C_=(e,t)=>n=>{if(t?.variants==null)return S_(e,n?.class,n?.className);let{variants:r,defaultVariants:i}=t,a=Object.keys(r).map(e=>{let t=n?.[e],a=i?.[e];if(t===null)return null;let o=x_(t)||x_(a);return r[e][o]}),o=n&&Object.entries(n).reduce((e,t)=>{let[n,r]=t;return r===void 0||(e[n]=r),e},{});return S_(e,a,t?.compoundVariants?.reduce((e,t)=>{let{class:n,className:r,...a}=t;return Object.entries(a).every(e=>{let[t,n]=e;return Array.isArray(n)?n.includes({...i,...o}[t]):{...i,...o}[t]===n})?[...e,n,r]:e},[]),n?.class,n?.className)},w_=(e,t)=>{let n=Array(e.length+t.length);for(let t=0;t<e.length;t++)n[t]=e[t];for(let r=0;r<t.length;r++)n[e.length+r]=t[r];return n},T_=(e,t)=>({classGroupId:e,validator:t}),E_=(e=new Map,t=null,n)=>({nextPart:e,validators:t,classGroupId:n}),D_=`-`,O_=[],k_=`arbitrary..`,A_=e=>{let t=N_(e),{conflictingClassGroups:n,conflictingClassGroupModifiers:r}=e;return{getClassGroupId:e=>{if(e.startsWith(`[`)&&e.endsWith(`]`))return M_(e);let n=e.split(D_);return j_(n,+(n[0]===``&&n.length>1),t)},getConflictingClassGroupIds:(e,t)=>{if(t){let t=r[e],i=n[e];return t?i?w_(i,t):t:i||O_}return n[e]||O_}}},j_=(e,t,n)=>{if(e.length-t===0)return n.classGroupId;let r=e[t],i=n.nextPart.get(r);if(i){let n=j_(e,t+1,i);if(n)return n}let a=n.validators;if(a===null)return;let o=t===0?e.join(D_):e.slice(t).join(D_),s=a.length;for(let e=0;e<s;e++){let t=a[e];if(t.validator(o))return t.classGroupId}},M_=e=>e.slice(1,-1).indexOf(`:`)===-1?void 0:(()=>{let t=e.slice(1,-1),n=t.indexOf(`:`),r=t.slice(0,n);return r?k_+r:void 0})(),N_=e=>{let{theme:t,classGroups:n}=e;return P_(n,t)},P_=(e,t)=>{let n=E_();for(let r in e){let i=e[r];F_(i,n,r,t)}return n},F_=(e,t,n,r)=>{let i=e.length;for(let a=0;a<i;a++){let i=e[a];I_(i,t,n,r)}},I_=(e,t,n,r)=>{if(typeof e==`string`){L_(e,t,n);return}if(typeof e==`function`){R_(e,t,n,r);return}z_(e,t,n,r)},L_=(e,t,n)=>{let r=e===``?t:B_(t,e);r.classGroupId=n},R_=(e,t,n,r)=>{if(V_(e)){F_(e(r),t,n,r);return}t.validators===null&&(t.validators=[]),t.validators.push(T_(n,e))},z_=(e,t,n,r)=>{let i=Object.entries(e),a=i.length;for(let e=0;e<a;e++){let[a,o]=i[e];F_(o,B_(t,a),n,r)}},B_=(e,t)=>{let n=e,r=t.split(D_),i=r.length;for(let e=0;e<i;e++){let t=r[e],i=n.nextPart.get(t);i||(i=E_(),n.nextPart.set(t,i)),n=i}return n},V_=e=>`isThemeGetter`in e&&e.isThemeGetter===!0,H_=e=>{if(e<1)return{get:()=>void 0,set:()=>{}};let t=0,n=Object.create(null),r=Object.create(null),i=(i,a)=>{n[i]=a,t++,t>e&&(t=0,r=n,n=Object.create(null))};return{get(e){let t=n[e];if(t!==void 0)return t;if((t=r[e])!==void 0)return i(e,t),t},set(e,t){e in n?n[e]=t:i(e,t)}}},U_=`!`,W_=`:`,G_=[],K_=(e,t,n,r,i)=>({modifiers:e,hasImportantModifier:t,baseClassName:n,maybePostfixModifierPosition:r,isExternal:i}),q_=e=>{let{prefix:t,experimentalParseClassName:n}=e,r=e=>{let t=[],n=0,r=0,i=0,a,o=e.length;for(let s=0;s<o;s++){let o=e[s];if(n===0&&r===0){if(o===W_){t.push(e.slice(i,s)),i=s+1;continue}if(o===`/`){a=s;continue}}o===`[`?n++:o===`]`?n--:o===`(`?r++:o===`)`&&r--}let s=t.length===0?e:e.slice(i),c=s,l=!1;s.endsWith(U_)?(c=s.slice(0,-1),l=!0):s.startsWith(U_)&&(c=s.slice(1),l=!0);let u=a&&a>i?a-i:void 0;return K_(t,l,c,u)};if(t){let e=t+W_,n=r;r=t=>t.startsWith(e)?n(t.slice(e.length)):K_(G_,!1,t,void 0,!0)}if(n){let e=r;r=t=>n({className:t,parseClassName:e})}return r},J_=e=>{let t=new Map;return e.orderSensitiveModifiers.forEach((e,n)=>{t.set(e,1e6+n)}),e=>{let n=[],r=[];for(let i=0;i<e.length;i++){let a=e[i],o=a[0]===`[`,s=t.has(a);o||s?(r.length>0&&(r.sort(),n.push(...r),r=[]),n.push(a)):r.push(a)}return r.length>0&&(r.sort(),n.push(...r)),n}},Y_=e=>({cache:H_(e.cacheSize),parseClassName:q_(e),sortModifiers:J_(e),postfixLookupClassGroupIds:X_(e),...A_(e)}),X_=e=>{let t=Object.create(null),n=e.postfixLookupClassGroups;if(n)for(let e=0;e<n.length;e++)t[n[e]]=!0;return t},Z_=/\s+/,Q_=(e,t)=>{let{parseClassName:n,getClassGroupId:r,getConflictingClassGroupIds:i,sortModifiers:a,postfixLookupClassGroupIds:o}=t,s=[],c=e.trim().split(Z_),l=``;for(let e=c.length-1;e>=0;--e){let t=c[e],{isExternal:u,modifiers:d,hasImportantModifier:f,baseClassName:p,maybePostfixModifierPosition:m}=n(t);if(u){l=t+(l.length>0?` `+l:l);continue}let h=!!m,g;if(h){g=r(p.substring(0,m));let e=g&&o[g]?r(p):void 0;e&&e!==g&&(g=e,h=!1)}else g=r(p);if(!g){if(!h){l=t+(l.length>0?` `+l:l);continue}if(g=r(p),!g){l=t+(l.length>0?` `+l:l);continue}h=!1}let _=d.length===0?``:d.length===1?d[0]:a(d).join(`:`),v=f?_+U_:_,y=v+g;if(s.indexOf(y)>-1)continue;s.push(y);let b=i(g,h);for(let e=0;e<b.length;++e){let t=b[e];s.push(v+t)}l=t+(l.length>0?` `+l:l)}return l},$_=(...e)=>{let t=0,n,r,i=``;for(;t<e.length;)(n=e[t++])&&(r=ev(n))&&(i&&(i+=` `),i+=r);return i},ev=e=>{if(typeof e==`string`)return e;let t,n=``;for(let r=0;r<e.length;r++)e[r]&&(t=ev(e[r]))&&(n&&(n+=` `),n+=t);return n},tv=(e,...t)=>{let n,r,i,a,o=o=>(n=Y_(t.reduce((e,t)=>t(e),e())),r=n.cache.get,i=n.cache.set,a=s,s(o)),s=e=>{let t=r(e);if(t)return t;let a=Q_(e,n);return i(e,a),a};return a=o,(...e)=>a($_(...e))},nv=[],rv=e=>{let t=t=>t[e]||nv;return t.isThemeGetter=!0,t},iv=/^\[(?:(\w[\w-]*):)?(.+)\]$/i,av=/^\((?:(\w[\w-]*):)?(.+)\)$/i,ov=/^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/,sv=/^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/,cv=/\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/,lv=/^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/,uv=/^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/,dv=/^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/,fv=e=>ov.test(e),Y=e=>!!e&&!Number.isNaN(Number(e)),pv=e=>!!e&&Number.isInteger(Number(e)),mv=e=>e.endsWith(`%`)&&Y(e.slice(0,-1)),hv=e=>sv.test(e),gv=()=>!0,_v=e=>cv.test(e)&&!lv.test(e),vv=()=>!1,yv=e=>uv.test(e),bv=e=>dv.test(e),xv=e=>!X(e)&&!Z(e),Sv=e=>e.startsWith(`@container`)&&(e[10]===`/`&&e[11]!==void 0||e[11]===`s`&&e[16]!==void 0&&e.startsWith(`-size/`,10)||e[11]===`n`&&e[18]!==void 0&&e.startsWith(`-normal/`,10)),Cv=e=>Rv(e,Hv,vv),X=e=>iv.test(e),wv=e=>Rv(e,Uv,_v),Tv=e=>Rv(e,Wv,Y),Ev=e=>Rv(e,Kv,gv),Dv=e=>Rv(e,Gv,vv),Ov=e=>Rv(e,Bv,vv),kv=e=>Rv(e,Vv,bv),Av=e=>Rv(e,qv,yv),Z=e=>av.test(e),jv=e=>zv(e,Uv),Mv=e=>zv(e,Gv),Nv=e=>zv(e,Bv),Pv=e=>zv(e,Hv),Fv=e=>zv(e,Vv),Iv=e=>zv(e,qv,!0),Lv=e=>zv(e,Kv,!0),Rv=(e,t,n)=>{let r=iv.exec(e);return r?r[1]?t(r[1]):n(r[2]):!1},zv=(e,t,n=!1)=>{let r=av.exec(e);return r?r[1]?t(r[1]):n:!1},Bv=e=>e===`position`||e===`percentage`,Vv=e=>e===`image`||e===`url`,Hv=e=>e===`length`||e===`size`||e===`bg-size`,Uv=e=>e===`length`,Wv=e=>e===`number`,Gv=e=>e===`family-name`,Kv=e=>e===`number`||e===`weight`,qv=e=>e===`shadow`,Jv=tv(()=>{let e=rv(`color`),t=rv(`font`),n=rv(`text`),r=rv(`font-weight`),i=rv(`tracking`),a=rv(`leading`),o=rv(`breakpoint`),s=rv(`container`),c=rv(`spacing`),l=rv(`radius`),u=rv(`shadow`),d=rv(`inset-shadow`),f=rv(`text-shadow`),p=rv(`drop-shadow`),m=rv(`blur`),h=rv(`perspective`),g=rv(`aspect`),_=rv(`ease`),v=rv(`animate`),y=()=>[`auto`,`avoid`,`all`,`avoid-page`,`page`,`left`,`right`,`column`],b=()=>[`center`,`top`,`bottom`,`left`,`right`,`top-left`,`left-top`,`top-right`,`right-top`,`bottom-right`,`right-bottom`,`bottom-left`,`left-bottom`],x=()=>[...b(),Z,X],S=()=>[`auto`,`hidden`,`clip`,`visible`,`scroll`],C=()=>[`auto`,`contain`,`none`],w=()=>[Z,X,c],ee=()=>[fv,`full`,`auto`,...w()],te=()=>[pv,`none`,`subgrid`,Z,X],T=()=>[`auto`,{span:[`full`,pv,Z,X]},pv,Z,X],ne=()=>[pv,`auto`,Z,X],re=()=>[`auto`,`min`,`max`,`fr`,Z,X],ie=()=>[`start`,`end`,`center`,`between`,`around`,`evenly`,`stretch`,`baseline`,`center-safe`,`end-safe`],E=()=>[`start`,`end`,`center`,`stretch`,`center-safe`,`end-safe`],ae=()=>[`auto`,...w()],oe=()=>[fv,`auto`,`full`,`dvw`,`dvh`,`lvw`,`lvh`,`svw`,`svh`,`min`,`max`,`fit`,...w()],se=()=>[fv,`screen`,`full`,`dvw`,`lvw`,`svw`,`min`,`max`,`fit`,...w()],ce=()=>[fv,`screen`,`full`,`lh`,`dvh`,`lvh`,`svh`,`min`,`max`,`fit`,...w()],D=()=>[e,Z,X],le=()=>[...b(),Nv,Ov,{position:[Z,X]}],ue=()=>[`no-repeat`,{repeat:[``,`x`,`y`,`space`,`round`]}],de=()=>[`auto`,`cover`,`contain`,Pv,Cv,{size:[Z,X]}],fe=()=>[mv,jv,wv],pe=()=>[``,`none`,`full`,l,Z,X],me=()=>[``,Y,jv,wv],he=()=>[`solid`,`dashed`,`dotted`,`double`],ge=()=>[`normal`,`multiply`,`screen`,`overlay`,`darken`,`lighten`,`color-dodge`,`color-burn`,`hard-light`,`soft-light`,`difference`,`exclusion`,`hue`,`saturation`,`color`,`luminosity`],_e=()=>[Y,mv,Nv,Ov],ve=()=>[``,`none`,m,Z,X],ye=()=>[`none`,Y,Z,X],be=()=>[`none`,Y,Z,X],O=()=>[Y,Z,X],xe=()=>[fv,`full`,...w()];return{cacheSize:500,theme:{animate:[`spin`,`ping`,`pulse`,`bounce`],aspect:[`video`],blur:[hv],breakpoint:[hv],color:[gv],container:[hv],"drop-shadow":[hv],ease:[`in`,`out`,`in-out`],font:[xv],"font-weight":[`thin`,`extralight`,`light`,`normal`,`medium`,`semibold`,`bold`,`extrabold`,`black`],"inset-shadow":[hv],leading:[`none`,`tight`,`snug`,`normal`,`relaxed`,`loose`],perspective:[`dramatic`,`near`,`normal`,`midrange`,`distant`,`none`],radius:[hv],shadow:[hv],spacing:[`px`,Y],text:[hv],"text-shadow":[hv],tracking:[`tighter`,`tight`,`normal`,`wide`,`wider`,`widest`]},classGroups:{aspect:[{aspect:[`auto`,`square`,fv,X,Z,g]}],container:[`container`],"container-type":[{"@container":[``,`normal`,`size`,Z,X]}],"container-named":[Sv],columns:[{columns:[Y,X,Z,s]}],"break-after":[{"break-after":y()}],"break-before":[{"break-before":y()}],"break-inside":[{"break-inside":[`auto`,`avoid`,`avoid-page`,`avoid-column`]}],"box-decoration":[{"box-decoration":[`slice`,`clone`]}],box:[{box:[`border`,`content`]}],display:[`block`,`inline-block`,`inline`,`flex`,`inline-flex`,`table`,`inline-table`,`table-caption`,`table-cell`,`table-column`,`table-column-group`,`table-footer-group`,`table-header-group`,`table-row-group`,`table-row`,`flow-root`,`grid`,`inline-grid`,`contents`,`list-item`,`hidden`],sr:[`sr-only`,`not-sr-only`],float:[{float:[`right`,`left`,`none`,`start`,`end`]}],clear:[{clear:[`left`,`right`,`both`,`none`,`start`,`end`]}],isolation:[`isolate`,`isolation-auto`],"object-fit":[{object:[`contain`,`cover`,`fill`,`none`,`scale-down`]}],"object-position":[{object:x()}],overflow:[{overflow:S()}],"overflow-x":[{"overflow-x":S()}],"overflow-y":[{"overflow-y":S()}],overscroll:[{overscroll:C()}],"overscroll-x":[{"overscroll-x":C()}],"overscroll-y":[{"overscroll-y":C()}],position:[`static`,`fixed`,`absolute`,`relative`,`sticky`],inset:[{inset:ee()}],"inset-x":[{"inset-x":ee()}],"inset-y":[{"inset-y":ee()}],start:[{"inset-s":ee(),start:ee()}],end:[{"inset-e":ee(),end:ee()}],"inset-bs":[{"inset-bs":ee()}],"inset-be":[{"inset-be":ee()}],top:[{top:ee()}],right:[{right:ee()}],bottom:[{bottom:ee()}],left:[{left:ee()}],visibility:[`visible`,`invisible`,`collapse`],z:[{z:[pv,`auto`,Z,X]}],basis:[{basis:[fv,`full`,`auto`,s,...w()]}],"flex-direction":[{flex:[`row`,`row-reverse`,`col`,`col-reverse`]}],"flex-wrap":[{flex:[`nowrap`,`wrap`,`wrap-reverse`]}],flex:[{flex:[Y,fv,`auto`,`initial`,`none`,X]}],grow:[{grow:[``,Y,Z,X]}],shrink:[{shrink:[``,Y,Z,X]}],order:[{order:[pv,`first`,`last`,`none`,Z,X]}],"grid-cols":[{"grid-cols":te()}],"col-start-end":[{col:T()}],"col-start":[{"col-start":ne()}],"col-end":[{"col-end":ne()}],"grid-rows":[{"grid-rows":te()}],"row-start-end":[{row:T()}],"row-start":[{"row-start":ne()}],"row-end":[{"row-end":ne()}],"grid-flow":[{"grid-flow":[`row`,`col`,`dense`,`row-dense`,`col-dense`]}],"auto-cols":[{"auto-cols":re()}],"auto-rows":[{"auto-rows":re()}],gap:[{gap:w()}],"gap-x":[{"gap-x":w()}],"gap-y":[{"gap-y":w()}],"justify-content":[{justify:[...ie(),`normal`]}],"justify-items":[{"justify-items":[...E(),`normal`]}],"justify-self":[{"justify-self":[`auto`,...E()]}],"align-content":[{content:[`normal`,...ie()]}],"align-items":[{items:[...E(),{baseline:[``,`last`]}]}],"align-self":[{self:[`auto`,...E(),{baseline:[``,`last`]}]}],"place-content":[{"place-content":ie()}],"place-items":[{"place-items":[...E(),`baseline`]}],"place-self":[{"place-self":[`auto`,...E()]}],p:[{p:w()}],px:[{px:w()}],py:[{py:w()}],ps:[{ps:w()}],pe:[{pe:w()}],pbs:[{pbs:w()}],pbe:[{pbe:w()}],pt:[{pt:w()}],pr:[{pr:w()}],pb:[{pb:w()}],pl:[{pl:w()}],m:[{m:ae()}],mx:[{mx:ae()}],my:[{my:ae()}],ms:[{ms:ae()}],me:[{me:ae()}],mbs:[{mbs:ae()}],mbe:[{mbe:ae()}],mt:[{mt:ae()}],mr:[{mr:ae()}],mb:[{mb:ae()}],ml:[{ml:ae()}],"space-x":[{"space-x":w()}],"space-x-reverse":[`space-x-reverse`],"space-y":[{"space-y":w()}],"space-y-reverse":[`space-y-reverse`],size:[{size:oe()}],"inline-size":[{inline:[`auto`,...se()]}],"min-inline-size":[{"min-inline":[`auto`,...se()]}],"max-inline-size":[{"max-inline":[`none`,...se()]}],"block-size":[{block:[`auto`,...ce()]}],"min-block-size":[{"min-block":[`auto`,...ce()]}],"max-block-size":[{"max-block":[`none`,...ce()]}],w:[{w:[s,`screen`,...oe()]}],"min-w":[{"min-w":[s,`screen`,`none`,...oe()]}],"max-w":[{"max-w":[s,`screen`,`none`,`prose`,{screen:[o]},...oe()]}],h:[{h:[`screen`,`lh`,...oe()]}],"min-h":[{"min-h":[`screen`,`lh`,`none`,...oe()]}],"max-h":[{"max-h":[`screen`,`lh`,...oe()]}],"font-size":[{text:[`base`,n,jv,wv]}],"font-smoothing":[`antialiased`,`subpixel-antialiased`],"font-style":[`italic`,`not-italic`],"font-weight":[{font:[r,Lv,Ev]}],"font-stretch":[{"font-stretch":[`ultra-condensed`,`extra-condensed`,`condensed`,`semi-condensed`,`normal`,`semi-expanded`,`expanded`,`extra-expanded`,`ultra-expanded`,mv,X]}],"font-family":[{font:[Mv,Dv,t]}],"font-features":[{"font-features":[X]}],"fvn-normal":[`normal-nums`],"fvn-ordinal":[`ordinal`],"fvn-slashed-zero":[`slashed-zero`],"fvn-figure":[`lining-nums`,`oldstyle-nums`],"fvn-spacing":[`proportional-nums`,`tabular-nums`],"fvn-fraction":[`diagonal-fractions`,`stacked-fractions`],tracking:[{tracking:[i,Z,X]}],"line-clamp":[{"line-clamp":[Y,`none`,Z,Tv]}],leading:[{leading:[a,...w()]}],"list-image":[{"list-image":[`none`,Z,X]}],"list-style-position":[{list:[`inside`,`outside`]}],"list-style-type":[{list:[`disc`,`decimal`,`none`,Z,X]}],"text-alignment":[{text:[`left`,`center`,`right`,`justify`,`start`,`end`]}],"placeholder-color":[{placeholder:D()}],"text-color":[{text:D()}],"text-decoration":[`underline`,`overline`,`line-through`,`no-underline`],"text-decoration-style":[{decoration:[...he(),`wavy`]}],"text-decoration-thickness":[{decoration:[Y,`from-font`,`auto`,Z,wv]}],"text-decoration-color":[{decoration:D()}],"underline-offset":[{"underline-offset":[Y,`auto`,Z,X]}],"text-transform":[`uppercase`,`lowercase`,`capitalize`,`normal-case`],"text-overflow":[`truncate`,`text-ellipsis`,`text-clip`],"text-wrap":[{text:[`wrap`,`nowrap`,`balance`,`pretty`]}],indent:[{indent:w()}],"tab-size":[{tab:[pv,Z,X]}],"vertical-align":[{align:[`baseline`,`top`,`middle`,`bottom`,`text-top`,`text-bottom`,`sub`,`super`,Z,X]}],whitespace:[{whitespace:[`normal`,`nowrap`,`pre`,`pre-line`,`pre-wrap`,`break-spaces`]}],break:[{break:[`normal`,`words`,`all`,`keep`]}],wrap:[{wrap:[`break-word`,`anywhere`,`normal`]}],hyphens:[{hyphens:[`none`,`manual`,`auto`]}],content:[{content:[`none`,Z,X]}],"bg-attachment":[{bg:[`fixed`,`local`,`scroll`]}],"bg-clip":[{"bg-clip":[`border`,`padding`,`content`,`text`]}],"bg-origin":[{"bg-origin":[`border`,`padding`,`content`]}],"bg-position":[{bg:le()}],"bg-repeat":[{bg:ue()}],"bg-size":[{bg:de()}],"bg-image":[{bg:[`none`,{linear:[{to:[`t`,`tr`,`r`,`br`,`b`,`bl`,`l`,`tl`]},pv,Z,X],radial:[``,Z,X],conic:[pv,Z,X]},Fv,kv]}],"bg-color":[{bg:D()}],"gradient-from-pos":[{from:fe()}],"gradient-via-pos":[{via:fe()}],"gradient-to-pos":[{to:fe()}],"gradient-from":[{from:D()}],"gradient-via":[{via:D()}],"gradient-to":[{to:D()}],rounded:[{rounded:pe()}],"rounded-s":[{"rounded-s":pe()}],"rounded-e":[{"rounded-e":pe()}],"rounded-t":[{"rounded-t":pe()}],"rounded-r":[{"rounded-r":pe()}],"rounded-b":[{"rounded-b":pe()}],"rounded-l":[{"rounded-l":pe()}],"rounded-ss":[{"rounded-ss":pe()}],"rounded-se":[{"rounded-se":pe()}],"rounded-ee":[{"rounded-ee":pe()}],"rounded-es":[{"rounded-es":pe()}],"rounded-tl":[{"rounded-tl":pe()}],"rounded-tr":[{"rounded-tr":pe()}],"rounded-br":[{"rounded-br":pe()}],"rounded-bl":[{"rounded-bl":pe()}],"border-w":[{border:me()}],"border-w-x":[{"border-x":me()}],"border-w-y":[{"border-y":me()}],"border-w-s":[{"border-s":me()}],"border-w-e":[{"border-e":me()}],"border-w-bs":[{"border-bs":me()}],"border-w-be":[{"border-be":me()}],"border-w-t":[{"border-t":me()}],"border-w-r":[{"border-r":me()}],"border-w-b":[{"border-b":me()}],"border-w-l":[{"border-l":me()}],"divide-x":[{"divide-x":me()}],"divide-x-reverse":[`divide-x-reverse`],"divide-y":[{"divide-y":me()}],"divide-y-reverse":[`divide-y-reverse`],"border-style":[{border:[...he(),`hidden`,`none`]}],"divide-style":[{divide:[...he(),`hidden`,`none`]}],"border-color":[{border:D()}],"border-color-x":[{"border-x":D()}],"border-color-y":[{"border-y":D()}],"border-color-s":[{"border-s":D()}],"border-color-e":[{"border-e":D()}],"border-color-bs":[{"border-bs":D()}],"border-color-be":[{"border-be":D()}],"border-color-t":[{"border-t":D()}],"border-color-r":[{"border-r":D()}],"border-color-b":[{"border-b":D()}],"border-color-l":[{"border-l":D()}],"divide-color":[{divide:D()}],"outline-style":[{outline:[...he(),`none`,`hidden`]}],"outline-offset":[{"outline-offset":[Y,Z,X]}],"outline-w":[{outline:[``,Y,jv,wv]}],"outline-color":[{outline:D()}],shadow:[{shadow:[``,`none`,u,Iv,Av]}],"shadow-color":[{shadow:D()}],"inset-shadow":[{"inset-shadow":[`none`,d,Iv,Av]}],"inset-shadow-color":[{"inset-shadow":D()}],"ring-w":[{ring:me()}],"ring-w-inset":[`ring-inset`],"ring-color":[{ring:D()}],"ring-offset-w":[{"ring-offset":[Y,wv]}],"ring-offset-color":[{"ring-offset":D()}],"inset-ring-w":[{"inset-ring":me()}],"inset-ring-color":[{"inset-ring":D()}],"text-shadow":[{"text-shadow":[`none`,f,Iv,Av]}],"text-shadow-color":[{"text-shadow":D()}],opacity:[{opacity:[Y,Z,X]}],"mix-blend":[{"mix-blend":[...ge(),`plus-darker`,`plus-lighter`]}],"bg-blend":[{"bg-blend":ge()}],"mask-clip":[{"mask-clip":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]},`mask-no-clip`],"mask-composite":[{mask:[`add`,`subtract`,`intersect`,`exclude`]}],"mask-image-linear-pos":[{"mask-linear":[Y]}],"mask-image-linear-from-pos":[{"mask-linear-from":_e()}],"mask-image-linear-to-pos":[{"mask-linear-to":_e()}],"mask-image-linear-from-color":[{"mask-linear-from":D()}],"mask-image-linear-to-color":[{"mask-linear-to":D()}],"mask-image-t-from-pos":[{"mask-t-from":_e()}],"mask-image-t-to-pos":[{"mask-t-to":_e()}],"mask-image-t-from-color":[{"mask-t-from":D()}],"mask-image-t-to-color":[{"mask-t-to":D()}],"mask-image-r-from-pos":[{"mask-r-from":_e()}],"mask-image-r-to-pos":[{"mask-r-to":_e()}],"mask-image-r-from-color":[{"mask-r-from":D()}],"mask-image-r-to-color":[{"mask-r-to":D()}],"mask-image-b-from-pos":[{"mask-b-from":_e()}],"mask-image-b-to-pos":[{"mask-b-to":_e()}],"mask-image-b-from-color":[{"mask-b-from":D()}],"mask-image-b-to-color":[{"mask-b-to":D()}],"mask-image-l-from-pos":[{"mask-l-from":_e()}],"mask-image-l-to-pos":[{"mask-l-to":_e()}],"mask-image-l-from-color":[{"mask-l-from":D()}],"mask-image-l-to-color":[{"mask-l-to":D()}],"mask-image-x-from-pos":[{"mask-x-from":_e()}],"mask-image-x-to-pos":[{"mask-x-to":_e()}],"mask-image-x-from-color":[{"mask-x-from":D()}],"mask-image-x-to-color":[{"mask-x-to":D()}],"mask-image-y-from-pos":[{"mask-y-from":_e()}],"mask-image-y-to-pos":[{"mask-y-to":_e()}],"mask-image-y-from-color":[{"mask-y-from":D()}],"mask-image-y-to-color":[{"mask-y-to":D()}],"mask-image-radial":[{"mask-radial":[Z,X]}],"mask-image-radial-from-pos":[{"mask-radial-from":_e()}],"mask-image-radial-to-pos":[{"mask-radial-to":_e()}],"mask-image-radial-from-color":[{"mask-radial-from":D()}],"mask-image-radial-to-color":[{"mask-radial-to":D()}],"mask-image-radial-shape":[{"mask-radial":[`circle`,`ellipse`]}],"mask-image-radial-size":[{"mask-radial":[{closest:[`side`,`corner`],farthest:[`side`,`corner`]}]}],"mask-image-radial-pos":[{"mask-radial-at":b()}],"mask-image-conic-pos":[{"mask-conic":[Y]}],"mask-image-conic-from-pos":[{"mask-conic-from":_e()}],"mask-image-conic-to-pos":[{"mask-conic-to":_e()}],"mask-image-conic-from-color":[{"mask-conic-from":D()}],"mask-image-conic-to-color":[{"mask-conic-to":D()}],"mask-mode":[{mask:[`alpha`,`luminance`,`match`]}],"mask-origin":[{"mask-origin":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]}],"mask-position":[{mask:le()}],"mask-repeat":[{mask:ue()}],"mask-size":[{mask:de()}],"mask-type":[{"mask-type":[`alpha`,`luminance`]}],"mask-image":[{mask:[`none`,Z,X]}],filter:[{filter:[``,`none`,Z,X]}],blur:[{blur:ve()}],brightness:[{brightness:[Y,Z,X]}],contrast:[{contrast:[Y,Z,X]}],"drop-shadow":[{"drop-shadow":[``,`none`,p,Iv,Av]}],"drop-shadow-color":[{"drop-shadow":D()}],grayscale:[{grayscale:[``,Y,Z,X]}],"hue-rotate":[{"hue-rotate":[Y,Z,X]}],invert:[{invert:[``,Y,Z,X]}],saturate:[{saturate:[Y,Z,X]}],sepia:[{sepia:[``,Y,Z,X]}],"backdrop-filter":[{"backdrop-filter":[``,`none`,Z,X]}],"backdrop-blur":[{"backdrop-blur":ve()}],"backdrop-brightness":[{"backdrop-brightness":[Y,Z,X]}],"backdrop-contrast":[{"backdrop-contrast":[Y,Z,X]}],"backdrop-grayscale":[{"backdrop-grayscale":[``,Y,Z,X]}],"backdrop-hue-rotate":[{"backdrop-hue-rotate":[Y,Z,X]}],"backdrop-invert":[{"backdrop-invert":[``,Y,Z,X]}],"backdrop-opacity":[{"backdrop-opacity":[Y,Z,X]}],"backdrop-saturate":[{"backdrop-saturate":[Y,Z,X]}],"backdrop-sepia":[{"backdrop-sepia":[``,Y,Z,X]}],"border-collapse":[{border:[`collapse`,`separate`]}],"border-spacing":[{"border-spacing":w()}],"border-spacing-x":[{"border-spacing-x":w()}],"border-spacing-y":[{"border-spacing-y":w()}],"table-layout":[{table:[`auto`,`fixed`]}],caption:[{caption:[`top`,`bottom`]}],transition:[{transition:[``,`all`,`colors`,`opacity`,`shadow`,`transform`,`none`,Z,X]}],"transition-behavior":[{transition:[`normal`,`discrete`]}],duration:[{duration:[Y,`initial`,Z,X]}],ease:[{ease:[`linear`,`initial`,_,Z,X]}],delay:[{delay:[Y,Z,X]}],animate:[{animate:[`none`,v,Z,X]}],backface:[{backface:[`hidden`,`visible`]}],perspective:[{perspective:[h,Z,X]}],"perspective-origin":[{"perspective-origin":x()}],rotate:[{rotate:ye()}],"rotate-x":[{"rotate-x":ye()}],"rotate-y":[{"rotate-y":ye()}],"rotate-z":[{"rotate-z":ye()}],scale:[{scale:be()}],"scale-x":[{"scale-x":be()}],"scale-y":[{"scale-y":be()}],"scale-z":[{"scale-z":be()}],"scale-3d":[`scale-3d`],skew:[{skew:O()}],"skew-x":[{"skew-x":O()}],"skew-y":[{"skew-y":O()}],transform:[{transform:[Z,X,``,`none`,`gpu`,`cpu`]}],"transform-origin":[{origin:x()}],"transform-style":[{transform:[`3d`,`flat`]}],translate:[{translate:xe()}],"translate-x":[{"translate-x":xe()}],"translate-y":[{"translate-y":xe()}],"translate-z":[{"translate-z":xe()}],"translate-none":[`translate-none`],zoom:[{zoom:[pv,Z,X]}],accent:[{accent:D()}],appearance:[{appearance:[`none`,`auto`]}],"caret-color":[{caret:D()}],"color-scheme":[{scheme:[`normal`,`dark`,`light`,`light-dark`,`only-dark`,`only-light`]}],cursor:[{cursor:[`auto`,`default`,`pointer`,`wait`,`text`,`move`,`help`,`not-allowed`,`none`,`context-menu`,`progress`,`cell`,`crosshair`,`vertical-text`,`alias`,`copy`,`no-drop`,`grab`,`grabbing`,`all-scroll`,`col-resize`,`row-resize`,`n-resize`,`e-resize`,`s-resize`,`w-resize`,`ne-resize`,`nw-resize`,`se-resize`,`sw-resize`,`ew-resize`,`ns-resize`,`nesw-resize`,`nwse-resize`,`zoom-in`,`zoom-out`,Z,X]}],"field-sizing":[{"field-sizing":[`fixed`,`content`]}],"pointer-events":[{"pointer-events":[`auto`,`none`]}],resize:[{resize:[`none`,``,`y`,`x`]}],"scroll-behavior":[{scroll:[`auto`,`smooth`]}],"scrollbar-thumb-color":[{"scrollbar-thumb":D()}],"scrollbar-track-color":[{"scrollbar-track":D()}],"scrollbar-gutter":[{"scrollbar-gutter":[`auto`,`stable`,`both`]}],"scrollbar-w":[{scrollbar:[`auto`,`thin`,`none`]}],"scroll-m":[{"scroll-m":w()}],"scroll-mx":[{"scroll-mx":w()}],"scroll-my":[{"scroll-my":w()}],"scroll-ms":[{"scroll-ms":w()}],"scroll-me":[{"scroll-me":w()}],"scroll-mbs":[{"scroll-mbs":w()}],"scroll-mbe":[{"scroll-mbe":w()}],"scroll-mt":[{"scroll-mt":w()}],"scroll-mr":[{"scroll-mr":w()}],"scroll-mb":[{"scroll-mb":w()}],"scroll-ml":[{"scroll-ml":w()}],"scroll-p":[{"scroll-p":w()}],"scroll-px":[{"scroll-px":w()}],"scroll-py":[{"scroll-py":w()}],"scroll-ps":[{"scroll-ps":w()}],"scroll-pe":[{"scroll-pe":w()}],"scroll-pbs":[{"scroll-pbs":w()}],"scroll-pbe":[{"scroll-pbe":w()}],"scroll-pt":[{"scroll-pt":w()}],"scroll-pr":[{"scroll-pr":w()}],"scroll-pb":[{"scroll-pb":w()}],"scroll-pl":[{"scroll-pl":w()}],"snap-align":[{snap:[`start`,`end`,`center`,`align-none`]}],"snap-stop":[{snap:[`normal`,`always`]}],"snap-type":[{snap:[`none`,`x`,`y`,`both`]}],"snap-strictness":[{snap:[`mandatory`,`proximity`]}],touch:[{touch:[`auto`,`none`,`manipulation`]}],"touch-x":[{"touch-pan":[`x`,`left`,`right`]}],"touch-y":[{"touch-pan":[`y`,`up`,`down`]}],"touch-pz":[`touch-pinch-zoom`],select:[{select:[`none`,`text`,`all`,`auto`]}],"will-change":[{"will-change":[`auto`,`scroll`,`contents`,`transform`,Z,X]}],fill:[{fill:[`none`,...D()]}],"stroke-w":[{stroke:[Y,jv,wv,Tv]}],stroke:[{stroke:[`none`,...D()]}],"forced-color-adjust":[{"forced-color-adjust":[`auto`,`none`]}]},conflictingClassGroups:{"container-named":[`container-type`],overflow:[`overflow-x`,`overflow-y`],overscroll:[`overscroll-x`,`overscroll-y`],inset:[`inset-x`,`inset-y`,`inset-bs`,`inset-be`,`start`,`end`,`top`,`right`,`bottom`,`left`],"inset-x":[`right`,`left`],"inset-y":[`top`,`bottom`],flex:[`basis`,`grow`,`shrink`],gap:[`gap-x`,`gap-y`],p:[`px`,`py`,`ps`,`pe`,`pbs`,`pbe`,`pt`,`pr`,`pb`,`pl`],px:[`pr`,`pl`],py:[`pt`,`pb`],m:[`mx`,`my`,`ms`,`me`,`mbs`,`mbe`,`mt`,`mr`,`mb`,`ml`],mx:[`mr`,`ml`],my:[`mt`,`mb`],size:[`w`,`h`],"font-size":[`leading`],"fvn-normal":[`fvn-ordinal`,`fvn-slashed-zero`,`fvn-figure`,`fvn-spacing`,`fvn-fraction`],"fvn-ordinal":[`fvn-normal`],"fvn-slashed-zero":[`fvn-normal`],"fvn-figure":[`fvn-normal`],"fvn-spacing":[`fvn-normal`],"fvn-fraction":[`fvn-normal`],"line-clamp":[`display`,`overflow`],rounded:[`rounded-s`,`rounded-e`,`rounded-t`,`rounded-r`,`rounded-b`,`rounded-l`,`rounded-ss`,`rounded-se`,`rounded-ee`,`rounded-es`,`rounded-tl`,`rounded-tr`,`rounded-br`,`rounded-bl`],"rounded-s":[`rounded-ss`,`rounded-es`],"rounded-e":[`rounded-se`,`rounded-ee`],"rounded-t":[`rounded-tl`,`rounded-tr`],"rounded-r":[`rounded-tr`,`rounded-br`],"rounded-b":[`rounded-br`,`rounded-bl`],"rounded-l":[`rounded-tl`,`rounded-bl`],"border-spacing":[`border-spacing-x`,`border-spacing-y`],"border-w":[`border-w-x`,`border-w-y`,`border-w-s`,`border-w-e`,`border-w-bs`,`border-w-be`,`border-w-t`,`border-w-r`,`border-w-b`,`border-w-l`],"border-w-x":[`border-w-r`,`border-w-l`],"border-w-y":[`border-w-t`,`border-w-b`],"border-color":[`border-color-x`,`border-color-y`,`border-color-s`,`border-color-e`,`border-color-bs`,`border-color-be`,`border-color-t`,`border-color-r`,`border-color-b`,`border-color-l`],"border-color-x":[`border-color-r`,`border-color-l`],"border-color-y":[`border-color-t`,`border-color-b`],translate:[`translate-x`,`translate-y`,`translate-none`],"translate-none":[`translate`,`translate-x`,`translate-y`,`translate-z`],"scroll-m":[`scroll-mx`,`scroll-my`,`scroll-ms`,`scroll-me`,`scroll-mbs`,`scroll-mbe`,`scroll-mt`,`scroll-mr`,`scroll-mb`,`scroll-ml`],"scroll-mx":[`scroll-mr`,`scroll-ml`],"scroll-my":[`scroll-mt`,`scroll-mb`],"scroll-p":[`scroll-px`,`scroll-py`,`scroll-ps`,`scroll-pe`,`scroll-pbs`,`scroll-pbe`,`scroll-pt`,`scroll-pr`,`scroll-pb`,`scroll-pl`],"scroll-px":[`scroll-pr`,`scroll-pl`],"scroll-py":[`scroll-pt`,`scroll-pb`],touch:[`touch-x`,`touch-y`,`touch-pz`],"touch-x":[`touch`],"touch-y":[`touch`],"touch-pz":[`touch`]},conflictingClassGroupModifiers:{"font-size":[`leading`]},postfixLookupClassGroups:[`container-type`],orderSensitiveModifiers:[`*`,`**`,`after`,`backdrop`,`before`,`details-content`,`file`,`first-letter`,`first-line`,`marker`,`placeholder`,`selection`]}});function Yv(...e){return Jv(b_(e))}var Xv=F({__name:`Alert`,props:{class:{type:[Boolean,null,String,Object,Array]},variant:{}},setup(e){let t=e;return(n,r)=>(R(),z(`div`,{"data-slot":`alert`,class:O(N(Yv)(N($v)({variant:e.variant}),t.class)),role:`alert`},[I(n.$slots,`default`)],2))}}),Zv=F({__name:`AlertDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`alert-description`,class:O(N(Yv)(`text-muted-foreground text-sm text-balance md:text-pretty [&_p:not(:last-child)]:mb-4 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[I(e.$slots,`default`)],2))}}),Qv=F({__name:`AlertTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`alert-title`,class:O(N(Yv)(`font-medium group-has-[>svg]/alert:col-start-2 cn-font-heading [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[I(e.$slots,`default`)],2))}}),$v=C_(`grid gap-0.5 rounded-lg border px-2.5 py-2 text-left text-sm has-data-[slot=alert-action]:relative has-data-[slot=alert-action]:pr-18 has-[>svg]:grid-cols-[auto_1fr] has-[>svg]:gap-x-2 *:[svg]:row-span-2 *:[svg]:translate-y-0.5 *:[svg]:text-current *:[svg:not([class*=size-])]:size-4 group/alert relative w-full`,{variants:{variant:{default:`bg-card text-card-foreground`,destructive:`text-destructive bg-card *:data-[slot=alert-description]:text-destructive/90 *:[svg]:text-current`}},defaultVariants:{variant:`default`}});function ey(e){return typeof e==`string`?`'${e}'`:new iy().serialize(e)}var ty=` _-,;:!?.'"()[]{}@*/\\&#%\`^+<=>|~$0123456789abcdefghijklmnopqrstuvwxyz`,ny=(function(){let e=new Uint8Array(128);for(let t=0;t<69;t++)e[ty.charCodeAt(t)]=t+1;for(let t=65;t<=90;t++)e[t]=e[t+32];return e})();function ry(e,t){if(e===t)return 0;let n=Math.min(e.length,t.length),r=0;for(let i=0;i<n;i++){let n=e.charCodeAt(i),a=t.charCodeAt(i);if(n===a)continue;let o=n<128&&ny[n]?ny[n]:n+128,s=a<128&&ny[a]?ny[a]:a+128;if(o!==s)return o<s?-1:1;r===0&&(r=n>a?-1:1)}return e.length===t.length?r:e.length<t.length?-1:1}var iy=(function(){class e{#e=new Map;compare(e,t){let n=typeof e,r=typeof t;return n===`string`&&r===`string`?ry(e,t):n===`number`&&r===`number`?e-t:ry(this.serialize(e,!0),this.serialize(t,!0))}serialize(e,t){if(e===null)return`null`;switch(typeof e){case`string`:return t?e:`'${e}'`;case`bigint`:return`${e}n`;case`object`:return this.$object(e);case`function`:return this.$function(e)}return String(e)}serializeObject(e){let t=Object.prototype.toString.call(e);if(t!==`[object Object]`)return this.serializeBuiltInType(t.length<10?`unknown:${t}`:t.slice(8,-1),e);let n=e.constructor,r=n===Object||n===void 0?``:n.name;if(r!==``&&globalThis[r]===n)return this.serializeBuiltInType(r,e);if(`toJSON`in e&&typeof e.toJSON==`function`){let t=e.toJSON();return r+(typeof t==`object`&&t?this.$object(t):`(${this.serialize(t)})`)}let i=Object.keys(e).sort(ry),a=`${r}{`;for(let t=0;t<i.length;t++){let n=i[t];a+=`${n}:${this.serialize(e[n])}`,t<i.length-1&&(a+=`,`)}return a+`}`}serializeBuiltInType(e,t){let n=this[`$`+e];if(n)return n.call(this,t);if(typeof t.entries==`function`)return this.serializeObjectEntries(e,t.entries());throw Error(`Cannot serialize ${e}`)}serializeObjectEntries(e,t){let n=Array.from(t).sort((e,t)=>this.compare(e[0],t[0])),r=`${e}{`;for(let e=0;e<n.length;e++){let[t,i]=n[e];r+=`${this.serialize(t,!0)}:${this.serialize(i)}`,e<n.length-1&&(r+=`,`)}return r+`}`}$object(e){let t=this.#e.get(e);return t===void 0&&(this.#e.set(e,`#${this.#e.size}`),t=this.serializeObject(e),this.#e.set(e,t)),t}$function(e){let t=Function.prototype.toString.call(e);return t.slice(-15)===`[native code] }`?`${e.name||``}()[native]`:`${e.name}(${e.length})${t.replace(/\s*\n\s*/g,``)}`}$Array(e){let t=`[`;for(let n=0;n<e.length;n++)t+=this.serialize(e[n]),n<e.length-1&&(t+=`,`);return t+`]`}$Date(e){try{return`Date(${e.toISOString()})`}catch{return`Date(null)`}}$ArrayBuffer(e){return`ArrayBuffer[${new Uint8Array(e).join(`,`)}]`}$Set(e){return`Set${this.$Array(Array.from(e).sort((e,t)=>this.compare(e,t)))}`}$Map(e){return this.serializeObjectEntries(`Map`,e.entries())}}for(let t of[`Error`,`RegExp`,`URL`])e.prototype[`$`+t]=function(e){return`${t}(${e})`};for(let t of[`Int8Array`,`Uint8Array`,`Uint8ClampedArray`,`Int16Array`,`Uint16Array`,`Int32Array`,`Uint32Array`,`Float32Array`,`Float64Array`])e.prototype[`$`+t]=function(e){return`${t}[${e.join(`,`)}]`};for(let t of[`BigInt64Array`,`BigUint64Array`])e.prototype[`$`+t]=function(e){return`${t}[${e.join(`n,`)}${e.length>0?`n`:``}]`};return e})();function ay(e,t){return e===t||ey(e)===ey(t)}function oy(e,t){let n=typeof e==`string`&&!t?`${e}Context`:t,r=Symbol(n);return[t=>{let n=yr(r,t);if(n||n===null)return n;throw Error(`Injection \`${r.toString()}\` not found. Component must be used within ${Array.isArray(e)?`one of the following components: ${e.join(`, `)}`:`\`${e}\``}`)},e=>(vr(r,e),e)]}function sy(){let e=document.activeElement;if(e==null)return null;for(;e!=null&&e.shadowRoot!=null&&e.shadowRoot.activeElement!=null;)e=e.shadowRoot.activeElement;return e}function cy(e){return e==null}function ly(e,t){return cy(e)?!1:Array.isArray(e)?e.some(e=>ay(e,t)):ay(e,t)}function uy(e,t){return Fe()?(Ie(e,t),!0):!1}function dy(e){let t=!1,n,r=Pe(!0);return((...i)=>(t||=(n=r.run(()=>e(...i)),!0),n))}var fy=typeof window<`u`&&typeof document<`u`;typeof WorkerGlobalScope<`u`&&globalThis instanceof WorkerGlobalScope;var py=e=>e!==void 0,my=Object.prototype.toString,hy=e=>my.call(e)===`[object Object]`,gy=_y();function _y(){var e,t;return fy&&!!((e=window)!=null&&(e=e.navigator)!=null&&e.userAgent)&&(/iP(?:ad|hone|od)/.test(window.navigator.userAgent)||((t=window)==null||(t=t.navigator)==null?void 0:t.maxTouchPoints)>2&&/iPad|Macintosh/.test(window?.navigator.userAgent))}function vy(e){return Array.isArray(e)?e:[e]}function yy(e){return e||Fs()}function by(e){if(!fy)return e;let t=0,n,r,i=()=>{--t,r&&t<=0&&(r.stop(),n=void 0,r=void 0)};return((...a)=>(t+=1,r||(r=Pe(!0),n=r.run(()=>e(...a))),uy(i),n))}function xy(e){return Zt(j(e)?new Proxy({},{get(t,n,r){return N(Reflect.get(e.value,n,r))},set(t,n,r){return j(e.value[n])&&!j(r)?e.value[n].value=r:e.value[n]=r,!0},deleteProperty(t,n){return Reflect.deleteProperty(e.value,n)},has(t,n){return Reflect.has(e.value,n)},ownKeys(){return Object.keys(e.value)},getOwnPropertyDescriptor(){return{enumerable:!0,configurable:!0}}}):e)}function Sy(e){return xy(W(e))}function Cy(e,...t){let n=t.flat(),r=n[0];return Sy(()=>Object.fromEntries(typeof r==`function`?Object.entries(yn(e)).filter(([e,t])=>!r(mn(t),e)):Object.entries(yn(e)).filter(e=>!n.includes(e[0]))))}function wy(e,t=1e4){return vn((n,r)=>{let i=mn(e),a,o=()=>setTimeout(()=>{i=mn(e),r()},mn(t));return uy(()=>{clearTimeout(a)}),{get(){return n(),i},set(e){i=e,r(),clearTimeout(a),a=o()}}})}function Ty(e,t){yy(t)&&ea(e,t)}function Ey(e,t,n){return Er(e,t,{...n,immediate:!0})}var Dy=fy?window:void 0;fy&&window.document,fy&&window.navigator,fy&&window.location;function Oy(e){let t=mn(e);return t?.$el??t}function ky(...e){let t=(e,t,n,r)=>(e.addEventListener(t,n,r),()=>e.removeEventListener(t,n,r)),n=W(()=>{let t=vy(mn(e[0])).filter(e=>e!=null);return t.every(e=>typeof e!=`string`)?t:void 0});return Ey(()=>[n.value?.map(e=>Oy(e))??[Dy].filter(e=>e!=null),vy(mn(n.value?e[1]:e[0])),vy(N(n.value?e[2]:e[1])),mn(n.value?e[3]:e[2])],([e,n,r,i],a,o)=>{if(!e?.length||!n?.length||!r?.length)return;let s=hy(i)?{...i}:i,c=e.flatMap(e=>n.flatMap(n=>r.map(r=>t(e,n,r,s))));o(()=>{c.forEach(e=>e())})},{flush:`post`})}function Ay(){let e=un(!1),t=Fs();return t&&Zi(()=>{e.value=!0},t),e}function jy(e){let t=Ay();return W(()=>(t.value,!!e()))}function My(e){return typeof e==`function`?e:typeof e==`string`?t=>t.key===e:Array.isArray(e)?t=>e.includes(t.key):()=>!0}function Ny(...e){let t,n,r={};e.length===3?(t=e[0],n=e[1],r=e[2]):e.length===2?typeof e[1]==`object`?(t=!0,n=e[0],r=e[1]):(t=e[0],n=e[1]):(t=!0,n=e[0]);let{target:i=Dy,eventName:a=`keydown`,passive:o=!1,dedupe:s=!1}=r,c=My(t);return ky(i,a,e=>{e.repeat&&mn(s)||c(e)&&n(e)},o)}function Py(e){return JSON.parse(JSON.stringify(e))}function Fy(e,t,n={}){let{window:r=Dy,...i}=n,a,o=jy(()=>r&&`ResizeObserver`in r),s=()=>{a&&=(a.disconnect(),void 0)},c=Er(W(()=>{let t=mn(e);return Array.isArray(t)?t.map(e=>Oy(e)):[Oy(t)]}),e=>{if(s(),o.value&&r){a=new ResizeObserver(t);for(let t of e)t&&a.observe(t,i)}},{immediate:!0,flush:`post`}),l=()=>{s(),c()};return uy(l),{isSupported:o,stop:l}}function Iy(e,t,n,r={}){var i,a;let{clone:o=!1,passive:s=!1,eventName:c,deep:l=!1,defaultValue:u,shouldEmit:d}=r,f=Fs(),p=n||f?.emit||(f==null||(i=f.$emit)==null?void 0:i.bind(f))||(f==null||(a=f.proxy)==null||(a=a.$emit)==null?void 0:a.bind(f?.proxy)),m=c;t||=`modelValue`,m||=`update:${t.toString()}`;let h=e=>o?typeof o==`function`?o(e):Py(e):e,g=()=>py(e[t])?h(e[t]):u,_=e=>{d?d(e)&&p(m,e):p(m,e)};if(s){let n=M(g()),r=!1;return Er(()=>e[t],e=>{r||(r=!0,n.value=h(e),Qn(()=>r=!1))}),Er(n,n=>{!r&&(n!==e[t]||l)&&_(n)},{deep:l}),n}return W({get(){return g()},set(e){_(e)}})}function Ly(e){return e?e.flatMap(e=>e.type===L?Ly(e.children):[e]):[]}var Ry=[`INPUT`,`TEXTAREA`];function zy(e,t,n,r={}){if(!t||r.enableIgnoredElement&&Ry.includes(t.nodeName))return null;let{arrowKeyOptions:i=`both`,attributeName:a=`[data-reka-collection-item]`,itemsArray:o=[],loop:s=!0,dir:c=`ltr`,preventScroll:l=!0,focus:u=!1}=r,[d,f,p,m,h,g]=[e.key===`ArrowRight`,e.key===`ArrowLeft`,e.key===`ArrowUp`,e.key===`ArrowDown`,e.key===`Home`,e.key===`End`],_=p||m,v=d||f;if(!h&&!g&&(!_&&!v||i===`vertical`&&v||i===`horizontal`&&_))return null;let y=n?Array.from(n.querySelectorAll(a)):o;if(!y.length)return null;l&&e.preventDefault();let b=null;return v||_?b=By(y,t,{goForward:_?m:c===`ltr`?d:f,loop:s}):h?b=y.at(0)||null:g&&(b=y.at(-1)||null),u&&b?.focus(),b}function By(e,t,n,r=e.includes(t)?e.length:e.length+1){if(--r===0)return null;let i=e.indexOf(t),a;if(a=i===-1?n.goForward?0:e.length-1:n.goForward?i+1:i-1,!n.loop&&(a<0||a>=e.length))return null;let o=e[(a+e.length)%e.length];return o?o.hasAttribute(`disabled`)&&o.getAttribute(`disabled`)!==`false`?By(e,o,n,r):o:null}var[Vy,Hy]=oy(`ConfigProvider`);function Uy(e){let t=Vy({dir:M(`ltr`)});return W(()=>e?.value||t.dir?.value||`ltr`)}function Wy(e){let t=Fs(),n=t?.type.emits,r={};return n?.length||console.warn(`No emitted event found. Please check component: ${t?.type.__name}`),n?.forEach(t=>{r[ce(E(t))]=(...n)=>e(t,...n)}),r}function Gy(){let e=Fs(),t=M(),n=W(()=>r());$i(()=>{n.value!==r()&&pn(t)});function r(){return t.value&&`$el`in t.value&&[`#text`,`#comment`].includes(t.value.$el.nodeName)?t.value.$el.nextElementSibling:Oy(t)}let i=Object.assign({},e.exposed),a={};for(let t in e.props)Object.defineProperty(a,t,{enumerable:!0,configurable:!0,get:()=>e.props[t]});if(Object.keys(i).length>0)for(let e in i)Object.defineProperty(a,e,{enumerable:!0,configurable:!0,get:()=>i[e]});Object.defineProperty(a,"$el",{enumerable:!0,configurable:!0,get:()=>e.vnode.el}),e.exposed=a;function o(n){if(t.value=n,n&&(Object.defineProperty(a,"$el",{enumerable:!0,configurable:!0,get:()=>n instanceof Element?n:n.$el}),!(n instanceof Element)&&!Object.hasOwn(n,`$el`))){let t=n.$.exposed,r=Object.assign({},a);for(let e in t)Object.defineProperty(r,e,{enumerable:!0,configurable:!0,get:()=>t[e]});e.exposed=r}}return{forwardRef:o,currentRef:t,currentElement:n}}function Ky(e){let t=Fs(),n=Object.keys(t?.type.props??{}).reduce((e,n)=>{let r=(t?.type.props[n]).default;return r!==void 0&&(e[n]=r),e},{}),r=Sn(e);return W(()=>{let e={},i=t?.vnode.props??{};return Object.keys(i).forEach(t=>{e[E(t)]=i[t]}),Object.keys({...n,...e}).reduce((e,t)=>(r.value[t]!==void 0&&(e[t]=r.value[t]),e),{})})}function qy(e,t){let n=Ky(e),r=t?Wy(t):{};return W(()=>({...n.value,...r}))}var Jy=0;function Yy(e,t=`reka`){if(e)return e;let n,r=Vy({useId:void 0});return n=r.useId?r.useId():`useId`in bu?ai?.():`${++Jy}`,t?`${t}-${n}`:n}function Xy(e,t){let n=M(e);function r(e){return t[n.value][e]??n.value}return{state:n,dispatch:e=>{n.value=r(e)}}}function Zy(e,t){let n=M({}),r=M(`none`),i=M(e),a=e.value?`mounted`:`unmounted`,o,s=t.value?.ownerDocument.defaultView??Dy,{state:c,dispatch:l}=Xy(a,{mounted:{UNMOUNT:`unmounted`,ANIMATION_OUT:`unmountSuspended`},unmountSuspended:{MOUNT:`mounted`,ANIMATION_END:`unmounted`},unmounted:{MOUNT:`mounted`}}),u=e=>{if(fy){let n=new CustomEvent(e,{bubbles:!1,cancelable:!1});t.value?.dispatchEvent(n)}};Er(e,async(e,i)=>{let a=i!==e;if(await Qn(),a){let a=r.value,o=Qy(t.value);e?(l(`MOUNT`),u(`enter`),o===`none`&&u(`after-enter`)):o===`none`||o===`undefined`||n.value?.display===`none`?(l(`UNMOUNT`),u(`leave`),u(`after-leave`)):i&&a!==o?(l(`ANIMATION_OUT`),u(`leave`)):(l(`UNMOUNT`),u(`after-leave`))}},{immediate:!0});let d=e=>{if(e.target!==t.value)return;let n=Qy(t.value),r=n.includes(CSS.escape(e.animationName)),a=c.value===`mounted`?`enter`:`leave`;if(r&&(u(`after-${a}`),l(`ANIMATION_END`),!i.value)){let e=t.value.style.animationFillMode;t.value.style.animationFillMode=`forwards`,o=s?.setTimeout(()=>{t.value?.style.animationFillMode===`forwards`&&(t.value.style.animationFillMode=e)})}n===`none`&&l(`ANIMATION_END`)},f=e=>{e.target===t.value&&(r.value=Qy(t.value))},p=Er(t,(e,t)=>{e?(n.value=getComputedStyle(e),e.addEventListener(`animationstart`,f),e.addEventListener(`animationcancel`,d),e.addEventListener(`animationend`,d)):(l(`ANIMATION_END`),o!==void 0&&s?.clearTimeout(o),t?.removeEventListener(`animationstart`,f),t?.removeEventListener(`animationcancel`,d),t?.removeEventListener(`animationend`,d))},{immediate:!0}),m=Er(c,()=>{let e=Qy(t.value);r.value=c.value===`mounted`?e:`none`});return ta(()=>{p(),m(),t.value&&(t.value.removeEventListener(`animationstart`,f),t.value.removeEventListener(`animationcancel`,d),t.value.removeEventListener(`animationend`,d)),o!==void 0&&s?.clearTimeout(o)}),{isPresent:W(()=>[`mounted`,`unmountSuspended`].includes(c.value))}}function Qy(e){return e&&getComputedStyle(e).animationName||`none`}var $y=F({name:`Presence`,props:{present:{type:Boolean,required:!0},forceMount:{type:Boolean}},slots:{},setup(e,{slots:t,expose:n}){let{present:r,forceMount:i}=yn(e),a=M(),{isPresent:o}=Zy(r,a);n({present:o});let s=t.default({present:o.value});s=Ly(s||[]);let c=Fs();if(s&&s?.length>1){let e=c?.parent?.type.name?`<${c.parent.type.name} />`:`component`;throw Error([`Detected an invalid children for \`${e}\` for  \`Presence\` component.`,``,"Note: Presence works similarly to `v-if` directly, but it waits for animation/transition to finished before unmounting. So it expect only one direct child of valid VNode type.",`You can apply a few solutions:`,["Provide a single child element so that `presence` directive attach correctly.",`Ensure the first child is an actual element instead of a raw text node or comment node.`].map(e=>`  - ${e}`).join(`
`)].join(`
`))}return()=>i.value||r.value||o.value?G(t.default({present:o.value})[0],{ref:e=>{let t=Oy(e);return t?.hasAttribute===void 0||(t?.hasAttribute(`data-reka-popper-content-wrapper`)?a.value=t.firstElementChild:a.value=t),t}}):null}}),eb=F({name:`PrimitiveSlot`,inheritAttrs:!1,setup(e,{attrs:t,slots:n}){return()=>{if(!n.default)return null;let e=Ly(n.default()),r=e.findIndex(e=>e.type!==cs);if(r===-1)return e;let i=e[r];delete i.props?.ref;let a=i.props?ks(t,i.props):t,o=Cs({...i,props:{}},a);return e.length===1?o:(e[r]=o,e)}}}),tb=[`area`,`img`,`input`],nb=F({name:`Primitive`,inheritAttrs:!1,props:{asChild:{type:Boolean,default:!1},as:{type:[String,Object],default:`div`}},setup(e,{attrs:t,slots:n}){let r=e.asChild?`template`:e.as;return typeof r==`string`&&tb.includes(r)?()=>G(r,t):r===`template`?()=>G(eb,t,{default:n.default}):()=>G(e.as,t,{default:n.default})}});function rb(){let e=M();return{primitiveElement:e,currentElement:W(()=>[`#text`,`#comment`].includes(e.value?.$el.nodeName)?e.value?.$el.nextElementSibling:Oy(e))}}var[ib,ab]=oy(`CollapsibleRoot`),ob=F({__name:`CollapsibleRoot`,props:{defaultOpen:{type:Boolean,required:!1,default:!1},open:{type:Boolean,required:!1,default:void 0},disabled:{type:Boolean,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:open`],setup(e,{expose:t,emit:n}){let r=e,i=Iy(r,`open`,n,{defaultValue:r.defaultOpen,passive:r.open===void 0}),{disabled:a,unmountOnHide:o}=yn(r);return ab({contentId:``,disabled:a,open:i,unmountOnHide:o,onOpenToggle:()=>{a.value||(i.value=!i.value)}}),t({open:i}),Gy(),(e,t)=>(R(),B(N(nb),{as:e.as,"as-child":r.asChild,"data-state":N(i)?`open`:`closed`,"data-disabled":N(a)?``:void 0},{default:P(()=>[I(e.$slots,`default`,{open:N(i)})]),_:3},8,[`as`,`as-child`,`data-state`,`data-disabled`]))}}),sb=F({inheritAttrs:!1,__name:`CollapsibleContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`contentFound`],setup(e,{emit:t}){let n=e,r=t,i=ib();i.contentId||=Yy(void 0,`reka-collapsible-content`);let a=M(),{forwardRef:o,currentElement:s}=Gy(),c=M(0),l=M(0),u=W(()=>i.open.value),d=M(u.value),f=M();Er(()=>[u.value,a.value?.present],async()=>{await Qn();let e=s.value;if(!e)return;f.value=f.value||{transitionDuration:e.style.transitionDuration,animationName:e.style.animationName},e.style.transitionDuration=`0s`,e.style.animationName=`none`;let t=e.getBoundingClientRect();l.value=t.height,c.value=t.width,d.value||(e.style.transitionDuration=f.value.transitionDuration,e.style.animationName=f.value.animationName)},{immediate:!0});let p=W(()=>d.value&&i.open.value);return Zi(()=>{requestAnimationFrame(()=>{d.value=!1})}),ky(s,`beforematch`,e=>{requestAnimationFrame(()=>{i.onOpenToggle(),r(`contentFound`)})}),(e,t)=>(R(),B(N($y),{ref_key:`presentRef`,ref:a,present:e.forceMount||N(i).open.value,"force-mount":!0},{default:P(({present:t})=>[H(N(nb),ks(e.$attrs,{id:N(i).contentId,ref:N(o),"as-child":n.asChild,as:e.as,hidden:t?void 0:N(i).unmountOnHide.value?``:`until-found`,"data-state":p.value?void 0:N(i).open.value?`open`:`closed`,"data-disabled":N(i).disabled?.value?``:void 0,style:{"--reka-collapsible-content-height":`${l.value}px`,"--reka-collapsible-content-width":`${c.value}px`}}),{default:P(()=>[!N(i).unmountOnHide.value||t?I(e.$slots,`default`,{key:0}):Ts(`v-if`,!0)]),_:2},1040,[`id`,`as-child`,`as`,`hidden`,`data-state`,`data-disabled`,`style`])]),_:3},8,[`present`]))}}),cb=F({__name:`CollapsibleTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e;Gy();let n=ib();return(e,r)=>(R(),B(N(nb),{type:e.as===`button`?`button`:void 0,as:e.as,"as-child":t.asChild,"aria-controls":N(n).contentId,"aria-expanded":N(n).open.value,"data-state":N(n).open.value?`open`:`closed`,"data-disabled":N(n).disabled?.value?``:void 0,disabled:N(n).disabled?.value,onClick:N(n).onOpenToggle},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`type`,`as`,`as-child`,`aria-controls`,`aria-expanded`,`data-state`,`data-disabled`,`disabled`,`onClick`]))}});function lb({type:e,defaultValue:t,modelValue:n}){let r=n||t;return n!==void 0||t!==void 0?Array.isArray(r)?`multiple`:`single`:e??`single`}function ub({type:e,defaultValue:t,modelValue:n}){return e||lb({type:e,defaultValue:t,modelValue:n})}function db({type:e,defaultValue:t}){return t===void 0?e===`single`?void 0:[]:t}function fb(e,t){let n=W(()=>ub(e)),r=Iy(e,`modelValue`,t,{defaultValue:db(e),passive:e.modelValue===void 0,deep:!0});function i(e){if(n.value===`single`)r.value=ay(e,r.value)?void 0:e;else{let t=Array.isArray(r.value)?[...r.value||[]]:[r.value].filter(Boolean);if(ly(t,e)){let n=t.findIndex(t=>ay(t,e));t.splice(n,1)}else t.push(e);r.value=t}}return{modelValue:r,changeModelValue:i,isSingle:W(()=>n.value===`single`)}}var[pb,mb]=oy(`AccordionRoot`),hb=F({__name:`AccordionRoot`,props:{collapsible:{type:Boolean,required:!1,default:!1},disabled:{type:Boolean,required:!1,default:!1},dir:{type:String,required:!1},orientation:{type:String,required:!1,default:`vertical`},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},type:{type:String,required:!1},modelValue:{type:null,required:!1},defaultValue:{type:null,required:!1}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,{dir:i,disabled:a,unmountOnHide:o}=yn(n),s=Uy(i),{modelValue:c,changeModelValue:l,isSingle:u}=fb(n,r),{forwardRef:d,currentElement:f}=Gy();return mb({disabled:a,direction:s,orientation:n.orientation,parentElement:f,isSingle:u,collapsible:n.collapsible,modelValue:c,changeModelValue:l,unmountOnHide:o}),(e,t)=>(R(),B(N(nb),{ref:N(d),"as-child":e.asChild,as:e.as},{default:P(()=>[I(e.$slots,`default`,{modelValue:N(c)})]),_:3},8,[`as-child`,`as`]))}}),gb=function(e){return e.Open=`open`,e.Closed=`closed`,e}(gb||{}),[_b,vb]=oy(`AccordionItem`),yb=F({__name:`AccordionItem`,props:{disabled:{type:Boolean,required:!1},value:{type:String,required:!0},unmountOnHide:{type:Boolean,required:!1,default:void 0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e,{expose:t}){let n=e,r=pb(),i=W(()=>r.isSingle.value?n.value===r.modelValue.value:Array.isArray(r.modelValue.value)&&r.modelValue.value.includes(n.value)),a=W(()=>r.disabled.value||n.disabled),o=W(()=>a.value?``:void 0),s=W(()=>i.value?gb.Open:gb.Closed);t({open:i,dataDisabled:o});let{currentRef:c,currentElement:l}=Gy();vb({open:i,dataState:s,disabled:a,dataDisabled:o,triggerId:``,currentRef:c,currentElement:l,value:W(()=>n.value)});function u(e){let t=e.target;if(Array.from(r.parentElement.value?.querySelectorAll(`[data-reka-collection-item]`)??[]).findIndex(e=>e===t)===-1)return null;zy(e,t,r.parentElement.value,{arrowKeyOptions:r.orientation,dir:r.direction.value,focus:!0})}return(e,t)=>(R(),B(N(ob),{"data-orientation":N(r).orientation,"data-disabled":o.value,"data-state":s.value,disabled:a.value,open:i.value,as:n.as,"as-child":n.asChild,"unmount-on-hide":n.unmountOnHide??N(r).unmountOnHide.value,onKeydown:ou(u,[`up`,`down`,`left`,`right`,`home`,`end`])},{default:P(()=>[I(e.$slots,`default`,{open:i.value})]),_:3},8,[`data-orientation`,`data-disabled`,`data-state`,`disabled`,`open`,`as`,`as-child`,`unmount-on-hide`]))}}),bb=F({__name:`AccordionContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=pb(),r=_b();return Gy(),(e,i)=>(R(),B(N(sb),{role:`region`,"as-child":t.asChild,as:e.as,"force-mount":t.forceMount,"aria-labelledby":N(r).triggerId,"data-state":N(r).dataState.value,"data-disabled":N(r).dataDisabled.value,"data-orientation":N(n).orientation,style:{"--reka-accordion-content-width":`var(--reka-collapsible-content-width)`,"--reka-accordion-content-height":`var(--reka-collapsible-content-height)`},onContentFound:i[0]||=e=>N(n).changeModelValue(N(r).value.value)},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`force-mount`,`aria-labelledby`,`data-state`,`data-disabled`,`data-orientation`]))}}),xb=F({__name:`AccordionHeader`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`h3`}},setup(e){let t=e,n=pb(),r=_b();return Gy(),(e,i)=>(R(),B(N(nb),{as:t.as,"as-child":t.asChild,"data-orientation":N(n).orientation,"data-state":N(r).dataState.value,"data-disabled":N(r).dataDisabled.value},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`data-orientation`,`data-state`,`data-disabled`]))}}),Sb=F({__name:`AccordionTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=pb(),r=_b();r.triggerId||=Yy(void 0,`reka-accordion-trigger`);function i(){let e=n.isSingle.value&&r.open.value&&!n.collapsible;r.disabled.value||e||n.changeModelValue(r.value.value)}return(e,a)=>(R(),B(N(cb),{id:N(r).triggerId,ref:N(r).currentRef,"data-reka-collection-item":``,as:t.as,"as-child":t.asChild,"aria-disabled":N(r).disabled.value||void 0,"aria-expanded":N(r).open.value||!1,"data-disabled":N(r).dataDisabled.value,"data-orientation":N(n).orientation,"data-state":N(r).dataState.value,disabled:N(r).disabled.value,onClick:i},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`id`,`as`,`as-child`,`aria-disabled`,`aria-expanded`,`data-disabled`,`data-orientation`,`data-state`,`disabled`]))}}),Cb=`data-reka-collection-item`;function wb(e={}){let{key:t=``,isProvider:n=!1}=e,r=`${t}CollectionProvider`,i;n?(i={collectionRef:M(),itemMap:M(new Map)},vr(r,i)):i=yr(r);let a=(e=!1)=>{let t=i.collectionRef.value;if(!t)return[];let n=Array.from(t.querySelectorAll(`[${Cb}]`)),r=new Map(n.map((e,t)=>[e,t])),a=Array.from(i.itemMap.value.values()).sort((e,t)=>(r.get(e.ref)??-1)-(r.get(t.ref)??-1));return e?a:a.filter(e=>e.ref.dataset.disabled!==``)},o=F({name:`CollectionSlot`,inheritAttrs:!1,setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=rb();return Er(a,()=>{i.collectionRef.value=a.value}),()=>G(eb,{ref:r,...n},t)}}),s=F({name:`CollectionItem`,inheritAttrs:!1,props:{value:{validator:()=>!0}},setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=rb();return Cr(t=>{if(a.value){let n=sn(a.value);i.itemMap.value.set(n,{ref:a.value,value:e.value}),t(()=>i.itemMap.value.delete(n))}}),()=>G(eb,{...n,[Cb]:``,ref:r},t)}});return{getItems:a,reactiveItems:W(()=>Array.from(i.itemMap.value.values())),itemMapSize:W(()=>i.itemMap.value.size),CollectionSlot:o,CollectionItem:s}}var Tb=`rovingFocusGroup.onEntryFocus`,Eb={bubbles:!1,cancelable:!0},Db={ArrowLeft:`prev`,ArrowUp:`prev`,ArrowRight:`next`,ArrowDown:`next`,PageUp:`first`,Home:`first`,PageDown:`last`,End:`last`};function Ob(e,t){return t===`rtl`?e===`ArrowLeft`?`ArrowRight`:e===`ArrowRight`?`ArrowLeft`:e:e}function kb(e,t,n){let r=Ob(e.key,n);if(!(t===`vertical`&&[`ArrowLeft`,`ArrowRight`].includes(r))&&!(t===`horizontal`&&[`ArrowUp`,`ArrowDown`].includes(r)))return Db[r]}function Ab(e,t=!1){let n=sy();for(let r of e)if(r===n||(r.focus({preventScroll:t}),sy()!==n))return}function jb(e,t){return e.map((n,r)=>e[(t+r)%e.length])}var[Mb,Nb]=oy(`RovingFocusGroup`),Pb=F({__name:`RovingFocusGroup`,props:{orientation:{type:String,required:!1,default:void 0},dir:{type:String,required:!1},loop:{type:Boolean,required:!1,default:!1},currentTabStopId:{type:[String,null],required:!1},defaultCurrentTabStopId:{type:String,required:!1},preventScrollOnEntryFocus:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`entryFocus`,`update:currentTabStopId`],setup(e,{expose:t,emit:n}){let r=e,i=n,{loop:a,orientation:o,dir:s}=yn(r),c=Uy(s),l=Iy(r,`currentTabStopId`,i,{defaultValue:r.defaultCurrentTabStopId,passive:r.currentTabStopId===void 0}),u=M(!1),d=M(!1),f=M(0),{getItems:p,CollectionSlot:m}=wb({isProvider:!0});function h(e){let t=!d.value;if(e.currentTarget&&e.target===e.currentTarget&&t&&!u.value){let t=new CustomEvent(Tb,Eb);if(e.currentTarget.dispatchEvent(t),i(`entryFocus`,t),!t.defaultPrevented){let e=p().map(e=>e.ref).filter(e=>e.dataset.disabled!==``);Ab([e.find(e=>e.getAttribute(`data-active`)===``),e.find(e=>e.getAttribute(`data-highlighted`)===``),e.find(e=>e.id===l.value),...e].filter(Boolean),r.preventScrollOnEntryFocus)}}d.value=!1}function g(){setTimeout(()=>{d.value=!1},1)}return t({getItems:p}),Nb({loop:a,dir:c,orientation:o,currentTabStopId:l,onItemFocus:e=>{l.value=e},onItemShiftTab:()=>{u.value=!0},onFocusableItemAdd:()=>{f.value++},onFocusableItemRemove:()=>{f.value--}}),(e,t)=>(R(),B(N(m),null,{default:P(()=>[H(N(nb),{tabindex:u.value||f.value===0?-1:0,"data-orientation":N(o),as:e.as,"as-child":e.asChild,dir:N(c),style:{outline:`none`},onMousedown:t[0]||=e=>d.value=!0,onMouseup:g,onFocus:h,onBlur:t[1]||=e=>u.value=!1},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`as`,`as-child`,`dir`])]),_:3}))}}),Fb=F({__name:`RovingFocusItem`,props:{tabStopId:{type:String,required:!1},focusable:{type:Boolean,required:!1,default:!0},active:{type:Boolean,required:!1},allowShiftKey:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Mb(),r=Yy(),i=W(()=>t.tabStopId||r),a=W(()=>n.currentTabStopId.value===i.value),{getItems:o,CollectionItem:s}=wb();Zi(()=>{t.focusable&&n.onFocusableItemAdd()}),ta(()=>{t.focusable&&n.onFocusableItemRemove()}),Er(()=>t.focusable,(e,t)=>{e!==t&&(e?n.onFocusableItemAdd():n.onFocusableItemRemove())});function c(e){if(e.key===`Tab`&&e.shiftKey){n.onItemShiftTab();return}if(e.target!==e.currentTarget)return;let r=kb(e,n.orientation.value,n.dir.value);if(r!==void 0){if(e.metaKey||e.ctrlKey||e.altKey||!t.allowShiftKey&&e.shiftKey)return;e.preventDefault();let i=[...o().map(e=>e.ref).filter(e=>e.dataset.disabled!==``)];if(r===`last`)i.reverse();else if(r===`prev`||r===`next`){r===`prev`&&i.reverse();let t=i.indexOf(e.currentTarget);i=n.loop.value?jb(i,t+1):i.slice(t+1)}Qn(()=>Ab(i))}}return(e,t)=>(R(),B(N(s),null,{default:P(()=>[H(N(nb),{tabindex:a.value?0:-1,"data-orientation":N(n).orientation.value,"data-active":e.active?``:void 0,"data-disabled":e.focusable?void 0:``,as:e.as,"as-child":e.asChild,onMousedown:t[0]||=t=>{e.focusable?N(n).onItemFocus(i.value):t.preventDefault()},onFocus:t[1]||=e=>N(n).onItemFocus(i.value),onKeydown:c},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`data-active`,`data-disabled`,`as`,`as-child`])]),_:3}))}}),[Ib,Lb]=oy(`TabsRoot`),Rb=F({__name:`TabsRoot`,props:{defaultValue:{type:null,required:!1},orientation:{type:String,required:!1,default:`horizontal`},dir:{type:String,required:!1},activationMode:{type:String,required:!1,default:`automatic`},modelValue:{type:null,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,{orientation:i,unmountOnHide:a,dir:o}=yn(n),s=Uy(o);Gy();let c=Iy(n,`modelValue`,r,{defaultValue:n.defaultValue,passive:n.modelValue===void 0}),l=M(),u=un(new Set);return Lb({modelValue:c,changeModelValue:e=>{c.value=e},orientation:i,dir:s,unmountOnHide:a,activationMode:n.activationMode,baseId:Yy(void 0,`reka-tabs`),tabsList:l,contentIds:u,registerContent:e=>{u.value=new Set([...u.value,e])},unregisterContent:e=>{let t=new Set(u.value);t.delete(e),u.value=t}}),(e,t)=>(R(),B(N(nb),{dir:N(s),"data-orientation":N(i),"as-child":e.asChild,as:e.as},{default:P(()=>[I(e.$slots,`default`,{modelValue:N(c)})]),_:3},8,[`dir`,`data-orientation`,`as-child`,`as`]))}});function zb(e,t){return`${e}-trigger-${t}`}function Bb(e,t){return`${e}-content-${t}`}var Vb=F({__name:`TabsContent`,props:{value:{type:[String,Number],required:!0},forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{forwardRef:n}=Gy(),r=Ib(),i=W(()=>zb(r.baseId,t.value)),a=W(()=>Bb(r.baseId,t.value)),o=W(()=>t.value===r.modelValue.value),s=M(o.value);return Zi(()=>{r.registerContent(t.value),requestAnimationFrame(()=>{s.value=!1})}),ea(()=>{r.unregisterContent(t.value)}),(e,t)=>(R(),B(N($y),{present:e.forceMount||o.value,"force-mount":``},{default:P(({present:t})=>[H(N(nb),{id:a.value,ref:N(n),"as-child":e.asChild,as:e.as,role:`tabpanel`,"data-state":o.value?`active`:`inactive`,"data-orientation":N(r).orientation.value,"aria-labelledby":i.value,hidden:!t,tabindex:`0`,style:ge({animationDuration:s.value?`0s`:void 0})},{default:P(()=>[!N(r).unmountOnHide.value||t?I(e.$slots,`default`,{key:0}):Ts(`v-if`,!0)]),_:2},1032,[`id`,`as-child`,`as`,`data-state`,`data-orientation`,`aria-labelledby`,`hidden`,`style`])]),_:3},8,[`present`]))}}),Hb=F({__name:`TabsList`,props:{loop:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let{loop:t}=yn(e),{forwardRef:n,currentElement:r}=Gy(),i=Ib();return i.tabsList=r,(e,r)=>(R(),B(N(Pb),{"as-child":``,orientation:N(i).orientation.value,dir:N(i).dir.value,loop:N(t)},{default:P(()=>[H(N(nb),{ref:N(n),role:`tablist`,"as-child":e.asChild,as:e.as,"aria-orientation":N(i).orientation.value},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`aria-orientation`])]),_:3},8,[`orientation`,`dir`,`loop`]))}}),Ub=F({__name:`TabsTrigger`,props:{value:{type:[String,Number],required:!0},disabled:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e,{forwardRef:n}=Gy(),r=Ib(),i=W(()=>zb(r.baseId,t.value)),a=W(()=>r.contentIds.value.has(t.value)?Bb(r.baseId,t.value):void 0),o=W(()=>t.value===r.modelValue.value);return(e,t)=>(R(),B(N(Fb),{"as-child":``,focusable:!e.disabled,active:o.value},{default:P(()=>[H(N(nb),{id:i.value,ref:N(n),role:`tab`,type:e.as===`button`?`button`:void 0,as:e.as,"as-child":e.asChild,"aria-selected":o.value?`true`:`false`,"aria-controls":a.value,"data-state":o.value?`active`:`inactive`,disabled:e.disabled,"data-disabled":e.disabled?``:void 0,"data-orientation":N(r).orientation.value,onMousedown:t[0]||=iu(t=>{!e.disabled&&t.ctrlKey===!1?N(r).changeModelValue(e.value):t.preventDefault()},[`left`]),onKeydown:t[1]||=ou(t=>N(r).changeModelValue(e.value),[`enter`,`space`]),onFocus:t[2]||=()=>{let t=N(r).activationMode!==`manual`;!o.value&&!e.disabled&&t&&N(r).changeModelValue(e.value)}},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`id`,`type`,`as`,`as-child`,`aria-selected`,`aria-controls`,`data-state`,`disabled`,`data-disabled`,`data-orientation`])]),_:3},8,[`focusable`,`active`]))}}),Wb=F({__name:`Button`,props:{variant:{},size:{},class:{type:[Boolean,null,String,Object,Array]},asChild:{type:Boolean},as:{default:`button`}},setup(e){let t=e;return(n,r)=>(R(),B(N(nb),{"data-slot":`button`,"data-variant":e.variant,"data-size":e.size,as:e.as,"as-child":e.asChild,class:O(N(Yv)(N(Gb)({variant:e.variant,size:e.size}),t.class))},{default:P(()=>[I(n.$slots,`default`)]),_:3},8,[`data-variant`,`data-size`,`as`,`as-child`,`class`]))}}),Gb=C_(`focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 rounded-lg border border-transparent bg-clip-padding text-sm font-medium focus-visible:ring-3 aria-invalid:ring-3 active:not-aria-[haspopup]:translate-y-px [&_svg:not([class*=size-])]:size-4 group/button inline-flex shrink-0 items-center justify-center whitespace-nowrap transition-all outline-none select-none disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0`,{variants:{variant:{default:`bg-primary text-primary-foreground [a]:hover:bg-primary/80`,outline:`border-border bg-background hover:bg-muted hover:text-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50 aria-expanded:bg-muted aria-expanded:text-foreground`,secondary:`bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground`,ghost:`hover:bg-muted hover:text-foreground dark:hover:bg-muted/50 aria-expanded:bg-muted aria-expanded:text-foreground`,destructive:`bg-destructive/10 hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/20 text-destructive focus-visible:border-destructive/40 dark:hover:bg-destructive/30`,link:`text-primary underline-offset-4 hover:underline`},size:{default:`h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2`,xs:`h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*=size-])]:size-3`,sm:`h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*=size-])]:size-3.5`,lg:`h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2`,icon:`size-8`,"icon-xs":`size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*=size-])]:size-3`,"icon-sm":`size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg`,"icon-lg":`size-9`}},defaultVariants:{variant:`default`,size:`default`}}),Kb=[`data-size`],qb=F({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e;return(n,r)=>(R(),z(`div`,{"data-slot":`card`,"data-size":e.size,class:O(N(Yv)(`ring-foreground/10 bg-card text-card-foreground gap-4 overflow-hidden rounded-xl py-4 text-sm ring-1 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl group/card flex flex-col`,t.class))},[I(n.$slots,`default`)],10,Kb))}}),Jb=F({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-content`,class:O(N(Yv)(`px-4 group-data-[size=sm]/card:px-3`,t.class))},[I(e.$slots,`default`)],2))}}),Yb=F({__name:`CardDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-description`,class:O(N(Yv)(`text-muted-foreground text-sm`,t.class))},[I(e.$slots,`default`)],2))}}),Xb=F({__name:`CardHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-header`,class:O(N(Yv)(`gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3 group/card-header @container/card-header grid auto-rows-min items-start has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto]`,t.class))},[I(e.$slots,`default`)],2))}}),Zb=F({__name:`CardTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-title`,class:O(N(Yv)(`text-base leading-snug font-medium group-data-[size=sm]/card:text-sm cn-font-heading`,t.class))},[I(e.$slots,`default`)],2))}}),Qb=F({__name:`Input`,props:{defaultValue:{},modelValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=Iy(n,`modelValue`,t,{passive:!0,defaultValue:n.defaultValue});return(e,t)=>gr((R(),z(`input`,{"onUpdate:modelValue":t[0]||=e=>j(r)?r.value=e:null,"data-slot":`input`,class:O(N(Yv)(`dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 disabled:bg-input/50 dark:disabled:bg-input/80 h-8 rounded-lg border bg-transparent px-2.5 py-1 text-base transition-colors file:h-6 file:text-sm file:font-medium focus-visible:ring-3 aria-invalid:ring-3 md:text-sm w-full min-w-0 outline-none file:inline-flex file:border-0 file:bg-transparent file:text-foreground placeholder:text-muted-foreground disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50`,n.class))},null,2)),[[Wl,N(r)]])}}),$b=`llmgwAdminKey`;function ex(){try{return sessionStorage.getItem($b)??``}catch{return``}}function tx(e){try{sessionStorage.setItem($b,e)}catch{}}function nx(){try{sessionStorage.removeItem($b)}catch{}}var rx=t_(`auth`,{state:()=>({apiKey:ex(),error:``}),getters:{isAuthenticated:e=>e.apiKey!==``},actions:{submit(e){e&&(this.apiKey=e,this.error=``,tx(e))},reject(e){this.apiKey=``,this.error=e,nx()}}}),ix=class extends Error{status;constructor(e,t){super(e),this.name=`AdminApiError`,this.status=t}};async function ax(e){let t=rx(),n=t.apiKey,r=await fetch(e,{credentials:`same-origin`,headers:n?{"x-api-key":n}:{}});if(r.status===401||r.status===403)throw t.apiKey===n&&t.reject(`invalid key, or not an admin`),new ix(`${e}: HTTP ${r.status}`,r.status);if(!r.ok)throw new ix(`${e}: HTTP ${r.status}`,r.status);return await r.json()}var ox=5e3,sx=t_(`dashboard`,{state:()=>({overview:null,usage:null,targets:null,lastUpdated:null,error:``,timer:void 0}),actions:{async refresh(){if(!rx().isAuthenticated)return;let[e,t,n]=await Promise.allSettled([ax(`/admin/api/overview`),ax(`/admin/api/usage`),ax(`/admin/api/targets`)]);e.status===`fulfilled`&&(this.overview=e.value),t.status===`fulfilled`&&(this.usage=t.value),n.status===`fulfilled`&&(this.targets=n.value);let r=[];if(e.status===`rejected`&&r.push({label:`overview`,reason:e.reason}),t.status===`rejected`&&r.push({label:`usage`,reason:t.reason}),n.status===`rejected`&&r.push({label:`targets`,reason:n.reason}),r.length===0){this.lastUpdated=new Date,this.error=``;return}r.some(({reason:e})=>e instanceof ix&&(e.status===401||e.status===403))||(r.length<3&&(this.lastUpdated=new Date),this.error=r.map(({label:e,reason:t})=>`${e}: ${t instanceof Error?t.message:String(t)}`).join(`; `))},startPolling(){this.timer===void 0&&(this.refresh(),this.timer=setInterval(()=>void this.refresh(),ox))},stopPolling(){this.timer!==void 0&&(clearInterval(this.timer),this.timer=void 0)}}}),cx={class:`mx-auto flex min-h-[70vh] max-w-md flex-col justify-center px-4`},lx={class:`flex size-12 items-center justify-center rounded-full bg-primary/10 text-primary`},ux={class:`flex flex-col items-center gap-1`},dx={"aria-labelledby":`authgate-security-heading`,class:`flex flex-col gap-1.5 text-xs text-muted-foreground`},fx={class:`flex items-start gap-1.5`},px={class:`flex items-start gap-1.5`},mx={class:`flex items-start gap-1.5`},hx={class:`relative`},gx=((e,t)=>{let n=e.__vccOpts||e;for(let[e,r]of t)n[e]=r;return n})(F({__name:`AuthGate`,setup(e){let t=rx(),n=sx(),r=M(``),i=M(!1),a=M(null),o=W(()=>r.value.trim()!==``);function s(){let e=r.value;r.value=``,t.submit(e),n.refresh()}function c(){Qn(()=>a.value?.$el?.focus())}return Zi(c),Er(()=>t.error,e=>{e&&c()}),(e,n)=>{let c=ca(`FontAwesomeIcon`);return R(),z(`div`,cx,[H(N(qb),null,{default:P(()=>[H(N(Xb),{class:`flex flex-col items-center gap-3 text-center`},{default:P(()=>[V(`div`,lx,[H(c,{icon:N(i_),class:`size-5`,"aria-hidden":`true`},null,8,[`icon`])]),V(`div`,ux,[n[3]||=V(`span`,{class:`text-xs font-medium text-muted-foreground`},`LLM Gateway`,-1),H(N(Zb),{class:`text-lg font-semibold`},{default:P(()=>[...n[2]||=[U(`Admin key required`,-1)]]),_:1})]),H(N(Yb),null,{default:P(()=>[...n[4]||=[U(`Enter an admin API key to continue.`,-1)]]),_:1})]),_:1}),H(N(Jb),{class:`flex flex-col gap-4`},{default:P(()=>[n[10]||=V(`h2`,{id:`authgate-security-heading`,class:`sr-only`},` How this key is handled `,-1),V(`ul`,dx,[V(`li`,fx,[H(c,{icon:N(u_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[5]||=V(`span`,null,`Kept only in this tab's session storage`,-1)]),V(`li`,px,[H(c,{icon:N(u_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[6]||=V(`span`,null,`Never written to disk`,-1)]),V(`li`,mx,[H(c,{icon:N(u_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[7]||=V(`span`,null,`Sent only to this page's own /admin/api/* requests`,-1)])]),V(`form`,{class:`flex flex-col gap-3`,onSubmit:iu(s,[`prevent`])},[V(`div`,hx,[H(N(Qb),{ref_key:`keyInputEl`,ref:a,modelValue:r.value,"onUpdate:modelValue":n[0]||=e=>r.value=e,type:i.value?`text`:`password`,autocomplete:`off`,placeholder:`API key`,"aria-label":`Admin API key`,"aria-invalid":!!N(t).error,"aria-describedby":N(t).error?`authgate-error`:void 0,class:O([`h-10 pr-10`,{"authgate-shake":N(t).error}])},null,8,[`modelValue`,`type`,`aria-invalid`,`aria-describedby`,`class`]),H(N(Wb),{type:`button`,variant:`ghost`,size:`icon-xs`,class:`absolute top-1/2 right-1.5 -translate-y-1/2 text-muted-foreground hover:text-foreground`,"aria-label":i.value?`Hide key`:`Show key`,onClick:n[1]||=e=>i.value=!i.value},{default:P(()=>[H(c,{icon:i.value?N(__):N(o_),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`aria-label`])]),H(N(Wb),{type:`submit`,class:`w-full`,disabled:!o.value},{default:P(()=>[...n[8]||=[U(` Continue `,-1)]]),_:1},8,[`disabled`])],32),N(t).error?(R(),B(N(Xv),{key:0,id:`authgate-error`,variant:`destructive`},{default:P(()=>[H(N(Qv),null,{default:P(()=>[...n[9]||=[U(`Authentication failed`,-1)]]),_:1}),H(N(Zv),null,{default:P(()=>[U(k(N(t).error),1)]),_:1})]),_:1})):Ts(``,!0)]),_:1})]),_:1})])}}}),[[`__scopeId`,`data-v-4be6bc09`]]);function _x(e,t){return typeof e==`function`?e(t):e}function vx(e,t){return n=>{t.setState(t=>({...t,[e]:_x(n,t[e])}))}}function yx(e){return e instanceof Function}function bx(e){return Array.isArray(e)&&e.every(e=>typeof e==`number`)}function xx(e,t){let n=[],r=e=>{e.forEach(e=>{n.push(e);let i=t(e);i!=null&&i.length&&r(i)})};return r(e),n}function Q(e,t,n){let r=[],i;return a=>{let o;n.key&&n.debug&&(o=Date.now());let s=e(a);if(!(s.length!==r.length||s.some((e,t)=>r[t]!==e)))return i;r=s;let c;if(n.key&&n.debug&&(c=Date.now()),i=t(...s),n==null||n.onChange==null||n.onChange(i),n.key&&n.debug&&n!=null&&n.debug()){let e=Math.round((Date.now()-o)*100)/100,t=Math.round((Date.now()-c)*100)/100,r=t/16,i=(e,t)=>{for(e=String(e);e.length<t;)e=` `+e;return e};console.info(`%c⏱ ${i(t,5)} /${i(e,5)} ms`,`
            font-size: .6rem;
            font-weight: bold;
            color: hsl(${Math.max(0,Math.min(120-120*r,120))}deg 100% 31%);`,n?.key)}return i}}function $(e,t,n,r){return{debug:()=>e?.debugAll??e[t],key:!1,onChange:r}}function Sx(e,t,n,r){let i={id:`${t.id}_${n.id}`,row:t,column:n,getValue:()=>t.getValue(r),renderValue:()=>i.getValue()??e.options.renderFallbackValue,getContext:Q(()=>[e,n,t,i],(e,t,n,r)=>({table:e,column:t,row:n,cell:r,getValue:r.getValue,renderValue:r.renderValue}),$(e.options,`debugCells`,`cell.getContext`))};return e._features.forEach(r=>{r.createCell==null||r.createCell(i,n,t,e)},{}),i}function Cx(e,t,n,r){let i={...e._getDefaultColumnDef(),...t},a=i.accessorKey,o=i.id??(a?typeof String.prototype.replaceAll==`function`?a.replaceAll(`.`,`_`):a.replace(/\./g,`_`):void 0)??(typeof i.header==`string`?i.header:void 0),s;if(i.accessorFn?s=i.accessorFn:a&&(s=a.includes(`.`)?e=>{let t=e;for(let e of a.split(`.`))t=t?.[e];return t}:e=>e[i.accessorKey]),!o)throw Error();let c={id:`${String(o)}`,accessorFn:s,parent:r,depth:n,columnDef:i,columns:[],getFlatColumns:Q(()=>[!0],()=>[c,...c.columns?.flatMap(e=>e.getFlatColumns())],$(e.options,`debugColumns`,`column.getFlatColumns`)),getLeafColumns:Q(()=>[e._getOrderColumnsFn()],e=>{var t;return(t=c.columns)!=null&&t.length?e(c.columns.flatMap(e=>e.getLeafColumns())):[c]},$(e.options,`debugColumns`,`column.getLeafColumns`))};for(let t of e._features)t.createColumn==null||t.createColumn(c,e);return c}var wx=`debugHeaders`;function Tx(e,t,n){let r={id:n.id??t.id,column:t,index:n.index,isPlaceholder:!!n.isPlaceholder,placeholderId:n.placeholderId,depth:n.depth,subHeaders:[],colSpan:0,rowSpan:0,headerGroup:null,getLeafHeaders:()=>{let e=[],t=n=>{n.subHeaders&&n.subHeaders.length&&n.subHeaders.map(t),e.push(n)};return t(r),e},getContext:()=>({table:e,header:r,column:t})};return e._features.forEach(t=>{t.createHeader==null||t.createHeader(r,e)}),r}var Ex={createTable:e=>{e.getHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(t,n,r,i)=>{let a=r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],o=i?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],s=n.filter(e=>!(r!=null&&r.includes(e.id))&&!(i!=null&&i.includes(e.id)));return Dx(t,[...a,...s,...o],e)},$(e.options,wx,`getHeaderGroups`)),e.getCenterHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(t,n,r,i)=>(n=n.filter(e=>!(r!=null&&r.includes(e.id))&&!(i!=null&&i.includes(e.id))),Dx(t,n,e,`center`)),$(e.options,wx,`getCenterHeaderGroups`)),e.getLeftHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left],(t,n,r)=>Dx(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`left`),$(e.options,wx,`getLeftHeaderGroups`)),e.getRightHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.right],(t,n,r)=>Dx(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`right`),$(e.options,wx,`getRightHeaderGroups`)),e.getFooterGroups=Q(()=>[e.getHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getFooterGroups`)),e.getLeftFooterGroups=Q(()=>[e.getLeftHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getLeftFooterGroups`)),e.getCenterFooterGroups=Q(()=>[e.getCenterHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getCenterFooterGroups`)),e.getRightFooterGroups=Q(()=>[e.getRightHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getRightFooterGroups`)),e.getFlatHeaders=Q(()=>[e.getHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getFlatHeaders`)),e.getLeftFlatHeaders=Q(()=>[e.getLeftHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getLeftFlatHeaders`)),e.getCenterFlatHeaders=Q(()=>[e.getCenterHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getCenterFlatHeaders`)),e.getRightFlatHeaders=Q(()=>[e.getRightHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getRightFlatHeaders`)),e.getCenterLeafHeaders=Q(()=>[e.getCenterFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getCenterLeafHeaders`)),e.getLeftLeafHeaders=Q(()=>[e.getLeftFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getLeftLeafHeaders`)),e.getRightLeafHeaders=Q(()=>[e.getRightFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getRightLeafHeaders`)),e.getLeafHeaders=Q(()=>[e.getLeftHeaderGroups(),e.getCenterHeaderGroups(),e.getRightHeaderGroups()],(e,t,n)=>[...e[0]?.headers??[],...t[0]?.headers??[],...n[0]?.headers??[]].map(e=>e.getLeafHeaders()).flat(),$(e.options,wx,`getLeafHeaders`))}};function Dx(e,t,n,r){let i=0,a=function(e,t){t===void 0&&(t=1),i=Math.max(i,t),e.filter(e=>e.getIsVisible()).forEach(e=>{var n;(n=e.columns)!=null&&n.length&&a(e.columns,t+1)},0)};a(e);let o=[],s=(e,t)=>{let i={depth:t,id:[r,`${t}`].filter(Boolean).join(`_`),headers:[]},a=[];e.forEach(e=>{let o=[...a].reverse()[0],s=e.column.depth===i.depth,c,l=!1;if(s&&e.column.parent?c=e.column.parent:(c=e.column,l=!0),o&&o?.column===c)o.subHeaders.push(e);else{let i=Tx(n,c,{id:[r,t,c.id,e?.id].filter(Boolean).join(`_`),isPlaceholder:l,placeholderId:l?`${a.filter(e=>e.column===c).length}`:void 0,depth:t,index:a.length});i.subHeaders.push(e),a.push(i)}i.headers.push(e),e.headerGroup=i}),o.push(i),t>0&&s(a,t-1)};s(t.map((e,t)=>Tx(n,e,{depth:i,index:t})),i-1),o.reverse();let c=e=>e.filter(e=>e.column.getIsVisible()).map(e=>{let t=0,n=0,r=[0];e.subHeaders&&e.subHeaders.length?(r=[],c(e.subHeaders).forEach(e=>{let{colSpan:n,rowSpan:i}=e;t+=n,r.push(i)})):t=1;let i=Math.min(...r);return n+=i,e.colSpan=t,e.rowSpan=n,{colSpan:t,rowSpan:n}});return c(o[0]?.headers??[]),o}var Ox=(e,t,n,r,i,a,o)=>{let s={id:t,index:r,original:n,depth:i,parentId:o,_valuesCache:{},_uniqueValuesCache:{},getValue:t=>{if(s._valuesCache.hasOwnProperty(t))return s._valuesCache[t];let n=e.getColumn(t);if(n!=null&&n.accessorFn)return s._valuesCache[t]=n.accessorFn(s.original,r),s._valuesCache[t]},getUniqueValues:t=>{if(s._uniqueValuesCache.hasOwnProperty(t))return s._uniqueValuesCache[t];let n=e.getColumn(t);if(n!=null&&n.accessorFn)return n.columnDef.getUniqueValues?(s._uniqueValuesCache[t]=n.columnDef.getUniqueValues(s.original,r),s._uniqueValuesCache[t]):(s._uniqueValuesCache[t]=[s.getValue(t)],s._uniqueValuesCache[t])},renderValue:t=>s.getValue(t)??e.options.renderFallbackValue,subRows:a??[],getLeafRows:()=>xx(s.subRows,e=>e.subRows),getParentRow:()=>s.parentId?e.getRow(s.parentId,!0):void 0,getParentRows:()=>{let e=[],t=s;for(;;){let n=t.getParentRow();if(!n)break;e.push(n),t=n}return e.reverse()},getAllCells:Q(()=>[e.getAllLeafColumns()],t=>t.map(t=>Sx(e,s,t,t.id)),$(e.options,`debugRows`,`getAllCells`)),_getAllCellsByColumnId:Q(()=>[s.getAllCells()],e=>e.reduce((e,t)=>(e[t.column.id]=t,e),{}),$(e.options,`debugRows`,`getAllCellsByColumnId`))};for(let t=0;t<e._features.length;t++){let n=e._features[t];n==null||n.createRow==null||n.createRow(s,e)}return s},kx={createColumn:(e,t)=>{e._getFacetedRowModel=t.options.getFacetedRowModel&&t.options.getFacetedRowModel(t,e.id),e.getFacetedRowModel=()=>e._getFacetedRowModel?e._getFacetedRowModel():t.getPreFilteredRowModel(),e._getFacetedUniqueValues=t.options.getFacetedUniqueValues&&t.options.getFacetedUniqueValues(t,e.id),e.getFacetedUniqueValues=()=>e._getFacetedUniqueValues?e._getFacetedUniqueValues():new Map,e._getFacetedMinMaxValues=t.options.getFacetedMinMaxValues&&t.options.getFacetedMinMaxValues(t,e.id),e.getFacetedMinMaxValues=()=>{if(e._getFacetedMinMaxValues)return e._getFacetedMinMaxValues()}}},Ax=(e,t,n)=>{var r,i;let a=n==null||(r=n.toString())==null?void 0:r.toLowerCase();return!!((i=e.getValue(t))!=null&&(i=i.toString())!=null&&(i=i.toLowerCase())!=null&&i.includes(a))};Ax.autoRemove=e=>Bx(e);var jx=(e,t,n)=>{var r;return!!((r=e.getValue(t))!=null&&(r=r.toString())!=null&&r.includes(n))};jx.autoRemove=e=>Bx(e);var Mx=(e,t,n)=>{var r;return((r=e.getValue(t))==null||(r=r.toString())==null?void 0:r.toLowerCase())===n?.toLowerCase()};Mx.autoRemove=e=>Bx(e);var Nx=(e,t,n)=>e.getValue(t)?.includes(n);Nx.autoRemove=e=>Bx(e);var Px=(e,t,n)=>!n.some(n=>{var r;return!((r=e.getValue(t))!=null&&r.includes(n))});Px.autoRemove=e=>Bx(e)||!(e!=null&&e.length);var Fx=(e,t,n)=>n.some(n=>e.getValue(t)?.includes(n));Fx.autoRemove=e=>Bx(e)||!(e!=null&&e.length);var Ix=(e,t,n)=>e.getValue(t)===n;Ix.autoRemove=e=>Bx(e);var Lx=(e,t,n)=>e.getValue(t)==n;Lx.autoRemove=e=>Bx(e);var Rx=(e,t,n)=>{let[r,i]=n,a=e.getValue(t);return a>=r&&a<=i};Rx.resolveFilterValue=e=>{let[t,n]=e,r=typeof t==`number`?t:parseFloat(t),i=typeof n==`number`?n:parseFloat(n),a=t===null||Number.isNaN(r)?-1/0:r,o=n===null||Number.isNaN(i)?1/0:i;if(a>o){let e=a;a=o,o=e}return[a,o]},Rx.autoRemove=e=>Bx(e)||Bx(e[0])&&Bx(e[1]);var zx={includesString:Ax,includesStringSensitive:jx,equalsString:Mx,arrIncludes:Nx,arrIncludesAll:Px,arrIncludesSome:Fx,equals:Ix,weakEquals:Lx,inNumberRange:Rx};function Bx(e){return e==null||e===``}var Vx={getDefaultColumnDef:()=>({filterFn:`auto`}),getInitialState:e=>({columnFilters:[],...e}),getDefaultOptions:e=>({onColumnFiltersChange:vx(`columnFilters`,e),filterFromLeafRows:!1,maxLeafRowFilterDepth:100}),createColumn:(e,t)=>{e.getAutoFilterFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);return typeof n==`string`?zx.includesString:typeof n==`number`?zx.inNumberRange:typeof n==`boolean`||typeof n==`object`&&n?zx.equals:Array.isArray(n)?zx.arrIncludes:zx.weakEquals},e.getFilterFn=()=>yx(e.columnDef.filterFn)?e.columnDef.filterFn:e.columnDef.filterFn===`auto`?e.getAutoFilterFn():t.options.filterFns?.[e.columnDef.filterFn]??zx[e.columnDef.filterFn],e.getCanFilter=()=>(e.columnDef.enableColumnFilter??!0)&&(t.options.enableColumnFilters??!0)&&(t.options.enableFilters??!0)&&!!e.accessorFn,e.getIsFiltered=()=>e.getFilterIndex()>-1,e.getFilterValue=()=>{var n;return(n=t.getState().columnFilters)==null||(n=n.find(t=>t.id===e.id))==null?void 0:n.value},e.getFilterIndex=()=>t.getState().columnFilters?.findIndex(t=>t.id===e.id)??-1,e.setFilterValue=n=>{t.setColumnFilters(t=>{let r=e.getFilterFn(),i=t?.find(t=>t.id===e.id),a=_x(n,i?i.value:void 0);if(Hx(r,a,e))return t?.filter(t=>t.id!==e.id)??[];let o={id:e.id,value:a};return i?t?.map(t=>t.id===e.id?o:t)??[]:t!=null&&t.length?[...t,o]:[o]})}},createRow:(e,t)=>{e.columnFilters={},e.columnFiltersMeta={}},createTable:e=>{e.setColumnFilters=t=>{let n=e.getAllLeafColumns();e.options.onColumnFiltersChange==null||e.options.onColumnFiltersChange(e=>_x(t,e)?.filter(e=>{let t=n.find(t=>t.id===e.id);return!(t&&Hx(t.getFilterFn(),e.value,t))}))},e.resetColumnFilters=t=>{e.setColumnFilters(t?[]:e.initialState?.columnFilters??[])},e.getPreFilteredRowModel=()=>e.getCoreRowModel(),e.getFilteredRowModel=()=>(!e._getFilteredRowModel&&e.options.getFilteredRowModel&&(e._getFilteredRowModel=e.options.getFilteredRowModel(e)),e.options.manualFiltering||!e._getFilteredRowModel?e.getPreFilteredRowModel():e._getFilteredRowModel())}};function Hx(e,t,n){return(e&&e.autoRemove?e.autoRemove(t,n):!1)||t===void 0||typeof t==`string`&&!t}var Ux={sum:(e,t,n)=>n.reduce((t,n)=>{let r=n.getValue(e);return t+(typeof r==`number`?r:0)},0),min:(e,t,n)=>{let r;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r>n||r===void 0&&n>=n)&&(r=n)}),r},max:(e,t,n)=>{let r;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r<n||r===void 0&&n>=n)&&(r=n)}),r},extent:(e,t,n)=>{let r,i;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r===void 0?n>=n&&(r=i=n):(r>n&&(r=n),i<n&&(i=n)))}),[r,i]},mean:(e,t)=>{let n=0,r=0;if(t.forEach(t=>{let i=t.getValue(e);i!=null&&(i=+i)>=i&&(++n,r+=i)}),n)return r/n},median:(e,t)=>{if(!t.length)return;let n=t.map(t=>t.getValue(e));if(!bx(n))return;if(n.length===1)return n[0];let r=Math.floor(n.length/2),i=n.sort((e,t)=>e-t);return n.length%2==0?(i[r-1]+i[r])/2:i[r]},unique:(e,t)=>Array.from(new Set(t.map(t=>t.getValue(e))).values()),uniqueCount:(e,t)=>new Set(t.map(t=>t.getValue(e))).size,count:(e,t)=>t.length},Wx={getDefaultColumnDef:()=>({aggregatedCell:e=>{var t;return((t=e.getValue())==null||t.toString==null?void 0:t.toString())??null},aggregationFn:`auto`}),getInitialState:e=>({grouping:[],...e}),getDefaultOptions:e=>({onGroupingChange:vx(`grouping`,e),groupedColumnMode:`reorder`}),createColumn:(e,t)=>{e.toggleGrouping=()=>{t.setGrouping(t=>t!=null&&t.includes(e.id)?t.filter(t=>t!==e.id):[...t??[],e.id])},e.getCanGroup=()=>(e.columnDef.enableGrouping??!0)&&(t.options.enableGrouping??!0)&&(!!e.accessorFn||!!e.columnDef.getGroupingValue),e.getIsGrouped=()=>t.getState().grouping?.includes(e.id),e.getGroupedIndex=()=>t.getState().grouping?.indexOf(e.id),e.getToggleGroupingHandler=()=>{let t=e.getCanGroup();return()=>{t&&e.toggleGrouping()}},e.getAutoAggregationFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);if(typeof n==`number`)return Ux.sum;if(Object.prototype.toString.call(n)===`[object Date]`)return Ux.extent},e.getAggregationFn=()=>{if(!e)throw Error();return yx(e.columnDef.aggregationFn)?e.columnDef.aggregationFn:e.columnDef.aggregationFn===`auto`?e.getAutoAggregationFn():t.options.aggregationFns?.[e.columnDef.aggregationFn]??Ux[e.columnDef.aggregationFn]}},createTable:e=>{e.setGrouping=t=>e.options.onGroupingChange==null?void 0:e.options.onGroupingChange(t),e.resetGrouping=t=>{e.setGrouping(t?[]:e.initialState?.grouping??[])},e.getPreGroupedRowModel=()=>e.getFilteredRowModel(),e.getGroupedRowModel=()=>(!e._getGroupedRowModel&&e.options.getGroupedRowModel&&(e._getGroupedRowModel=e.options.getGroupedRowModel(e)),e.options.manualGrouping||!e._getGroupedRowModel?e.getPreGroupedRowModel():e._getGroupedRowModel())},createRow:(e,t)=>{e.getIsGrouped=()=>!!e.groupingColumnId,e.getGroupingValue=n=>{if(e._groupingValuesCache.hasOwnProperty(n))return e._groupingValuesCache[n];let r=t.getColumn(n);return r!=null&&r.columnDef.getGroupingValue?(e._groupingValuesCache[n]=r.columnDef.getGroupingValue(e.original),e._groupingValuesCache[n]):e.getValue(n)},e._groupingValuesCache={}},createCell:(e,t,n,r)=>{e.getIsGrouped=()=>t.getIsGrouped()&&t.id===n.groupingColumnId,e.getIsPlaceholder=()=>!e.getIsGrouped()&&t.getIsGrouped(),e.getIsAggregated=()=>{var t;return!e.getIsGrouped()&&!e.getIsPlaceholder()&&!!((t=n.subRows)!=null&&t.length)}}};function Gx(e,t,n){if(!(t!=null&&t.length)||!n)return e;let r=e.filter(e=>!t.includes(e.id));return n===`remove`?r:[...t.map(t=>e.find(e=>e.id===t)).filter(Boolean),...r]}var Kx={getInitialState:e=>({columnOrder:[],...e}),getDefaultOptions:e=>({onColumnOrderChange:vx(`columnOrder`,e)}),createColumn:(e,t)=>{e.getIndex=Q(e=>[rS(t,e)],t=>t.findIndex(t=>t.id===e.id),$(t.options,`debugColumns`,`getIndex`)),e.getIsFirstColumn=n=>rS(t,n)[0]?.id===e.id,e.getIsLastColumn=n=>{let r=rS(t,n);return r[r.length-1]?.id===e.id}},createTable:e=>{e.setColumnOrder=t=>e.options.onColumnOrderChange==null?void 0:e.options.onColumnOrderChange(t),e.resetColumnOrder=t=>{e.setColumnOrder(t?[]:e.initialState.columnOrder??[])},e._getOrderColumnsFn=Q(()=>[e.getState().columnOrder,e.getState().grouping,e.options.groupedColumnMode],(e,t,n)=>r=>{let i=[];if(!(e!=null&&e.length))i=r;else{let t=[...e],n=[...r];for(;n.length&&t.length;){let e=t.shift(),r=n.findIndex(t=>t.id===e);r>-1&&i.push(n.splice(r,1)[0])}i=[...i,...n]}return Gx(i,t,n)},$(e.options,`debugTable`,`_getOrderColumnsFn`))}},qx=()=>({left:[],right:[]}),Jx={getInitialState:e=>({columnPinning:qx(),...e}),getDefaultOptions:e=>({onColumnPinningChange:vx(`columnPinning`,e)}),createColumn:(e,t)=>{e.pin=n=>{let r=e.getLeafColumns().map(e=>e.id).filter(Boolean);t.setColumnPinning(e=>n===`right`?{left:(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),right:[...(e?.right??[]).filter(e=>!(r!=null&&r.includes(e))),...r]}:n===`left`?{left:[...(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),...r],right:(e?.right??[]).filter(e=>!(r!=null&&r.includes(e)))}:{left:(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),right:(e?.right??[]).filter(e=>!(r!=null&&r.includes(e)))})},e.getCanPin=()=>e.getLeafColumns().some(e=>(e.columnDef.enablePinning??!0)&&(t.options.enableColumnPinning??t.options.enablePinning??!0)),e.getIsPinned=()=>{let n=e.getLeafColumns().map(e=>e.id),{left:r,right:i}=t.getState().columnPinning,a=n.some(e=>r?.includes(e)),o=n.some(e=>i?.includes(e));return a?`left`:o?`right`:!1},e.getPinnedIndex=()=>{var n;let r=e.getIsPinned();return r?((n=t.getState().columnPinning)==null||(n=n[r])==null?void 0:n.indexOf(e.id))??-1:0}},createRow:(e,t)=>{e.getCenterVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.left,t.getState().columnPinning.right],(e,t,n)=>{let r=[...t??[],...n??[]];return e.filter(e=>!r.includes(e.column.id))},$(t.options,`debugRows`,`getCenterVisibleCells`)),e.getLeftVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.column.id===t)).filter(Boolean).map(e=>({...e,position:`left`})),$(t.options,`debugRows`,`getLeftVisibleCells`)),e.getRightVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.column.id===t)).filter(Boolean).map(e=>({...e,position:`right`})),$(t.options,`debugRows`,`getRightVisibleCells`))},createTable:e=>{e.setColumnPinning=t=>e.options.onColumnPinningChange==null?void 0:e.options.onColumnPinningChange(t),e.resetColumnPinning=t=>e.setColumnPinning(t?qx():e.initialState?.columnPinning??qx()),e.getIsSomeColumnsPinned=t=>{let n=e.getState().columnPinning;return t?!!n[t]?.length:!!(n.left?.length||n.right?.length)},e.getLeftLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),$(e.options,`debugColumns`,`getLeftLeafColumns`)),e.getRightLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),$(e.options,`debugColumns`,`getRightLeafColumns`)),e.getCenterLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(e,t,n)=>{let r=[...t??[],...n??[]];return e.filter(e=>!r.includes(e.id))},$(e.options,`debugColumns`,`getCenterLeafColumns`))}};function Yx(e){return e||(typeof document<`u`?document:null)}var Xx={size:150,minSize:20,maxSize:2**53-1},Zx=()=>({startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,isResizingColumn:!1,columnSizingStart:[]}),Qx={getDefaultColumnDef:()=>Xx,getInitialState:e=>({columnSizing:{},columnSizingInfo:Zx(),...e}),getDefaultOptions:e=>({columnResizeMode:`onEnd`,columnResizeDirection:`ltr`,onColumnSizingChange:vx(`columnSizing`,e),onColumnSizingInfoChange:vx(`columnSizingInfo`,e)}),createColumn:(e,t)=>{e.getSize=()=>{let n=t.getState().columnSizing[e.id];return Math.min(Math.max(e.columnDef.minSize??Xx.minSize,n??e.columnDef.size??Xx.size),e.columnDef.maxSize??Xx.maxSize)},e.getStart=Q(e=>[e,rS(t,e),t.getState().columnSizing],(t,n)=>n.slice(0,e.getIndex(t)).reduce((e,t)=>e+t.getSize(),0),$(t.options,`debugColumns`,`getStart`)),e.getAfter=Q(e=>[e,rS(t,e),t.getState().columnSizing],(t,n)=>n.slice(e.getIndex(t)+1).reduce((e,t)=>e+t.getSize(),0),$(t.options,`debugColumns`,`getAfter`)),e.resetSize=()=>{t.setColumnSizing(t=>{let{[e.id]:n,...r}=t;return r})},e.getCanResize=()=>(e.columnDef.enableResizing??!0)&&(t.options.enableColumnResizing??!0),e.getIsResizing=()=>t.getState().columnSizingInfo.isResizingColumn===e.id},createHeader:(e,t)=>{e.getSize=()=>{let t=0,n=e=>{e.subHeaders.length?e.subHeaders.forEach(n):t+=e.column.getSize()??0};return n(e),t},e.getStart=()=>{if(e.index>0){let t=e.headerGroup.headers[e.index-1];return t.getStart()+t.getSize()}return 0},e.getResizeHandler=n=>{let r=t.getColumn(e.column.id),i=r?.getCanResize();return a=>{if(!r||!i||(a.persist==null||a.persist(),tS(a)&&a.touches&&a.touches.length>1))return;let o=e.getSize(),s=e?e.getLeafHeaders().map(e=>[e.column.id,e.column.getSize()]):[[r.id,r.getSize()]],c=tS(a)?Math.round(a.touches[0].clientX):a.clientX,l={},u=(e,n)=>{typeof n==`number`&&(t.setColumnSizingInfo(e=>{let r=t.options.columnResizeDirection===`rtl`?-1:1,i=(n-(e?.startOffset??0))*r,a=Math.max(i/(e?.startSize??0),-.999999);return e.columnSizingStart.forEach(e=>{let[t,n]=e;l[t]=Math.round(Math.max(n+n*a,0)*100)/100}),{...e,deltaOffset:i,deltaPercentage:a}}),(t.options.columnResizeMode===`onChange`||e===`end`)&&t.setColumnSizing(e=>({...e,...l})))},d=e=>u(`move`,e),f=e=>{u(`end`,e),t.setColumnSizingInfo(e=>({...e,isResizingColumn:!1,startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,columnSizingStart:[]}))},p=Yx(n),m={moveHandler:e=>d(e.clientX),upHandler:e=>{p?.removeEventListener(`mousemove`,m.moveHandler),p?.removeEventListener(`mouseup`,m.upHandler),f(e.clientX)}},h={moveHandler:e=>(e.cancelable&&(e.preventDefault(),e.stopPropagation()),d(e.touches[0].clientX),!1),upHandler:e=>{p?.removeEventListener(`touchmove`,h.moveHandler),p?.removeEventListener(`touchend`,h.upHandler),e.cancelable&&(e.preventDefault(),e.stopPropagation()),f(e.touches[0]?.clientX)}},g=eS()?{passive:!1}:!1;tS(a)?(p?.addEventListener(`touchmove`,h.moveHandler,g),p?.addEventListener(`touchend`,h.upHandler,g)):(p?.addEventListener(`mousemove`,m.moveHandler,g),p?.addEventListener(`mouseup`,m.upHandler,g)),t.setColumnSizingInfo(e=>({...e,startOffset:c,startSize:o,deltaOffset:0,deltaPercentage:0,columnSizingStart:s,isResizingColumn:r.id}))}}},createTable:e=>{e.setColumnSizing=t=>e.options.onColumnSizingChange==null?void 0:e.options.onColumnSizingChange(t),e.setColumnSizingInfo=t=>e.options.onColumnSizingInfoChange==null?void 0:e.options.onColumnSizingInfoChange(t),e.resetColumnSizing=t=>{e.setColumnSizing(t?{}:e.initialState.columnSizing??{})},e.resetHeaderSizeInfo=t=>{e.setColumnSizingInfo(t?Zx():e.initialState.columnSizingInfo??Zx())},e.getTotalSize=()=>e.getHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getLeftTotalSize=()=>e.getLeftHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getCenterTotalSize=()=>e.getCenterHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getRightTotalSize=()=>e.getRightHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0}},$x=null;function eS(){if(typeof $x==`boolean`)return $x;let e=!1;try{let t={get passive(){return e=!0,!1}},n=()=>{};window.addEventListener(`test`,n,t),window.removeEventListener(`test`,n)}catch{e=!1}return $x=e,$x}function tS(e){return e.type===`touchstart`}var nS={getInitialState:e=>({columnVisibility:{},...e}),getDefaultOptions:e=>({onColumnVisibilityChange:vx(`columnVisibility`,e)}),createColumn:(e,t)=>{e.toggleVisibility=n=>{e.getCanHide()&&t.setColumnVisibility(t=>({...t,[e.id]:n??!e.getIsVisible()}))},e.getIsVisible=()=>{let n=e.columns;return(n.length?n.some(e=>e.getIsVisible()):t.getState().columnVisibility?.[e.id])??!0},e.getCanHide=()=>(e.columnDef.enableHiding??!0)&&(t.options.enableHiding??!0),e.getToggleVisibilityHandler=()=>t=>{e.toggleVisibility==null||e.toggleVisibility(t.target.checked)}},createRow:(e,t)=>{e._getAllVisibleCells=Q(()=>[e.getAllCells(),t.getState().columnVisibility],e=>e.filter(e=>e.column.getIsVisible()),$(t.options,`debugRows`,`_getAllVisibleCells`)),e.getVisibleCells=Q(()=>[e.getLeftVisibleCells(),e.getCenterVisibleCells(),e.getRightVisibleCells()],(e,t,n)=>[...e,...t,...n],$(t.options,`debugRows`,`getVisibleCells`))},createTable:e=>{let t=(t,n)=>Q(()=>[n(),n().filter(e=>e.getIsVisible()).map(e=>e.id).join(`_`)],e=>e.filter(e=>e.getIsVisible==null?void 0:e.getIsVisible()),$(e.options,`debugColumns`,t));e.getVisibleFlatColumns=t(`getVisibleFlatColumns`,()=>e.getAllFlatColumns()),e.getVisibleLeafColumns=t(`getVisibleLeafColumns`,()=>e.getAllLeafColumns()),e.getLeftVisibleLeafColumns=t(`getLeftVisibleLeafColumns`,()=>e.getLeftLeafColumns()),e.getRightVisibleLeafColumns=t(`getRightVisibleLeafColumns`,()=>e.getRightLeafColumns()),e.getCenterVisibleLeafColumns=t(`getCenterVisibleLeafColumns`,()=>e.getCenterLeafColumns()),e.setColumnVisibility=t=>e.options.onColumnVisibilityChange==null?void 0:e.options.onColumnVisibilityChange(t),e.resetColumnVisibility=t=>{e.setColumnVisibility(t?{}:e.initialState.columnVisibility??{})},e.toggleAllColumnsVisible=t=>{t??=!e.getIsAllColumnsVisible(),e.setColumnVisibility(e.getAllLeafColumns().reduce((e,n)=>({...e,[n.id]:t||!(n.getCanHide!=null&&n.getCanHide())}),{}))},e.getIsAllColumnsVisible=()=>!e.getAllLeafColumns().some(e=>!(e.getIsVisible!=null&&e.getIsVisible())),e.getIsSomeColumnsVisible=()=>e.getAllLeafColumns().some(e=>e.getIsVisible==null?void 0:e.getIsVisible()),e.getToggleAllColumnsVisibilityHandler=()=>t=>{e.toggleAllColumnsVisible(t.target?.checked)}}};function rS(e,t){return t?t===`center`?e.getCenterVisibleLeafColumns():t===`left`?e.getLeftVisibleLeafColumns():e.getRightVisibleLeafColumns():e.getVisibleLeafColumns()}var iS={createTable:e=>{e._getGlobalFacetedRowModel=e.options.getFacetedRowModel&&e.options.getFacetedRowModel(e,`__global__`),e.getGlobalFacetedRowModel=()=>e.options.manualFiltering||!e._getGlobalFacetedRowModel?e.getPreFilteredRowModel():e._getGlobalFacetedRowModel(),e._getGlobalFacetedUniqueValues=e.options.getFacetedUniqueValues&&e.options.getFacetedUniqueValues(e,`__global__`),e.getGlobalFacetedUniqueValues=()=>e._getGlobalFacetedUniqueValues?e._getGlobalFacetedUniqueValues():new Map,e._getGlobalFacetedMinMaxValues=e.options.getFacetedMinMaxValues&&e.options.getFacetedMinMaxValues(e,`__global__`),e.getGlobalFacetedMinMaxValues=()=>{if(e._getGlobalFacetedMinMaxValues)return e._getGlobalFacetedMinMaxValues()}}},aS={getInitialState:e=>({globalFilter:void 0,...e}),getDefaultOptions:e=>({onGlobalFilterChange:vx(`globalFilter`,e),globalFilterFn:`auto`,getColumnCanGlobalFilter:t=>{var n;let r=(n=e.getCoreRowModel().flatRows[0])==null||(n=n._getAllCellsByColumnId()[t.id])==null?void 0:n.getValue();return typeof r==`string`||typeof r==`number`}}),createColumn:(e,t)=>{e.getCanGlobalFilter=()=>(e.columnDef.enableGlobalFilter??!0)&&(t.options.enableGlobalFilter??!0)&&(t.options.enableFilters??!0)&&((t.options.getColumnCanGlobalFilter==null?void 0:t.options.getColumnCanGlobalFilter(e))??!0)&&!!e.accessorFn},createTable:e=>{e.getGlobalAutoFilterFn=()=>zx.includesString,e.getGlobalFilterFn=()=>{let{globalFilterFn:t}=e.options;return yx(t)?t:t===`auto`?e.getGlobalAutoFilterFn():e.options.filterFns?.[t]??zx[t]},e.setGlobalFilter=t=>{e.options.onGlobalFilterChange==null||e.options.onGlobalFilterChange(t)},e.resetGlobalFilter=t=>{e.setGlobalFilter(t?void 0:e.initialState.globalFilter)}}},oS={getInitialState:e=>({expanded:{},...e}),getDefaultOptions:e=>({onExpandedChange:vx(`expanded`,e),paginateExpandedRows:!0}),createTable:e=>{let t=!1,n=!1;e._autoResetExpanded=()=>{if(!t){e._queue(()=>{t=!0});return}if(e.options.autoResetAll??e.options.autoResetExpanded??!e.options.manualExpanding){if(n)return;n=!0,e._queue(()=>{e.resetExpanded(),n=!1})}},e.setExpanded=t=>e.options.onExpandedChange==null?void 0:e.options.onExpandedChange(t),e.toggleAllRowsExpanded=t=>{t??!e.getIsAllRowsExpanded()?e.setExpanded(!0):e.setExpanded({})},e.resetExpanded=t=>{e.setExpanded(t?{}:e.initialState?.expanded??{})},e.getCanSomeRowsExpand=()=>e.getPrePaginationRowModel().flatRows.some(e=>e.getCanExpand()),e.getToggleAllRowsExpandedHandler=()=>t=>{t.persist==null||t.persist(),e.toggleAllRowsExpanded()},e.getIsSomeRowsExpanded=()=>{let t=e.getState().expanded;return t===!0||Object.values(t).some(Boolean)},e.getIsAllRowsExpanded=()=>{let t=e.getState().expanded;return typeof t==`boolean`?t===!0:!(!Object.keys(t).length||e.getRowModel().flatRows.some(e=>!e.getIsExpanded()))},e.getExpandedDepth=()=>{let t=0;return(e.getState().expanded===!0?Object.keys(e.getRowModel().rowsById):Object.keys(e.getState().expanded)).forEach(e=>{let n=e.split(`.`);t=Math.max(t,n.length)}),t},e.getPreExpandedRowModel=()=>e.getSortedRowModel(),e.getExpandedRowModel=()=>(!e._getExpandedRowModel&&e.options.getExpandedRowModel&&(e._getExpandedRowModel=e.options.getExpandedRowModel(e)),e.options.manualExpanding||!e._getExpandedRowModel?e.getPreExpandedRowModel():e._getExpandedRowModel())},createRow:(e,t)=>{e.toggleExpanded=n=>{t.setExpanded(r=>{let i=r===!0||!!(r!=null&&r[e.id]),a={};if(r===!0?Object.keys(t.getRowModel().rowsById).forEach(e=>{a[e]=!0}):a=r,n??=!i,!i&&n)return{...a,[e.id]:!0};if(i&&!n){let{[e.id]:t,...n}=a;return n}return r})},e.getIsExpanded=()=>{let n=t.getState().expanded;return!!((t.options.getIsRowExpanded==null?void 0:t.options.getIsRowExpanded(e))??(n===!0||n?.[e.id]))},e.getCanExpand=()=>{var n;return(t.options.getRowCanExpand==null?void 0:t.options.getRowCanExpand(e))??((t.options.enableExpanding??!0)&&!!((n=e.subRows)!=null&&n.length))},e.getIsAllParentsExpanded=()=>{let n=!0,r=e;for(;n&&r.parentId;)r=t.getRow(r.parentId,!0),n=r.getIsExpanded();return n},e.getToggleExpandedHandler=()=>{let t=e.getCanExpand();return()=>{t&&e.toggleExpanded()}}}},sS=0,cS=10,lS=()=>({pageIndex:sS,pageSize:cS}),uS={getInitialState:e=>({...e,pagination:{...lS(),...e?.pagination}}),getDefaultOptions:e=>({onPaginationChange:vx(`pagination`,e)}),createTable:e=>{let t=!1,n=!1;e._autoResetPageIndex=()=>{if(!t){e._queue(()=>{t=!0});return}if(e.options.autoResetAll??e.options.autoResetPageIndex??!e.options.manualPagination){if(n)return;n=!0,e._queue(()=>{e.resetPageIndex(),n=!1})}},e.setPagination=t=>e.options.onPaginationChange==null?void 0:e.options.onPaginationChange(e=>_x(t,e)),e.resetPagination=t=>{e.setPagination(t?lS():e.initialState.pagination??lS())},e.setPageIndex=t=>{e.setPagination(n=>{let r=_x(t,n.pageIndex),i=e.options.pageCount===void 0||e.options.pageCount===-1?2**53-1:e.options.pageCount-1;return r=Math.max(0,Math.min(r,i)),{...n,pageIndex:r}})},e.resetPageIndex=t=>{var n;e.setPageIndex(t?sS:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageIndex)??sS)},e.resetPageSize=t=>{var n;e.setPageSize(t?cS:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageSize)??cS)},e.setPageSize=t=>{e.setPagination(e=>{let n=Math.max(1,_x(t,e.pageSize)),r=e.pageSize*e.pageIndex,i=Math.floor(r/n);return{...e,pageIndex:i,pageSize:n}})},e.setPageCount=t=>e.setPagination(n=>{let r=_x(t,e.options.pageCount??-1);return typeof r==`number`&&(r=Math.max(-1,r)),{...n,pageCount:r}}),e.getPageOptions=Q(()=>[e.getPageCount()],e=>{let t=[];return e&&e>0&&(t=[...Array(e)].fill(null).map((e,t)=>t)),t},$(e.options,`debugTable`,`getPageOptions`)),e.getCanPreviousPage=()=>e.getState().pagination.pageIndex>0,e.getCanNextPage=()=>{let{pageIndex:t}=e.getState().pagination,n=e.getPageCount();return n===-1||n!==0&&t<n-1},e.previousPage=()=>e.setPageIndex(e=>e-1),e.nextPage=()=>e.setPageIndex(e=>e+1),e.firstPage=()=>e.setPageIndex(0),e.lastPage=()=>e.setPageIndex(e.getPageCount()-1),e.getPrePaginationRowModel=()=>e.getExpandedRowModel(),e.getPaginationRowModel=()=>(!e._getPaginationRowModel&&e.options.getPaginationRowModel&&(e._getPaginationRowModel=e.options.getPaginationRowModel(e)),e.options.manualPagination||!e._getPaginationRowModel?e.getPrePaginationRowModel():e._getPaginationRowModel()),e.getPageCount=()=>e.options.pageCount??Math.ceil(e.getRowCount()/e.getState().pagination.pageSize),e.getRowCount=()=>e.options.rowCount??e.getPrePaginationRowModel().rows.length}},dS=()=>({top:[],bottom:[]}),fS={getInitialState:e=>({rowPinning:dS(),...e}),getDefaultOptions:e=>({onRowPinningChange:vx(`rowPinning`,e)}),createRow:(e,t)=>{e.pin=(n,r,i)=>{let a=r?e.getLeafRows().map(e=>{let{id:t}=e;return t}):[],o=i?e.getParentRows().map(e=>{let{id:t}=e;return t}):[],s=new Set([...o,e.id,...a]);t.setRowPinning(e=>n===`bottom`?{top:(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),bottom:[...(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e))),...Array.from(s)]}:n===`top`?{top:[...(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),...Array.from(s)],bottom:(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e)))}:{top:(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),bottom:(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e)))})},e.getCanPin=()=>{let{enableRowPinning:n,enablePinning:r}=t.options;return typeof n==`function`?n(e):n??r??!0},e.getIsPinned=()=>{let n=[e.id],{top:r,bottom:i}=t.getState().rowPinning,a=n.some(e=>r?.includes(e)),o=n.some(e=>i?.includes(e));return a?`top`:o?`bottom`:!1},e.getPinnedIndex=()=>{let n=e.getIsPinned();return n?((n===`top`?t.getTopRows():t.getBottomRows())?.map(e=>{let{id:t}=e;return t}))?.indexOf(e.id)??-1:-1}},createTable:e=>{e.setRowPinning=t=>e.options.onRowPinningChange==null?void 0:e.options.onRowPinningChange(t),e.resetRowPinning=t=>e.setRowPinning(t?dS():e.initialState?.rowPinning??dS()),e.getIsSomeRowsPinned=t=>{let n=e.getState().rowPinning;return t?!!n[t]?.length:!!(n.top?.length||n.bottom?.length)},e._getPinnedRows=(t,n,r)=>(e.options.keepPinnedRows??!0?(n??[]).map(t=>{let n=e.getRow(t,!0);return n.getIsAllParentsExpanded()?n:null}):(n??[]).map(e=>t.find(t=>t.id===e))).filter(Boolean).map(e=>({...e,position:r})),e.getTopRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.top],(t,n)=>e._getPinnedRows(t,n,`top`),$(e.options,`debugRows`,`getTopRows`)),e.getBottomRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.bottom],(t,n)=>e._getPinnedRows(t,n,`bottom`),$(e.options,`debugRows`,`getBottomRows`)),e.getCenterRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.top,e.getState().rowPinning.bottom],(e,t,n)=>{let r=new Set([...t??[],...n??[]]);return e.filter(e=>!r.has(e.id))},$(e.options,`debugRows`,`getCenterRows`))}},pS={getInitialState:e=>({rowSelection:{},...e}),getDefaultOptions:e=>({onRowSelectionChange:vx(`rowSelection`,e),enableRowSelection:!0,enableMultiRowSelection:!0,enableSubRowSelection:!0}),createTable:e=>{e.setRowSelection=t=>e.options.onRowSelectionChange==null?void 0:e.options.onRowSelectionChange(t),e.resetRowSelection=t=>e.setRowSelection(t?{}:e.initialState.rowSelection??{}),e.toggleAllRowsSelected=t=>{e.setRowSelection(n=>{t=t===void 0?!e.getIsAllRowsSelected():t;let r={...n},i=e.getPreGroupedRowModel().flatRows;return t?i.forEach(e=>{e.getCanSelect()&&(r[e.id]=!0)}):i.forEach(e=>{delete r[e.id]}),r})},e.toggleAllPageRowsSelected=t=>e.setRowSelection(n=>{let r=t===void 0?!e.getIsAllPageRowsSelected():t,i={...n};return e.getRowModel().rows.forEach(t=>{mS(i,t.id,r,!0,e)}),i}),e.getPreSelectedRowModel=()=>e.getCoreRowModel(),e.getSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getCoreRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getSelectedRowModel`)),e.getFilteredSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getFilteredRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getFilteredSelectedRowModel`)),e.getGroupedSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getSortedRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getGroupedSelectedRowModel`)),e.getIsAllRowsSelected=()=>{let t=e.getFilteredRowModel().flatRows,{rowSelection:n}=e.getState(),r=!!(t.length&&Object.keys(n).length);return r&&t.some(e=>e.getCanSelect()&&!n[e.id])&&(r=!1),r},e.getIsAllPageRowsSelected=()=>{let t=e.getPaginationRowModel().flatRows.filter(e=>e.getCanSelect()),{rowSelection:n}=e.getState(),r=!!t.length;return r&&t.some(e=>!n[e.id])&&(r=!1),r},e.getIsSomeRowsSelected=()=>{let t=Object.keys(e.getState().rowSelection??{}).length;return t>0&&t<e.getFilteredRowModel().flatRows.length},e.getIsSomePageRowsSelected=()=>{let t=e.getPaginationRowModel().flatRows;return!e.getIsAllPageRowsSelected()&&t.filter(e=>e.getCanSelect()).some(e=>e.getIsSelected()||e.getIsSomeSelected())},e.getToggleAllRowsSelectedHandler=()=>t=>{e.toggleAllRowsSelected(t.target.checked)},e.getToggleAllPageRowsSelectedHandler=()=>t=>{e.toggleAllPageRowsSelected(t.target.checked)}},createRow:(e,t)=>{e.toggleSelected=(n,r)=>{let i=e.getIsSelected();t.setRowSelection(a=>{if(n=n===void 0?!i:n,e.getCanSelect()&&i===n)return a;let o={...a};return mS(o,e.id,n,r?.selectChildren??!0,t),o})},e.getIsSelected=()=>{let{rowSelection:n}=t.getState();return gS(e,n)},e.getIsSomeSelected=()=>{let{rowSelection:n}=t.getState();return _S(e,n)===`some`},e.getIsAllSubRowsSelected=()=>{let{rowSelection:n}=t.getState();return _S(e,n)===`all`},e.getCanSelect=()=>typeof t.options.enableRowSelection==`function`?t.options.enableRowSelection(e):t.options.enableRowSelection??!0,e.getCanSelectSubRows=()=>typeof t.options.enableSubRowSelection==`function`?t.options.enableSubRowSelection(e):t.options.enableSubRowSelection??!0,e.getCanMultiSelect=()=>typeof t.options.enableMultiRowSelection==`function`?t.options.enableMultiRowSelection(e):t.options.enableMultiRowSelection??!0,e.getToggleSelectedHandler=()=>{let t=e.getCanSelect();return n=>{t&&e.toggleSelected(n.target?.checked)}}}},mS=(e,t,n,r,i)=>{var a;let o=i.getRow(t,!0);n?(o.getCanMultiSelect()||Object.keys(e).forEach(t=>delete e[t]),o.getCanSelect()&&(e[t]=!0)):delete e[t],r&&(a=o.subRows)!=null&&a.length&&o.getCanSelectSubRows()&&o.subRows.forEach(t=>mS(e,t.id,n,r,i))};function hS(e,t){let n=e.getState().rowSelection,r=[],i={},a=function(e,t){return e.map(e=>{var t;let o=gS(e,n);if(o&&(r.push(e),i[e.id]=e),(t=e.subRows)!=null&&t.length&&(e={...e,subRows:a(e.subRows)}),o)return e}).filter(Boolean)};return{rows:a(t.rows),flatRows:r,rowsById:i}}function gS(e,t){return t[e.id]??!1}function _S(e,t,n){var r;if(!((r=e.subRows)!=null&&r.length))return!1;let i=!0,a=!1;return e.subRows.forEach(e=>{if(!(a&&!i)&&(e.getCanSelect()&&(gS(e,t)?a=!0:i=!1),e.subRows&&e.subRows.length)){let n=_S(e,t);n===`all`?a=!0:(n===`some`&&(a=!0),i=!1)}}),i?`all`:a?`some`:!1}var vS=/([0-9]+)/gm,yS=(e,t,n)=>DS(ES(e.getValue(n)).toLowerCase(),ES(t.getValue(n)).toLowerCase()),bS=(e,t,n)=>DS(ES(e.getValue(n)),ES(t.getValue(n))),xS=(e,t,n)=>TS(ES(e.getValue(n)).toLowerCase(),ES(t.getValue(n)).toLowerCase()),SS=(e,t,n)=>TS(ES(e.getValue(n)),ES(t.getValue(n))),CS=(e,t,n)=>{let r=e.getValue(n),i=t.getValue(n);return r>i?1:r<i?-1:0},wS=(e,t,n)=>TS(e.getValue(n),t.getValue(n));function TS(e,t){return e===t?0:e>t?1:-1}function ES(e){return typeof e==`number`?isNaN(e)||e===1/0||e===-1/0?``:String(e):typeof e==`string`?e:``}function DS(e,t){let n=e.split(vS).filter(Boolean),r=t.split(vS).filter(Boolean);for(;n.length&&r.length;){let e=n.shift(),t=r.shift(),i=parseInt(e,10),a=parseInt(t,10),o=[i,a].sort();if(isNaN(o[0])){if(e>t)return 1;if(t>e)return-1;continue}if(isNaN(o[1]))return isNaN(i)?-1:1;if(i>a)return 1;if(a>i)return-1}return n.length-r.length}var OS={alphanumeric:yS,alphanumericCaseSensitive:bS,text:xS,textCaseSensitive:SS,datetime:CS,basic:wS},kS=[Ex,nS,Kx,Jx,kx,Vx,iS,aS,{getInitialState:e=>({sorting:[],...e}),getDefaultColumnDef:()=>({sortingFn:`auto`,sortUndefined:1}),getDefaultOptions:e=>({onSortingChange:vx(`sorting`,e),isMultiSortEvent:e=>e.shiftKey}),createColumn:(e,t)=>{e.getAutoSortingFn=()=>{let n=t.getFilteredRowModel().flatRows.slice(10),r=!1;for(let t of n){let n=t?.getValue(e.id);if(Object.prototype.toString.call(n)===`[object Date]`)return OS.datetime;if(typeof n==`string`&&(r=!0,n.split(vS).length>1))return OS.alphanumeric}return r?OS.text:OS.basic},e.getAutoSortDir=()=>typeof t.getFilteredRowModel().flatRows[0]?.getValue(e.id)==`string`?`asc`:`desc`,e.getSortingFn=()=>{if(!e)throw Error();return yx(e.columnDef.sortingFn)?e.columnDef.sortingFn:e.columnDef.sortingFn===`auto`?e.getAutoSortingFn():t.options.sortingFns?.[e.columnDef.sortingFn]??OS[e.columnDef.sortingFn]},e.toggleSorting=(n,r)=>{let i=e.getNextSortingOrder(),a=n!=null;t.setSorting(o=>{let s=o?.find(t=>t.id===e.id),c=o?.findIndex(t=>t.id===e.id),l=[],u,d=a?n:i===`desc`;return u=o!=null&&o.length&&e.getCanMultiSort()&&r?s?`toggle`:`add`:o!=null&&o.length&&c!==o.length-1?`replace`:s?`toggle`:`replace`,u===`toggle`&&(a||i||(u=`remove`)),u===`add`?(l=[...o,{id:e.id,desc:d}],l.splice(0,l.length-(t.options.maxMultiSortColCount??2**53-1))):l=u===`toggle`?o.map(t=>t.id===e.id?{...t,desc:d}:t):u===`remove`?o.filter(t=>t.id!==e.id):[{id:e.id,desc:d}],l})},e.getFirstSortDir=()=>e.columnDef.sortDescFirst??t.options.sortDescFirst??e.getAutoSortDir()===`desc`?`desc`:`asc`,e.getNextSortingOrder=n=>{let r=e.getFirstSortDir(),i=e.getIsSorted();return i?i!==r&&(t.options.enableSortingRemoval??!0)&&(!n||(t.options.enableMultiRemove??!0))?!1:i===`desc`?`asc`:`desc`:r},e.getCanSort=()=>(e.columnDef.enableSorting??!0)&&(t.options.enableSorting??!0)&&!!e.accessorFn,e.getCanMultiSort=()=>e.columnDef.enableMultiSort??t.options.enableMultiSort??!!e.accessorFn,e.getIsSorted=()=>{let n=t.getState().sorting?.find(t=>t.id===e.id);return n?n.desc?`desc`:`asc`:!1},e.getSortIndex=()=>t.getState().sorting?.findIndex(t=>t.id===e.id)??-1,e.clearSorting=()=>{t.setSorting(t=>t!=null&&t.length?t.filter(t=>t.id!==e.id):[])},e.getToggleSortingHandler=()=>{let n=e.getCanSort();return r=>{n&&(r.persist==null||r.persist(),e.toggleSorting==null||e.toggleSorting(void 0,e.getCanMultiSort()?t.options.isMultiSortEvent==null?void 0:t.options.isMultiSortEvent(r):!1))}}},createTable:e=>{e.setSorting=t=>e.options.onSortingChange==null?void 0:e.options.onSortingChange(t),e.resetSorting=t=>{e.setSorting(t?[]:e.initialState?.sorting??[])},e.getPreSortedRowModel=()=>e.getGroupedRowModel(),e.getSortedRowModel=()=>(!e._getSortedRowModel&&e.options.getSortedRowModel&&(e._getSortedRowModel=e.options.getSortedRowModel(e)),e.options.manualSorting||!e._getSortedRowModel?e.getPreSortedRowModel():e._getSortedRowModel())}},Wx,oS,uS,fS,pS,Qx];function AS(e){let t=[...kS,...e._features??[]],n={_features:t},r=n._features.reduce((e,t)=>Object.assign(e,t.getDefaultOptions==null?void 0:t.getDefaultOptions(n)),{}),i=e=>n.options.mergeOptions?n.options.mergeOptions(r,e):{...r,...e},a={...e.initialState??{}};n._features.forEach(e=>{a=(e.getInitialState==null?void 0:e.getInitialState(a))??a});let o=[],s=!1,c={_features:t,options:{...r,...e},initialState:a,_queue:e=>{o.push(e),s||(s=!0,Promise.resolve().then(()=>{for(;o.length;)o.shift()();s=!1}).catch(e=>setTimeout(()=>{throw e})))},reset:()=>{n.setState(n.initialState)},setOptions:e=>{let t=_x(e,n.options);n.options=i(t)},getState:()=>n.options.state,setState:e=>{n.options.onStateChange==null||n.options.onStateChange(e)},_getRowId:(e,t,r)=>(n.options.getRowId==null?void 0:n.options.getRowId(e,t,r))??`${r?[r.id,t].join(`.`):t}`,getCoreRowModel:()=>(n._getCoreRowModel||=n.options.getCoreRowModel(n),n._getCoreRowModel()),getRowModel:()=>n.getPaginationRowModel(),getRow:(e,t)=>{let r=(t?n.getPrePaginationRowModel():n.getRowModel()).rowsById[e];if(!r&&(r=n.getCoreRowModel().rowsById[e],!r))throw Error();return r},_getDefaultColumnDef:Q(()=>[n.options.defaultColumn],e=>(e??={},{header:e=>{let t=e.header.column.columnDef;return t.accessorKey?t.accessorKey:t.accessorFn?t.id:null},cell:e=>{var t;return((t=e.renderValue())==null||t.toString==null?void 0:t.toString())??null},...n._features.reduce((e,t)=>Object.assign(e,t.getDefaultColumnDef==null?void 0:t.getDefaultColumnDef()),{}),...e}),$(e,`debugColumns`,`_getDefaultColumnDef`)),_getColumnDefs:()=>n.options.columns,getAllColumns:Q(()=>[n._getColumnDefs()],e=>{let t=function(e,r,i){return i===void 0&&(i=0),e.map(e=>{let a=Cx(n,e,i,r),o=e;return a.columns=o.columns?t(o.columns,a,i+1):[],a})};return t(e)},$(e,`debugColumns`,`getAllColumns`)),getAllFlatColumns:Q(()=>[n.getAllColumns()],e=>e.flatMap(e=>e.getFlatColumns()),$(e,`debugColumns`,`getAllFlatColumns`)),_getAllFlatColumnsById:Q(()=>[n.getAllFlatColumns()],e=>e.reduce((e,t)=>(e[t.id]=t,e),{}),$(e,`debugColumns`,`getAllFlatColumnsById`)),getAllLeafColumns:Q(()=>[n.getAllColumns(),n._getOrderColumnsFn()],(e,t)=>t(e.flatMap(e=>e.getLeafColumns())),$(e,`debugColumns`,`getAllLeafColumns`)),getColumn:e=>n._getAllFlatColumnsById()[e]};Object.assign(n,c);for(let e=0;e<n._features.length;e++){let t=n._features[e];t==null||t.createTable==null||t.createTable(n)}return n}function jS(){return e=>Q(()=>[e.options.data],t=>{let n={rows:[],flatRows:[],rowsById:{}},r=function(t,i,a){i===void 0&&(i=0);let o=[];for(let c=0;c<t.length;c++){let l=Ox(e,e._getRowId(t[c],c,a),t[c],c,i,void 0,a?.id);if(n.flatRows.push(l),n.rowsById[l.id]=l,o.push(l),e.options.getSubRows){var s;l.originalSubRows=e.options.getSubRows(t[c],c),(s=l.originalSubRows)!=null&&s.length&&(l.subRows=r(l.originalSubRows,i+1,l))}}return o};return n.rows=r(t),n},$(e.options,`debugTable`,`getRowModel`,()=>e._autoResetPageIndex()))}function MS(){return e=>Q(()=>[e.getState().sorting,e.getPreSortedRowModel()],(t,n)=>{if(!n.rows.length||!(t!=null&&t.length))return n;let r=e.getState().sorting,i=[],a=r.filter(t=>e.getColumn(t.id)?.getCanSort()),o={};a.forEach(t=>{let n=e.getColumn(t.id);n&&(o[t.id]={sortUndefined:n.columnDef.sortUndefined,invertSorting:n.columnDef.invertSorting,sortingFn:n.getSortingFn()})});let s=e=>{let t=e.map(e=>({...e}));return t.sort((e,t)=>{for(let n=0;n<a.length;n+=1){let r=a[n],i=o[r.id],s=i.sortUndefined,c=r?.desc??!1,l=0;if(s){let n=e.getValue(r.id),i=t.getValue(r.id),a=n===void 0,o=i===void 0;if(a||o){if(s===`first`)return a?-1:1;if(s===`last`)return a?1:-1;l=a&&o?0:a?s:-s}}if(l===0&&(l=i.sortingFn(e,t,r.id)),l!==0)return c&&(l*=-1),i.invertSorting&&(l*=-1),l}return e.index-t.index}),t.forEach(e=>{var t;i.push(e),(t=e.subRows)!=null&&t.length&&(e.subRows=s(e.subRows))}),t};return{rows:s(n.rows),flatRows:i,rowsById:n.rowsById}},$(e.options,`debugTable`,`getSortedRowModel`,()=>e._autoResetPageIndex()))}function NS(){return!0}var PS=Symbol(`merge-proxy`),FS={get(e,t,n){return t===PS?n:e.get(t)},has(e,t){return e.has(t)},set:NS,deleteProperty:NS,getOwnPropertyDescriptor(e,t){return{configurable:!0,enumerable:!0,get(){return e.get(t)},set:NS,deleteProperty:NS}},ownKeys(e){return e.keys()}};function IS(e){return`value`in e?e.value:e}function LS(){var e=[...arguments];return new Proxy({get(t){for(let n=e.length-1;n>=0;n--){let r=IS(e[n])[t];if(r!==void 0)return r}},has(t){for(let n=e.length-1;n>=0;n--)if(t in IS(e[n]))return!0;return!1},keys(){let t=[];for(let n=0;n<e.length;n++)t.push(...Object.keys(IS(e[n])));return[...Array.from(new Set(t))]}},FS)}var RS=F({props:[`render`,`props`],setup:e=>()=>typeof e.render==`function`||typeof e.render==`object`?G(e.render,e.props):e.render});function zS(e){return LS(e,{data:N(e.data)})}function BS(e){let t=j(e.data),n=AS(LS({state:{},onStateChange:()=>{},renderFallbackValue:null,mergeOptions(e,n){return t?{...e,...n}:LS(e,n)}},t?zS(e):e));if(t){let t=un(e.data);Er(t,()=>{n.setState(e=>({...e,data:t.value}))},{immediate:!0})}let r=M(n.initialState);return Cr(()=>{n.setOptions(n=>{let i=new Proxy({},{get:(e,t)=>r.value[t]});return LS(n,t?zS(e):e,{state:LS(i,e.state??{}),onStateChange:t=>{t instanceof Function?r.value=t(r.value):r.value=t,e.onStateChange==null||e.onStateChange(t)}})})}),n}var VS=[`aria-label`],HS=F({__name:`SortHeaderButton`,props:{header:{}},setup(e){let t=e,n=W(()=>t.header.column.getIsSorted()),r=W(()=>n.value===`asc`?a_:n.value===`desc`?v_:d_),i=W(()=>{let e=t.header.column.columnDef.header;return typeof e==`string`?e:t.header.column.id}),a=W(()=>{let e=n.value===`asc`?`ascending`:n.value===`desc`?`descending`:`none`;return`Sort by ${i.value}, currently ${e}`});function o(){t.header.column.toggleSorting(n.value===`asc`)}return(t,i)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`button`,{type:`button`,"aria-label":a.value,class:`inline-flex items-center gap-1 rounded px-1.5 py-0.5 hover:text-foreground focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring`,onClick:o},[e.header.isPlaceholder?Ts(``,!0):(R(),B(N(RS),{key:0,render:e.header.column.columnDef.header,props:e.header.getContext()},null,8,[`render`,`props`])),H(s,{icon:r.value,class:O([`size-3 shrink-0`,n.value?`text-foreground`:`text-muted-foreground/60`]),"aria-hidden":`true`},null,8,[`icon`,`class`])],8,VS)}}}),US={"data-slot":`table-container`,class:`relative w-full overflow-x-auto`},WS=F({__name:`Table`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,US,[V(`table`,{"data-slot":`table`,class:O(N(Yv)(`w-full caption-bottom text-sm`,t.class))},[I(e.$slots,`default`)],2)]))}}),GS=F({__name:`TableBody`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`tbody`,{"data-slot":`table-body`,class:O(N(Yv)(`[&_tr:last-child]:border-0`,t.class))},[I(e.$slots,`default`)],2))}}),KS=F({__name:`TableCell`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`td`,{"data-slot":`table-cell`,class:O(N(Yv)(`p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[I(e.$slots,`default`)],2))}}),qS=F({__name:`TableRow`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`tr`,{"data-slot":`table-row`,class:O(N(Yv)(`hover:bg-muted/50 data-[state=selected]:bg-muted border-b transition-colors has-aria-expanded:bg-muted/50`,t.class))},[I(e.$slots,`default`)],2))}}),JS={class:`flex items-center justify-center py-10`},YS=F({__name:`TableEmpty`,props:{class:{type:[Boolean,null,String,Object,Array]},colspan:{default:1}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(qS,null,{default:P(()=>[H(KS,ks({class:N(Yv)(`p-4 whitespace-nowrap align-middle text-sm text-foreground`,t.class)},N(n)),{default:P(()=>[V(`div`,JS,[I(e.$slots,`default`)])]),_:3},16,[`class`])]),_:3}))}}),XS=F({__name:`TableHead`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`th`,{"data-slot":`table-head`,class:O(N(Yv)(`text-foreground h-10 px-2 text-left align-middle font-medium whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[I(e.$slots,`default`)],2))}}),ZS=F({__name:`TableHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`thead`,{"data-slot":`table-header`,class:O(N(Yv)(`[&_tr]:border-b`,t.class))},[I(e.$slots,`default`)],2))}});function QS(e,t){t.value=typeof e==`function`?e(t.value):e}var $S=F({__name:`DataTable`,props:{columns:{},data:{},rowClass:{type:Function},emptyMessage:{}},setup(e){let t=e,n=M([]),r=BS({get data(){return t.data},get columns(){return t.columns},getCoreRowModel:jS(),getSortedRowModel:MS(),onSortingChange:e=>QS(e,n),state:{get sorting(){return n.value}}});function i(e){if(e===`asc`)return`ascending`;if(e===`desc`)return`descending`}return(t,n)=>(R(),B(N(WS),null,{default:P(()=>[H(N(ZS),null,{default:P(()=>[(R(!0),z(L,null,ma(N(r).getHeaderGroups(),e=>(R(),B(N(qS),{key:e.id},{default:P(()=>[(R(!0),z(L,null,ma(e.headers,e=>(R(),B(N(XS),{key:e.id,class:O(e.column.columnDef.meta?.align===`right`?`text-right`:void 0),"aria-sort":e.column.getCanSort()?i(e.column.getIsSorted())??`none`:void 0},{default:P(()=>[e.column.getCanSort()?(R(),B(HS,{key:0,header:e,class:`-mx-1.5`},null,8,[`header`])):e.isPlaceholder?Ts(``,!0):(R(),B(N(RS),{key:1,render:e.column.columnDef.header,props:e.getContext()},null,8,[`render`,`props`]))]),_:2},1032,[`class`,`aria-sort`]))),128))]),_:2},1024))),128))]),_:1}),H(N(GS),null,{default:P(()=>[N(r).getRowModel().rows.length===0?(R(),B(N(YS),{key:0,colspan:e.columns.length,class:`text-muted-foreground`},{default:P(()=>[U(k(e.emptyMessage??`none`),1)]),_:1},8,[`colspan`])):Ts(``,!0),(R(!0),z(L,null,ma(N(r).getRowModel().rows,t=>(R(),B(N(qS),{key:t.id,class:O(e.rowClass?.(t.original))},{default:P(()=>[(R(!0),z(L,null,ma(t.getVisibleCells(),e=>(R(),B(N(KS),{key:e.id,class:O(e.column.columnDef.meta?.align===`right`?`text-right tabular-nums`:void 0)},{default:P(()=>[H(N(RS),{render:e.column.columnDef.cell,props:e.getContext()},null,8,[`render`,`props`])]),_:2},1032,[`class`]))),128))]),_:2},1032,[`class`]))),128))]),_:1})]),_:1}))}}),eC=F({__name:`Badge`,props:{asChild:{type:Boolean},as:{},variant:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(r,i)=>(R(),B(N(nb),ks({"data-slot":`badge`,"data-variant":e.variant,class:N(Yv)(N(tC)({variant:e.variant}),t.class)},N(n)),{default:P(()=>[I(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),tC=C_(`h-5 gap-1 rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium transition-all has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&>svg]:size-3! group/badge inline-flex w-fit shrink-0 items-center justify-center overflow-hidden whitespace-nowrap focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none`,{variants:{variant:{default:`bg-primary text-primary-foreground [a]:hover:bg-primary/80`,secondary:`bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80`,destructive:`bg-destructive/10 [a]:hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 text-destructive dark:bg-destructive/20`,outline:`border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground`,ghost:`hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50`,link:`text-primary underline-offset-4 hover:underline`}},defaultVariants:{variant:`default`}});async function nC(e,t){if(navigator.clipboard?.writeText)try{return await navigator.clipboard.writeText(e),`copied`}catch{}if(!t)return`failed`;let n=document.createRange();n.selectNodeContents(t);let r=window.getSelection();return r?(r.removeAllRanges(),r.addRange(n),`selected`):`failed`}var rC=`0001-01-01T00:00:00Z`;function iC(e,t){return`${e}/${t}`}function aC(e){return`$${(e/1e6).toFixed(4)}`}function oC(e){return e.toLocaleString(`en-US`)}function sC(e){let t=Math.abs(e);if(t<1e4)return oC(e);let n=e<0?`-`:``,[r,i]=t<1e6?[1e3,`k`]:t<1e9?[1e6,`M`]:[1e9,`B`],a=t/r,o=3-(Math.floor(a)>=100?3:Math.floor(a)>=10?2:1),s=10**o,c=(Math.floor(t*s/r)/s).toFixed(o);return o>0&&(c=c.replace(/0+$/,``).replace(/\.$/,``)),`${n}${c}${i}`}function cC(e){return e>0&&!(e&e-1)}function lC(e){return e<1024?`${e}`:cC(e)?e<1048576?`${Math.round(e/1024)}k`:`${Math.round(e/1048576)}M`:e<1e6?`${Math.round(e/1e3)}k`:`${Math.round(e/1e6)}M`}function uC(e){return`$${e.toFixed(2)}`}function dC(e,t){return e===0&&t===0?`free`:`in ${uC(e)} / out ${uC(t)} per MTok`}function fC(e){return e<1e3?`${Math.round(e)}ms`:`${(e/1e3).toFixed(1)}s`}function pC(e,t){if(!e||e===rC)return null;let n=new Date(e).getTime();return Number.isNaN(n)?null:Math.max(0,Math.round((t-n)/1e3))}function mC(e){let t=pC(e,Date.now());return t===null?``:` (${t}s ago)`}function hC(e,t=Date.now()){let n=pC(e,t);return n===null?``:`${n}s ago`}function gC(e){if(!e||e===rC)return``;let t=new Date(e).getTime();if(Number.isNaN(t))return``;let n=Math.round((t-Date.now())/1e3);return n<=0?``:`in ${n}s`}function _C(e){if(!e||e===rC)return`never`;let t=new Date(e);return Number.isNaN(t.getTime())?e:t.toLocaleString()}function vC(e,t){return e?mC(t)?`refreshed`:`pending`:`off`}function yC(e,t){switch(vC(e,t)){case`off`:return`discovery off`;case`pending`:return`pending`;case`refreshed`:return`refreshed${mC(t)}`}}function bC(e,t){switch(vC(e,t)){case`off`:return`discovery off`;case`pending`:return`pending`;case`refreshed`:return _C(t)}}function xC(e){if(!e)return`none`;let t=[];return e.requestsPerMinute&&t.push(`req/min ${e.requestsPerMinute}`),e.requestsPerDay&&t.push(`req/day ${e.requestsPerDay}`),e.tokensPerDay&&t.push(`tok/day ${e.tokensPerDay}`),e.tokensPerMonth&&t.push(`tok/month ${e.tokensPerMonth}`),e.costPerDayUSD&&t.push(`cost/day $${e.costPerDayUSD}`),e.costPerMonthUSD&&t.push(`cost/month $${e.costPerMonthUSD}`),t.length?t.join(`, `):`none`}function SC(e,t){switch(t){case`hour`:return`${e.slice(8,10)}:00`;case`day`:{let t=Number(e.slice(0,4)),n=Number(e.slice(4,6)),r=Number(e.slice(6,8));return new Date(t,n-1,r).toLocaleDateString(void 0,{month:`short`,day:`numeric`})}case`month`:{let t=Number(e.slice(0,4)),n=Number(e.slice(4,6));return new Date(t,n-1,1).toLocaleDateString(void 0,{month:`short`,year:`numeric`})}}}var CC=F({__name:`ModelChip`,props:{id:{},contextTokens:{},inputPerMTokUsd:{},outputPerMTokUsd:{}},setup(e){let t=e,n=si(`label`),r=M(`idle`),i;function a(){clearTimeout(i),i=setTimeout(()=>{r.value=`idle`},1500)}async function o(){let e=await nC(t.id,n.value??void 0);r.value=e,a()}let s={idle:g_,copied:u_,selected:u_,failed:h_},c=W(()=>({idle:`Copy ${t.id}`,copied:`Copied`,selected:`Selected — press Ctrl/Cmd+C`,failed:`Copy failed`})),l=W(()=>{let e=[];return t.inputPerMTokUsd!==void 0&&t.outputPerMTokUsd!==void 0&&e.push(dC(t.inputPerMTokUsd,t.outputPerMTokUsd)),t.contextTokens!==void 0&&e.push(`${lC(t.contextTokens)} context`),e.join(` · `)}),u=W(()=>{let e=c.value[r.value];return l.value?`${e} · ${l.value}`:e});return ta(()=>{clearTimeout(i)}),(t,n)=>{let i=ca(`FontAwesomeIcon`);return R(),B(N(eC),{as:`button`,type:`button`,variant:`secondary`,class:O([`cursor-pointer gap-1 font-mono text-xs font-normal transition-colors hover:bg-accent hover:text-accent-foreground`,r.value===`failed`?`text-destructive`:``]),title:u.value,"aria-label":u.value,onClick:o},{default:P(()=>[V(`span`,{ref:`label`,class:`select-text`},k(e.id),513),H(i,{icon:s[r.value],class:`size-2.5 shrink-0`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`class`,`title`,`aria-label`])}}});function wC(e,t){return!Number.isFinite(e)||e<=0?null:(e-(Number.isFinite(t)?t:0))/e}function TC(e){return e===null?`no-traffic`:e<.9?`severe`:e<.99?`degraded`:`healthy`}function EC(e,t){let n=wC(e,t);return n!==null&&n<.99}function DC(e){return e>=1?`100%`:`${Math.floor(e*100)}%`}function OC(e,t,n){return e===1?t:n}function kC(e,t){if(e<=0)return`no traffic in the last minute`;let n=wC(e,t),r=n===null?``:` (${DC(n)})`;return`${e} ${OC(e,`attempt`,`attempts`)}, ${t} ${OC(t,`failure`,`failures`)} in the last minute${r}`}function AC(e,t){if(e<=0)return`no traffic today`;let n=wC(e,t),r=n===null?``:` (${DC(n)})`;return`${e} ${OC(e,`attempt`,`attempts`)}, ${t} ${OC(t,`failure`,`failures`)} today${r}`}var jC={"aria-hidden":`true`},MC={class:`sr-only`},NC=F({__name:`ProviderRateBadge`,props:{attemptsDay:{},failuresDay:{},attemptsMinute:{},failuresMinute:{}},setup(e){let t=e,n=W(()=>wC(t.attemptsDay,t.failuresDay)),r=W(()=>TC(n.value)),i=W(()=>r.value===`no-traffic`?`no traffic`:DC(n.value)),a=W(()=>t.attemptsMinute===void 0||t.failuresMinute===void 0?AC(t.attemptsDay,t.failuresDay):kC(t.attemptsMinute,t.failuresMinute)),o=W(()=>r.value===`severe`?`destructive`:r.value===`healthy`?`secondary`:`outline`),s=W(()=>r.value===`degraded`?`border-status-warn/40 text-status-warn`:r.value===`no-traffic`?`text-muted-foreground`:``);return(e,t)=>(R(),B(N(eC),{as:`span`,variant:o.value,class:O([s.value,`font-normal tabular-nums`]),title:a.value},{default:P(()=>[V(`span`,jC,k(i.value),1),V(`span`,MC,k(a.value),1)]),_:1},8,[`variant`,`class`,`title`]))}}),PC=F({__name:`SearchInput`,props:{modelValue:{},placeholder:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=W(()=>n.modelValue.length>0);function a(e){r(`update:modelValue`,String(e))}function o(){r(`update:modelValue`,``)}return(t,r)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`div`,{class:O(N(Yv)(`relative`,n.class))},[H(s,{icon:N(r_),class:`pointer-events-none absolute top-1/2 left-2.5 size-3.5 -translate-y-1/2 text-muted-foreground`,"aria-hidden":`true`},null,8,[`icon`]),H(N(Qb),{"model-value":e.modelValue,type:`text`,placeholder:e.placeholder,"aria-label":e.placeholder,class:`pr-8 pl-8`,"onUpdate:modelValue":a},null,8,[`model-value`,`placeholder`,`aria-label`]),i.value?(R(),B(N(Wb),{key:0,type:`button`,variant:`ghost`,size:`icon-xs`,"aria-label":`Clear search`,class:`absolute top-1/2 right-1 -translate-y-1/2 text-muted-foreground hover:text-foreground`,onClick:o},{default:P(()=>[H(s,{icon:N(f_),class:`size-3.5`},null,8,[`icon`])]),_:1})):Ts(``,!0)],2)}}}),FC=F({__name:`Accordion`,props:{collapsible:{type:Boolean},disabled:{type:Boolean},dir:{},orientation:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},type:{},modelValue:{},defaultValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=qy(Cy(n,`class`),r);return(e,t)=>(R(),B(N(hb),ks({"data-slot":`accordion`},N(i),{class:N(Yv)(`flex w-full flex-col`,n.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`class`]))}}),IC=F({__name:`AccordionContent`,props:{forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(N(bb),ks({"data-slot":`accordion-content`},N(n),{class:`data-open:animate-accordion-down data-closed:animate-accordion-up text-sm overflow-hidden`}),{default:P(()=>[V(`div`,{class:O(N(Yv)(`pt-0 pb-2.5 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4`,t.class))},[I(e.$slots,`default`)],2)]),_:3},16))}}),LC=F({__name:`AccordionItem`,props:{disabled:{type:Boolean},value:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Ky(Cy(t,`class`));return(e,r)=>(R(),B(N(yb),ks({"data-slot":`accordion-item`},N(n),{class:N(Yv)(`not-last:border-b`,t.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`class`]))}}),RC=F({__name:`AccordionTrigger`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>{let i=ca(`FontAwesomeIcon`);return R(),B(N(xb),{class:`flex`},{default:P(()=>[H(N(Sb),ks({"data-slot":`accordion-trigger`},N(n),{class:N(Yv)(`focus-visible:ring-ring/50 focus-visible:border-ring focus-visible:after:border-ring **:data-[slot=accordion-trigger-icon]:text-muted-foreground rounded-lg py-2.5 text-left text-sm font-medium hover:underline focus-visible:ring-3 **:data-[slot=accordion-trigger-icon]:ml-auto **:data-[slot=accordion-trigger-icon]:size-4 group/accordion-trigger relative flex flex-1 items-start justify-between border border-transparent transition-all outline-none disabled:pointer-events-none disabled:opacity-50`,t.class)}),{default:P(()=>[I(e.$slots,`default`),I(e.$slots,`icon`,{},()=>[H(i,{icon:N(m_),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden`},null,8,[`icon`]),H(i,{icon:N(s_),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none hidden shrink-0 group-aria-expanded/accordion-trigger:inline`},null,8,[`icon`])])]),_:3},16,[`class`])]),_:3})}}});function zC(){let e=M(``),t=W(()=>e.value.trim().toLowerCase());return{query:e,normalized:t,hasQuery:W(()=>t.value.length>0)}}function BC(e,t,n){if(!t)return new Set(e.manuallyExpanded);let r=new Set(e.manuallyExpanded);for(let t of n)e.manuallyCollapsed.has(t)||r.add(t);return r}function VC(e,t,n){n?(e.manuallyExpanded.delete(t),e.manuallyCollapsed.add(t)):(e.manuallyCollapsed.delete(t),e.manuallyExpanded.add(t))}function HC(e){e.manuallyCollapsed.clear()}var UC={class:`flex flex-col gap-6`},WC={class:`grid gap-4 sm:grid-cols-3`},GC={class:`font-medium`},KC={key:0,class:`flex items-start gap-1.5 text-destructive`},qC={class:`font-medium`},JC={key:0,class:`text-muted-foreground`},YC={class:`font-medium`},XC={key:0,class:`text-muted-foreground`},ZC={key:0,class:`py-6 text-center text-sm text-muted-foreground`},QC={key:1,class:`py-6 text-center text-sm text-muted-foreground`},$C={class:`flex flex-1 flex-wrap items-center gap-x-3 gap-y-1 pr-2 text-left`},ew={class:`font-medium`},tw={class:`text-xs text-muted-foreground tabular-nums`},nw={class:`text-xs text-muted-foreground`},rw={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-3`},iw={class:`break-all`},aw={key:0},ow={key:1},sw={class:`text-destructive`},cw={key:0,class:`flex flex-wrap gap-1.5`},lw={key:0,title:`context window`,class:`text-xs text-muted-foreground tabular-nums`},uw={key:1,class:`text-sm text-muted-foreground`},dw={key:0,class:`text-xs text-muted-foreground`},fw=`Per-replica, in-process only — not a fleet-wide average across this deployment’s replicas.`,pw=F({__name:`ProvidersView`,setup(e){let t=sx(),n=W(()=>t.overview),r=Zt({manuallyExpanded:new Set,manuallyCollapsed:new Set}),{query:i,normalized:a,hasQuery:o}=zC();function s(e,t){return iC(e,t).toLowerCase().includes(a.value)}function c(e){return e.models.some(t=>s(e.name,t))}function l(e){return e.alias.toLowerCase().includes(a.value)||e.target.toLowerCase().includes(a.value)}let u=W(()=>{let e=n.value?.providers??[];return o.value?e.filter(c):e}),d=W(()=>{let e=n.value?.aliases??[];return o.value?e.filter(l):e}),f=W(()=>BC(r,o.value,u.value.map(e=>e.name)));function p(e){VC(r,e,f.value.has(e))}let m=W({get:()=>Array.from(f.value),set:e=>{let t=new Set(e);for(let e of f.value)t.has(e)||p(e);for(let e of t)f.value.has(e)||p(e)}});Er(i,e=>{e.trim()===``&&HC(r)});function h(e){return o.value?e.models.filter(t=>s(e.name,t)):e.models}let g={attemptsDay:0,failuresDay:0};function _(e,t){return e.modelRates?.[t]??g}function v(e,t){let n=_(e,t);return EC(n.attemptsDay,n.failuresDay)}let y={};function b(e,t){return e.modelMeta?.[t]??y}function x(e){switch(e){case`open`:return`destructive`;case`half-open`:return`secondary`;default:return}}function S(e){let t=gC(e.openUntil);return t?`${e.healthState} (${t})`:e.healthState}function C(e){return e===`open`?`text-destructive`:`text-muted-foreground`}function w(e){return e.latency?.streaming}function ee(e){return e.latency?.[`non-streaming`]}function te(e){return e.count===void 0?`no observations counted`:`${e.count} ${e.count===1?`observation`:`observations`} on this replica`}function T(e){return`Average time to first byte, the load-sensitive reading for streaming traffic. ${te(e)}. ${fw}`}function ne(e){return`Average total response time, including generation — not a load-sensitive signal like streaming ttfb, since this provider buffers the whole completion before sending anything. ${te(e)}. ${fw}`}function re(e){return e.provenance?.estimated}function ie(e){return e.provenance?.unbilled}function E(e){let t=e.requests===1?``:`s`;return`${e.requests} non-streaming response${t} carried no usage from the provider — prompt tokens were estimated from request body size instead (${e.tokens} tokens billed from the estimate), completion billed as zero. ${fw}`}function ae(e){let t=e.requests===1?``:`s`;return`${e.requests} streaming response${t} carried no usage from the provider — the request was counted but zero tokens were billed. If this keeps happening, this provider may be serving completions entirely free against every budget. ${fw}`}let oe=[{id:`alias`,header:`Alias`,accessorFn:e=>e.alias,cell:({row:e})=>G(CC,{id:e.original.alias,contextTokens:e.original.modelMeta?.contextTokens,inputPerMTokUsd:e.original.modelMeta?.inputPerMTokUsd,outputPerMTokUsd:e.original.modelMeta?.outputPerMTokUsd})},{id:`target`,header:`Target`,accessorFn:e=>e.target,cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},e.original.target)}],se=W(()=>n.value?.aliases.length?o.value?`no aliases match "${i.value}"`:`none`:`none configured`);return(e,t)=>{let r=ca(`FontAwesomeIcon`);return R(),z(`div`,UC,[V(`div`,WC,[H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.redis.configured?N(p_):N(c_),class:O([n.value?.redis.configured?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[2]||=U(` Redis `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`flex flex-col gap-1 text-sm`},{default:P(()=>[V(`p`,GC,k(n.value?.redis.configured?`Configured`:`Not configured`),1),n.value?.redis.lastErr?(R(),z(`p`,KC,[H(r,{icon:N(h_),class:`mt-0.5 size-3.5 shrink-0`},null,8,[`icon`]),V(`span`,null,k(n.value.redis.lastErr)+k(N(mC)(n.value.redis.lastErrAt)),1)])):Ts(``,!0)]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.cache.enabled?N(p_):N(c_),class:O([n.value?.cache.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[3]||=U(` Response cache `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`text-sm`},{default:P(()=>[V(`p`,qC,k(n.value?.cache.enabled?`Enabled`:`Disabled`),1),n.value?.cache.enabled?(R(),z(`p`,JC,`ttl `+k(n.value.cache.ttl),1)):Ts(``,!0)]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.retry.enabled?N(p_):N(c_),class:O([n.value?.retry.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[4]||=U(` Retry `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`text-sm`},{default:P(()=>[V(`p`,YC,k(n.value?.retry.enabled?`Enabled`:`Disabled`),1),n.value?.retry.enabled?(R(),z(`p`,XC,` attempts `+k(n.value.retry.attempts)+`, backoff `+k(n.value.retry.backoff),1)):Ts(``,!0)]),_:1})]),_:1})]),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[5]||=[U(`Providers`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[6]||=[U(` Every configured upstream and its last discovery refresh. Search filters providers and aliases by model id. `,-1)]]),_:1}),H(PC,{modelValue:N(i),"onUpdate:modelValue":t[0]||=e=>j(i)?i.value=e:null,placeholder:`Search models or aliases...`,class:`mt-2 max-w-sm`},null,8,[`modelValue`])]),_:1}),H(N(Jb),null,{default:P(()=>[n.value?.providers.length?N(o)&&u.value.length===0?(R(),z(`p`,QC,` no providers match "`+k(N(i))+`" `,1)):(R(),B(N(FC),{key:2,modelValue:m.value,"onUpdate:modelValue":t[1]||=e=>m.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:P(()=>[(R(!0),z(L,null,ma(u.value,e=>(R(),B(N(LC),{key:e.name,value:e.name},{default:P(()=>[H(N(RC),null,{default:P(()=>[V(`span`,$C,[V(`span`,ew,k(e.name),1),H(N(eC),{as:`span`,variant:`secondary`,class:`font-normal`},{default:P(()=>[U(k(e.type),1)]),_:2},1024),V(`span`,tw,k(e.modelCount)+` models`,1),H(NC,{"attempts-day":e.attemptsDay,"failures-day":e.failuresDay,"attempts-minute":e.attemptsMinute,"failures-minute":e.failuresMinute},null,8,[`attempts-day`,`failures-day`,`attempts-minute`,`failures-minute`]),e.healthState===`closed`?Ts(``,!0):(R(),B(N(eC),{key:0,as:`span`,variant:x(e.healthState),class:`font-normal`,title:e.healthState===`open`?`discovery is backing off after repeated failures`:`a discovery probe is deciding whether to recover`},{default:P(()=>[U(k(S(e)),1)]),_:2},1032,[`variant`,`title`])),w(e)?.avgTtfbMs===void 0?Ts(``,!0):(R(),B(N(eC),{key:1,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:T(w(e))},{default:P(()=>[U(` streaming ttfb `+k(N(fC)(w(e).avgTtfbMs)),1)]),_:2},1032,[`title`])),ee(e)?.avgDurationMs===void 0?Ts(``,!0):(R(),B(N(eC),{key:2,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:ne(ee(e))},{default:P(()=>[U(` non-streaming avg `+k(N(fC)(ee(e).avgDurationMs)),1)]),_:2},1032,[`title`])),re(e)?(R(),B(N(eC),{key:3,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:E(re(e))},{default:P(()=>[U(` estimated `+k(re(e).requests),1)]),_:2},1032,[`title`])):Ts(``,!0),ie(e)?(R(),B(N(eC),{key:4,as:`span`,variant:`destructive`,class:`font-normal tabular-nums`,title:ae(ie(e))},{default:P(()=>[U(` unbilled `+k(ie(e).requests),1)]),_:2},1032,[`title`])):Ts(``,!0),e.lastErr?(R(),B(r,{key:5,icon:N(h_),class:`size-3.5 shrink-0 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):Ts(``,!0),V(`span`,nw,k(N(yC)(e.discoveryEnabled,e.lastRefresh)),1)])]),_:2},1024),H(N(IC),null,{default:P(()=>[V(`dl`,rw,[V(`div`,null,[t[7]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Base URL`,-1),V(`dd`,iw,k(e.baseUrl),1)]),V(`div`,null,[t[8]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Last refresh`,-1),V(`dd`,null,k(N(bC)(e.discoveryEnabled,e.lastRefresh)),1)]),e.healthState===`closed`?Ts(``,!0):(R(),z(`div`,aw,[t[9]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Discovery health`,-1),V(`dd`,{class:O(C(e.healthState))},k(S(e)),3)])),e.lastErr?(R(),z(`div`,ow,[t[10]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Last error`,-1),V(`dd`,sw,k(e.lastErr),1)])):Ts(``,!0)]),h(e).length?(R(),z(`div`,cw,[(R(!0),z(L,null,ma(h(e),t=>(R(),z(`span`,{key:t,class:`inline-flex items-center gap-1`},[H(CC,{id:N(iC)(e.name,t),"context-tokens":b(e,t).contextTokens,"input-per-m-tok-usd":b(e,t).inputPerMTokUsd,"output-per-m-tok-usd":b(e,t).outputPerMTokUsd},null,8,[`id`,`context-tokens`,`input-per-m-tok-usd`,`output-per-m-tok-usd`]),b(e,t).contextTokens===void 0?Ts(``,!0):(R(),z(`span`,lw,k(N(lC)(b(e,t).contextTokens)),1)),v(e,t)?(R(),B(NC,{key:1,"attempts-day":_(e,t).attemptsDay,"failures-day":_(e,t).failuresDay},null,8,[`attempts-day`,`failures-day`])):Ts(``,!0)]))),128))])):(R(),z(`p`,uw,`no models known yet`))]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):(R(),z(`p`,ZC,`none`))]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[11]||=[U(`Model aliases`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[12]||=[U(`Operator-defined alias → target model mappings.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:oe,data:d.value,"empty-message":se.value},null,8,[`data`,`empty-message`])]),_:1})]),_:1}),n.value?.version?(R(),z(`p`,dw,`Version: `+k(n.value.version),1)):Ts(``,!0)])}}}),mw=[`title`],hw={"aria-hidden":`true`},gw={class:`sr-only`},_w=F({__name:`CompactNumber`,props:{value:{}},setup(e){let t=e,n=W(()=>sC(t.value)),r=W(()=>oC(t.value));return(e,t)=>(R(),z(`span`,{title:r.value},[V(`span`,hw,k(n.value),1),V(`span`,gw,k(r.value),1)],8,mw))}});function vw(e,t,n){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>G(_w,{value:n(e.original)})}}var yw=`not observed yet — no traffic and probes disabled or not yet run`;function bw(e){let t=hC(e.lastCheck);return t?`unhealthy (${t})`:`unhealthy`}function xw(e){let t=e.consecutiveFailures===1?`failure`:`failures`,n=e.source?` via ${e.source}`:``,r=`${e.consecutiveFailures} consecutive ${t}${n}`;return e.lastError?`${r}: ${e.lastError}`:r}function Sw(e){let t=hC(e.lastCheck);return t?e.source?`${t} via ${e.source}`:t:e.source?`via ${e.source}`:``}function Cw(e){if(e.consecutiveFailures<=0&&!e.lastError)return yw;let t=e.consecutiveFailures===1?`failure`:`failures`,n=e.source?` via ${e.source}`:``,r=`${e.consecutiveFailures} ${t} so far${n}`;return e.lastError?`${r}: ${e.lastError}`:r}function ww(e){if(e.state===`unhealthy`)return G(eC,{as:`span`,variant:`destructive`,class:`font-normal`,title:xw(e)},()=>bw(e));if(e.state===`healthy`){let t=e.latencyMs===void 0?``:` · ${fC(e.latencyMs)}`;return G(`span`,{class:`text-muted-foreground`,title:Sw(e)},`healthy${t}`)}return G(eC,{as:`span`,variant:`outline`,class:`font-normal`,title:Cw(e)},()=>`unknown`)}function Tw(){return[{id:`name`,header:`Name`,accessorFn:e=>e.name,cell:({row:e})=>G(`span`,{class:`font-medium`},e.original.name)},{id:`url`,header:`URL`,accessorFn:e=>e.url,cell:({row:e})=>G(`span`,{class:`block max-w-xs truncate text-muted-foreground`,title:e.original.url},e.original.url)},{id:`health`,header:`Health`,enableSorting:!1,accessorFn:e=>e.health.state,cell:({row:e})=>ww(e.original.health)},{id:`access`,header:`Access`,enableSorting:!1,accessorFn:e=>(e.access??[]).join(`, `),cell:({row:e})=>{let t=e.original.access;return t?.length?G(`div`,{class:`flex flex-wrap gap-1.5`},t.map(e=>G(eC,{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},()=>e))):G(`span`,{class:`text-muted-foreground`},`All groups`)}},vw(`reqMin`,`req/min`,e=>e.counters.requestsPerMinute),vw(`reqDay`,`req/day`,e=>e.counters.requestsPerDay),vw(`reqMonth`,`req/month`,e=>e.counters.requestsPerMonth)]}var Ew={class:`flex flex-col gap-6`},Dw=F({__name:`TargetsView`,setup(e){let t=sx(),n=W(()=>t.targets),{query:r,normalized:i,hasQuery:a}=zC();function o(e){return e.name.toLowerCase().includes(i.value)}let s=W(()=>{let e=n.value?.mcpServers??[];return a.value?e.filter(o):e}),c=W(()=>{let e=n.value?.agents??[];return a.value?e.filter(o):e});function l(e,t){return e?a.value&&t===0?`no targets match "${r.value}"`:`none`:`none configured`}let u=W(()=>l(n.value?.mcpServers.length??0,s.value.length)),d=W(()=>l(n.value?.agents.length??0,c.value.length)),f=Tw();return(e,t)=>(R(),z(`div`,Ew,[H(PC,{modelValue:N(r),"onUpdate:modelValue":t[0]||=e=>j(r)?r.value=e:null,placeholder:`Filter MCP servers or agents`,class:`max-w-sm`},null,8,[`modelValue`]),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[1]||=[U(`MCP servers`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[2]||=[U(`Configured MCP proxy targets, the groups allowed to reach them, and their request counters.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:N(f),data:s.value,"empty-message":u.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[3]||=[U(`Agents`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[4]||=[U(`Configured A2A agent proxy targets, the groups allowed to reach them, and their request counters.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:N(f),data:c.value,"empty-message":d.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1})]))}}),Ow=F({__name:`Tabs`,props:{defaultValue:{},orientation:{},dir:{},activationMode:{},modelValue:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=qy(Cy(n,`class`),r);return(e,t)=>(R(),B(N(Rb),ks({"data-slot":`tabs`,"data-orientation":N(i).orientation||`horizontal`},N(i),{class:N(Yv)(`gap-2 group/tabs flex data-horizontal:flex-col`,n.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`data-orientation`,`class`]))}}),kw=F({__name:`TabsContent`,props:{value:{},forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(N(Vb),ks({"data-slot":`tabs-content`,class:N(Yv)(`text-sm flex-1 outline-none`,t.class)},N(n)),{default:P(()=>[I(e.$slots,`default`)]),_:3},16,[`class`]))}}),Aw=F({__name:`TabsList`,props:{loop:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]},variant:{default:`default`}},setup(e){let t=e,n=Cy(t,`class`,`variant`);return(r,i)=>(R(),B(N(Hb),ks({"data-slot":`tabs-list`,"data-variant":e.variant},N(n),{class:N(Yv)(N(Mw)({variant:e.variant}),t.class)}),{default:P(()=>[I(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),jw=F({__name:`TabsTrigger`,props:{value:{},disabled:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Ky(Cy(t,`class`));return(e,r)=>(R(),B(N(Ub),ks({"data-slot":`tabs-trigger`,class:N(Yv)(`gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg:not([class*=size-])]:size-4 has-data-[icon=inline-end]:pr-1 has-data-[icon=inline-start]:pl-1 relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center whitespace-nowrap text-foreground/60 transition-all group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 dark:text-muted-foreground dark:hover:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0`,`group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent`,`data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground`,`after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100`,t.class)},N(n)),{default:P(()=>[I(e.$slots,`default`)]),_:3},16,[`class`]))}}),Mw=C_(`rounded-lg p-0.75 group-data-horizontal/tabs:h-8 data-[variant=line]:rounded-none group/tabs-list inline-flex w-fit items-center justify-center text-muted-foreground group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col`,{variants:{variant:{default:`bg-muted`,line:`gap-1 bg-transparent`}},defaultVariants:{variant:`default`}});function Nw(e,t,n,r=String,i=!0){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>{if(e.original.storeDown)return`?`;let t=n(e.original);return i?G(_w,{value:t}):r(t)}}}function Pw(e,t,n){return[{id:`id`,header:e,accessorFn:e=>e.id,cell:({row:e})=>G(`span`,{class:`font-medium`},e.original.id)},{id:`secondary`,header:t,accessorFn:n,cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},n(e.original))},{id:`limits`,header:`Limits`,accessorFn:e=>xC(e.limits),cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},xC(e.original.limits))},Nw(`reqMin`,`req/min`,e=>e.requestsPerMinute),Nw(`reqDay`,`req/day`,e=>e.requestsPerDay),Nw(`tokInDay`,`tokIn/day`,e=>e.tokensInPerDay),Nw(`tokOutDay`,`tokOut/day`,e=>e.tokensOutPerDay),Nw(`tokInMonth`,`tokIn/month`,e=>e.tokensInPerMonth),Nw(`tokOutMonth`,`tokOut/month`,e=>e.tokensOutPerMonth),Nw(`costDay`,`cost/day`,e=>e.costPerDayMicroUsd,aC,!1),Nw(`costMonth`,`cost/month`,e=>e.costPerMonthMicroUsd,aC,!1)]}var Fw=F({__name:`UsageTable`,props:{idLabel:{},entries:{},secondaryColumnLabel:{},secondaryValue:{type:Function},emptyMessage:{}},setup(e){let t=e,n=W(()=>Pw(t.idLabel,t.secondaryColumnLabel,t.secondaryValue));return(t,r)=>(R(),B($S,{columns:n.value,data:e.entries,"empty-message":e.emptyMessage,"row-class":e=>e.storeDown?`bg-destructive/10`:void 0},null,8,[`columns`,`data`,`empty-message`,`row-class`]))}});function Iw(e,t){return e.id.toLowerCase().includes(t)}function Lw(e,t){return e.id.toLowerCase().includes(t)}function Rw(e,t){return t.filter(t=>t.groupName===e.id)}function zw(e,t,n){return Rw(e,t).filter(e=>Iw(e,n))}function Bw(e,t,n){return Lw(e,n)||zw(e,t,n).length>0}var Vw={class:`flex flex-col gap-6`},Hw={class:`text-lg font-semibold tabular-nums`},Uw={class:`text-lg font-semibold tabular-nums`},Ww={class:`text-lg font-semibold tabular-nums`},Gw={class:`text-lg font-semibold tabular-nums`},Kw={key:0,class:`mb-3 flex flex-wrap gap-x-4 gap-y-1 text-xs font-medium text-muted-foreground`},qw={class:`flex flex-1 flex-wrap items-center gap-x-4 gap-y-1 pr-2 text-left`},Jw={class:`font-medium`},Yw={class:`text-xs text-muted-foreground tabular-nums`},Xw={class:`text-xs text-muted-foreground tabular-nums`},Zw={class:`text-xs text-muted-foreground tabular-nums`},Qw={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},$w={key:0,class:`flex flex-wrap gap-1.5`},eT={key:1,class:`text-muted-foreground`},tT={key:0,class:`flex flex-wrap gap-1.5`},nT={key:1,class:`text-muted-foreground`},rT={key:0,class:`flex flex-wrap gap-1.5`},iT={key:1,class:`text-muted-foreground`},aT={key:0,class:`flex flex-wrap gap-1.5`},oT={key:1,class:`text-muted-foreground`},sT={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},cT={class:`tabular-nums`},lT={class:`tabular-nums`},uT={class:`tabular-nums`},dT={class:`tabular-nums`},fT={class:`tabular-nums`},pT={class:`tabular-nums`},mT={key:2,class:`py-6 text-center text-sm text-muted-foreground`},hT=`Glob pattern — matches like a shell wildcard (*, ?, [...])`,gT=F({__name:`UsageView`,setup(e){let t=sx(),n=W(()=>t.usage),r=W(()=>{let e={};for(let n of t.overview?.groups??[])e[n.name]=n.memberCount;return e});function i(e){return e.groupName??``}function a(e){let t=r.value[e.id];return t===void 0?``:String(t)}let{query:o,normalized:s,hasQuery:c}=zC(),l=W(()=>{let e=n.value?.groups??[];if(!c.value)return e;let t=n.value?.users??[];return e.filter(e=>Bw(e,t,s.value))}),u=W(()=>c.value?l.value.filter(e=>!Lw(e,s.value)).map(e=>e.id):[]);function d(e){let t=n.value?.users??[];return!c.value||Lw(e,s.value)?Rw(e,t):zw(e,t,s.value)}let f=W(()=>n.value?.groups.length?c.value?`no groups match "${o.value}"`:`none`:`none configured`),p=W(()=>{let e=n.value?.users??[];if(!c.value)return e;let t=n.value?.groups??[],r=new Set(t.filter(e=>Lw(e,s.value)).map(e=>e.id));return e.filter(e=>Iw(e,s.value)||e.groupName!==void 0&&r.has(e.groupName))}),m=W(()=>n.value?.users.length?c.value?`no users match "${o.value}"`:`none`:`none configured`),h=Pw(`Name`,`Members`,a),g=M([]),_=BS({get data(){return l.value},get columns(){return h},getCoreRowModel:jS(),getSortedRowModel:MS(),onSortingChange:e=>QS(e,g),state:{get sorting(){return g.value}}}),v=W(()=>_.getRowModel().rows),y=new Set([`id`,`secondary`,`reqDay`,`costDay`]),b=W(()=>_.getHeaderGroups()[0].headers.filter(e=>y.has(e.column.id))),x=Zt({manuallyExpanded:new Set,manuallyCollapsed:new Set}),S=W(()=>BC(x,c.value,u.value));function C(e){VC(x,e,S.value.has(e))}let w=W({get:()=>Array.from(S.value),set:e=>{let t=new Set(e);for(let e of S.value)t.has(e)||C(e);for(let e of t)S.value.has(e)||C(e)}});Er(o,e=>{e.trim()===``&&HC(x)});function ee(e){return/[*?[]/.test(e)}return(e,t)=>(R(),z(`div`,Vw,[H(PC,{modelValue:N(o),"onUpdate:modelValue":t[0]||=e=>j(o)?o.value=e:null,placeholder:`Filter users or groups`,class:`max-w-sm`},null,8,[`modelValue`]),n.value?(R(),B(N(qb),{key:0},{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[2]||=[U(`Total`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[3]||=[U(`Usage summed across every user and group combined.`,-1)]]),_:1})]),_:1}),H(N(Jb),{class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-4`},{default:P(()=>[V(`div`,null,[t[4]||=V(`p`,{class:`text-muted-foreground`},`Requests/day`,-1),V(`p`,Hw,[H(_w,{value:n.value.total.requestsPerDay},null,8,[`value`])])]),V(`div`,null,[t[5]||=V(`p`,{class:`text-muted-foreground`},`Tokens in/day`,-1),V(`p`,Uw,[H(_w,{value:n.value.total.tokensInPerDay},null,8,[`value`])])]),V(`div`,null,[t[6]||=V(`p`,{class:`text-muted-foreground`},`Tokens out/day`,-1),V(`p`,Ww,[H(_w,{value:n.value.total.tokensOutPerDay},null,8,[`value`])])]),V(`div`,null,[t[7]||=V(`p`,{class:`text-muted-foreground`},`Cost/day`,-1),V(`p`,Gw,k(N(aC)(n.value.total.costPerDayMicroUsd)),1)])]),_:1})]),_:1})):Ts(``,!0),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[8]||=[U(`Groups`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[9]||=[U(`Expand a group to see its member users' own usage.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[v.value.length?(R(),z(`div`,Kw,[(R(!0),z(L,null,ma(b.value,e=>(R(),B(HS,{key:e.id,header:e},null,8,[`header`]))),128))])):Ts(``,!0),v.value.length?(R(),B(N(FC),{key:1,modelValue:w.value,"onUpdate:modelValue":t[1]||=e=>w.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:P(()=>[(R(!0),z(L,null,ma(v.value,e=>(R(),B(N(LC),{key:e.original.id,value:e.original.id},{default:P(()=>[H(N(RC),null,{default:P(()=>[V(`span`,qw,[V(`span`,Jw,k(e.original.id),1),V(`span`,Yw,k(a(e.original)||`0`)+` members`,1),V(`span`,Xw,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.requestsPerDay},null,8,[`value`])),t[10]||=U(` req/day `,-1)]),V(`span`,Zw,k(e.original.storeDown?`?`:N(aC)(e.original.costPerDayMicroUsd))+`/day `,1)])]),_:2},1024),H(N(IC),null,{default:P(()=>[V(`dl`,Qw,[V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:hT},`Providers`),V(`dd`,null,[e.original.providers?.length?(R(),z(`div`,$w,[(R(!0),z(L,null,ma(e.original.providers,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,eT,`All providers`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:hT},`Models`),V(`dd`,null,[e.original.models?.length?(R(),z(`div`,tT,[(R(!0),z(L,null,ma(e.original.models,e=>(R(),z(L,{key:e},[ee(e)?(R(),B(N(eC),{key:1,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024)):(R(),B(CC,{key:0,id:e},null,8,[`id`]))],64))),128))])):(R(),z(`span`,nT,`All models`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:hT},`MCP servers`),V(`dd`,null,[e.original.mcpServers?.length?(R(),z(`div`,rT,[(R(!0),z(L,null,ma(e.original.mcpServers,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,iT,`All MCP servers`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:hT},`Agents`),V(`dd`,null,[e.original.agents?.length?(R(),z(`div`,aT,[(R(!0),z(L,null,ma(e.original.agents,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,oT,`All agents`))])])]),V(`dl`,sT,[V(`div`,null,[t[11]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Limits`,-1),V(`dd`,null,k(N(xC)(e.original.limits)),1)]),V(`div`,null,[t[12]||=V(`dt`,{class:`text-xs text-muted-foreground`},`req/min`,-1),V(`dd`,cT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.requestsPerMinute},null,8,[`value`]))])]),V(`div`,null,[t[13]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/day`,-1),V(`dd`,lT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.tokensInPerDay},null,8,[`value`]))])]),V(`div`,null,[t[14]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/day`,-1),V(`dd`,uT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.tokensOutPerDay},null,8,[`value`]))])]),V(`div`,null,[t[15]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/month`,-1),V(`dd`,dT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.tokensInPerMonth},null,8,[`value`]))])]),V(`div`,null,[t[16]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/month`,-1),V(`dd`,fT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(_w,{key:1,value:e.original.tokensOutPerMonth},null,8,[`value`]))])]),V(`div`,null,[t[17]||=V(`dt`,{class:`text-xs text-muted-foreground`},`cost/month`,-1),V(`dd`,pT,k(e.original.storeDown?`?`:N(aC)(e.original.costPerMonthMicroUsd)),1)])]),t[18]||=V(`p`,{class:`mb-1.5 text-xs font-medium text-muted-foreground`},`Members`,-1),H(Fw,{"id-label":`Name`,"secondary-column-label":`Group`,entries:d(e.original),"secondary-value":i},null,8,[`entries`])]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):(R(),z(`p`,mT,k(f.value),1))]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[19]||=[U(`Users`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H(Fw,{"id-label":`Name`,"secondary-column-label":`Group`,entries:p.value,"secondary-value":i,"empty-message":m.value},null,8,[`entries`,`empty-message`])]),_:1})]),_:1})]))}});function _T(e,t,n){let r=e.startsWith(`#`)?e.slice(1):e;return t.includes(r)?r:n}function vT(e){return`#${e}`}function yT({validTabs:e,defaultTab:t}){let n=typeof window<`u`,r=M(n?_T(window.location.hash,e,t):t);Er(r,e=>{if(!n)return;let t=vT(e);window.location.hash!==t&&window.history.replaceState(null,``,t)});function i(){r.value=_T(window.location.hash,e,t)}return n&&(Zi(()=>window.addEventListener(`hashchange`,i)),ta(()=>window.removeEventListener(`hashchange`,i))),r}var bT=(function(){let e=typeof document<`u`&&document.createElement(`link`).relList;return e&&e.supports&&e.supports(`modulepreload`)?`modulepreload`:`preload`})(),xT=function(e){return`/admin/`+e},ST={},CT=function(e,t,n){let r=Promise.resolve();if(t&&t.length>0){let e=document.getElementsByTagName(`link`),i=document.querySelector(`meta[property=csp-nonce]`),a=i?.nonce||i?.getAttribute(`nonce`);function o(e){return Promise.all(e.map(e=>Promise.resolve(e).then(e=>({status:`fulfilled`,value:e}),e=>({status:`rejected`,reason:e}))))}function s(e){return import.meta.resolve?import.meta.resolve(e):new URL(e,import.meta.url).href}r=o(t.map(t=>{if(t=xT(t,n),t=s(t),t in ST)return;ST[t]=!0;let r=t.endsWith(`.css`);for(let n=e.length-1;n>=0;n--){let i=e[n];if(i.href===t&&(!r||i.rel===`stylesheet`))return}let i=document.createElement(`link`);if(i.rel=r?`stylesheet`:bT,r||(i.as=`script`),i.crossOrigin=``,i.href=t,a&&i.setAttribute(`nonce`,a),document.head.appendChild(i),r)return new Promise((e,n)=>{i.addEventListener(`load`,e),i.addEventListener(`error`,()=>n(Error(`Unable to preload CSS for ${t}`)))})}))}function i(e){let t=new Event(`vite:preloadError`,{cancelable:!0});if(t.payload=e,window.dispatchEvent(t),!t.defaultPrevented)throw e}return r.then(t=>{for(let e of t||[])e.status===`rejected`&&i(e.reason);return e().catch(i)})},wT={class:`flex w-full flex-col gap-6 px-4 py-8 sm:px-6 lg:px-8`},TT={class:`flex flex-col gap-1`},ET={class:`flex items-center justify-between gap-2`},DT={class:`flex items-center gap-1.5 text-sm text-muted-foreground`},OT=`https://github.com/lukaszraczylo/traefik-llmgateway`,kT=mu(F({__name:`App`,setup(e){let t=Li(()=>CT(()=>import(`./ChartsView--5PgKbV9.js`),[])),n=rx(),r=sx(),i=yT({validTabs:[`providers`,`usage`,`charts`,`targets`],defaultTab:`providers`}),a=W(()=>r.error?`refresh failed: ${r.error}`:r.lastUpdated?`last updated ${r.lastUpdated.toLocaleTimeString()}`:`loading...`);return Zi(()=>{r.startPolling()}),(e,o)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`div`,wT,[V(`header`,TT,[V(`div`,ET,[o[1]||=V(`h1`,{class:`text-xl font-semibold tracking-tight`},`LLM Gateway — Admin`,-1),H(N(Wb),{as:`a`,href:OT,target:`_blank`,rel:`noopener noreferrer`,variant:`ghost`,size:`icon`,"aria-label":`GitHub repository`,class:`text-muted-foreground hover:text-foreground`},{default:P(()=>[H(s,{icon:N(n_),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`])]),_:1})]),V(`p`,DT,[N(r).error?(R(),B(s,{key:0,icon:N(l_),class:`size-3.5 text-destructive`},null,8,[`icon`])):Ts(``,!0),V(`span`,{class:O(N(r).error?`text-destructive`:void 0)},k(a.value),3)])]),N(n).isAuthenticated?(R(),B(N(Ow),{key:1,modelValue:N(i),"onUpdate:modelValue":o[0]||=e=>j(i)?i.value=e:null},{default:P(()=>[H(N(Aw),null,{default:P(()=>[H(N(jw),{value:`providers`},{default:P(()=>[...o[2]||=[U(`Providers`,-1)]]),_:1}),H(N(jw),{value:`usage`},{default:P(()=>[...o[3]||=[U(`Usage`,-1)]]),_:1}),H(N(jw),{value:`charts`},{default:P(()=>[...o[4]||=[U(`Charts`,-1)]]),_:1}),H(N(jw),{value:`targets`},{default:P(()=>[...o[5]||=[U(`MCP & Agents`,-1)]]),_:1})]),_:1}),H(N(kw),{value:`providers`},{default:P(()=>[H(pw)]),_:1}),H(N(kw),{value:`usage`},{default:P(()=>[H(gT)]),_:1}),H(N(kw),{value:`charts`},{default:P(()=>[H(N(t))]),_:1}),H(N(kw),{value:`targets`},{default:P(()=>[H(Dw)]),_:1})]),_:1},8,[`modelValue`])):(R(),B(gx,{key:0}))])}}}));kT.use(Vg()),kT.component(`FontAwesomeIcon`,Cg),kT.mount(`#app`);export{Vr as $,ky as A,Zt as At,Ty as B,ge as Bt,qy as C,wr as Ct,Vy as D,on as Dt,Uy as E,Fe as Et,by as F,yn as Ft,Yv as G,sy as H,fy as I,mn as It,s_ as J,u_ as K,gy as L,N as Lt,Fy as M,en as Mt,Iy as N,un as Nt,Ny as O,j as Ot,dy as P,A as Pt,L as Q,Cy as R,O as Rt,Yy as S,Cr as St,Gy as T,nc as Tt,oy as U,cy as V,k as Vt,ay as W,Cg as X,t_ as Y,iu as Z,Jb as _,ma as _t,Ow as a,U as at,nb as b,ic as bt,SC as c,Ss as ct,sx as d,ks as dt,W as et,ix as f,Qn as ft,Xb as g,R as gt,Zb as h,ta as ht,Aw as i,z as it,Ay as j,M as jt,Oy as k,Ie as kt,sC as l,G as lt,rx as m,Zi as mt,Iw as n,B as nt,zC as o,H as ot,ax as p,ea as pt,m_ as q,jw as r,Ts as rt,PC as s,F as st,Bw as t,V as tt,oC as u,Pa as ut,qb as v,I as vt,Ky as w,P as wt,$y as x,Er as xt,wb as y,ua as yt,wy as z,xe as zt};", + "var e=Object.defineProperty,t=(t,n)=>{let r={};for(var i in t)e(r,i,{get:t[i],enumerable:!0});return n||e(r,Symbol.toStringTag,{value:`Module`}),r};function n(e){let t=Object.create(null);for(let n of e.split(`,`))t[n]=1;return e=>e in t}var r={},i=[],a=()=>{},o=()=>!1,s=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&(e.charCodeAt(2)>122||e.charCodeAt(2)<97),c=e=>e.startsWith(`onUpdate:`),l=Object.assign,u=(e,t)=>{let n=e.indexOf(t);n>-1&&e.splice(n,1)},d=Object.prototype.hasOwnProperty,f=(e,t)=>d.call(e,t),p=Array.isArray,m=e=>w(e)===`[object Map]`,h=e=>w(e)===`[object Set]`,g=e=>w(e)===`[object Date]`,_=e=>w(e)===`[object RegExp]`,v=e=>typeof e==`function`,y=e=>typeof e==`string`,b=e=>typeof e==`symbol`,x=e=>typeof e==`object`&&!!e,S=e=>(x(e)||v(e))&&v(e.then)&&v(e.catch),C=Object.prototype.toString,w=e=>C.call(e),ee=e=>w(e).slice(8,-1),te=e=>w(e)===`[object Object]`,T=e=>y(e)&&e!==`NaN`&&e[0]!==`-`&&``+parseInt(e,10)===e,ne=n(`,key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted`),re=e=>{let t=Object.create(null);return(n=>t[n]||(t[n]=e(n)))},ie=/-\w/g,E=re(e=>e.replace(ie,e=>e.slice(1).toUpperCase())),ae=/\B([A-Z])/g,oe=re(e=>e.replace(ae,`-$1`).toLowerCase()),se=re(e=>e.charAt(0).toUpperCase()+e.slice(1)),ce=re(e=>e?`on${se(e)}`:``),D=(e,t)=>!Object.is(e,t),le=(e,...t)=>{for(let n=0;n<e.length;n++)e[n](...t)},ue=(e,t,n,r=!1)=>{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:r,value:n})},de=e=>{let t=parseFloat(e);return isNaN(t)?e:t},fe=e=>{let t=y(e)?Number(e):NaN;return isNaN(t)?e:t},pe,me=()=>pe||=typeof globalThis<`u`?globalThis:typeof self<`u`?self:typeof window<`u`?window:typeof global<`u`?global:{},he=n(`Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol`);function ge(e){if(p(e)){let t={};for(let n=0;n<e.length;n++){let r=e[n],i=y(r)?be(r):ge(r);if(i)for(let e in i)t[e]=i[e]}return t}if(y(e)||x(e))return e}var _e=/;(?![^(]*\))/g,ve=/:([^]+)/,ye=/\/\*[^]*?\*\//g;function be(e){let t={};return e.replace(ye,``).split(_e).forEach(e=>{if(e){let n=e.split(ve);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}function O(e){let t=``;if(y(e))t=e;else if(p(e))for(let n=0;n<e.length;n++){let r=O(e[n]);r&&(t+=r+` `)}else if(x(e))for(let n in e)e[n]&&(t+=n+` `);return t.trim()}function xe(e){if(!e)return null;let{class:t,style:n}=e;return t&&!y(t)&&(e.class=O(t)),n&&(e.style=ge(n)),e}var Se=`itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`,Ce=n(Se);Se+``;function we(e){return!!e||e===``}function Te(e,t){if(e.length!==t.length)return!1;let n=!0;for(let r=0;n&&r<e.length;r++)n=Ee(e[r],t[r]);return n}function Ee(e,t){if(e===t)return!0;let n=g(e),r=g(t);if(n||r)return n&&r?e.getTime()===t.getTime():!1;if(n=b(e),r=b(t),n||r)return e===t;if(n=p(e),r=p(t),n||r)return n&&r?Te(e,t):!1;if(n=x(e),r=x(t),n||r){if(!n||!r||Object.keys(e).length!==Object.keys(t).length)return!1;for(let n in e){let r=e.hasOwnProperty(n),i=t.hasOwnProperty(n);if(r&&!i||!r&&i||!Ee(e[n],t[n]))return!1}}return String(e)===String(t)}function De(e,t){return e.findIndex(e=>Ee(e,t))}var Oe=e=>!!(e&&e.__v_isRef===!0),k=e=>y(e)?e:e==null?``:p(e)||x(e)&&(e.toString===C||!v(e.toString))?Oe(e)?k(e.value):JSON.stringify(e,ke,2):String(e),ke=(e,t)=>Oe(t)?ke(e,t.value):m(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((e,[t,n],r)=>(e[Ae(t,r)+` =>`]=n,e),{})}:h(t)?{[`Set(${t.size})`]:[...t.values()].map(e=>Ae(e))}:b(t)?Ae(t):x(t)&&!p(t)&&!te(t)?String(t):t,Ae=(e,t=``)=>b(e)?`Symbol(${e.description??t})`:e;function je(e){return e==null?`initial`:typeof e==`string`?e===``?` `:e:String(e)}var Me,Ne=class{constructor(e=!1){this.detached=e,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this._warnOnRun=!0,this.__v_skip=!0,!e&&Me&&(Me.active?(this.parent=Me,this.index=(Me.scopes||(Me.scopes=[])).push(this)-1):(this._active=!1,this._warnOnRun=!1))}get active(){return this._active}pause(){if(this._active){this._isPaused=!0;let e,t;if(this.scopes){let n=this.scopes.slice();for(e=0,t=n.length;e<t;e++)n[e].pause()}for(e=0,t=this.effects.length;e<t;e++)this.effects[e].pause()}}resume(){if(this._active&&this._isPaused){this._isPaused=!1;let e,t;if(this.scopes){let n=this.scopes.slice();for(e=0,t=n.length;e<t;e++)n[e].resume()}let n=this.effects.slice();for(e=0,t=n.length;e<t;e++)n[e].resume()}}run(e){if(this._active){let t=Me;try{return Me=this,e()}finally{Me=t}}}on(){++this._on===1&&(this.prevScope=Me,Me=this)}off(){if(this._on>0&&--this._on===0){if(Me===this)Me=this.prevScope;else{let e=Me;for(;e;){if(e.prevScope===this){e.prevScope=this.prevScope;break}e=e.prevScope}}this.prevScope=void 0}}stop(e){if(this._active){this._active=!1;let t,n;for(t=0,n=this.effects.length;t<n;t++)this.effects[t].stop();for(this.effects.length=0,t=0,n=this.cleanups.length;t<n;t++)this.cleanups[t]();if(this.cleanups.length=0,this.scopes){let e=this.scopes.slice();for(t=0,n=e.length;t<n;t++)e[t].stop(!0);this.scopes.length=0}if(!this.detached&&this.parent&&!e){let e=this.parent.scopes.pop();e&&e!==this&&(this.parent.scopes[this.index]=e,e.index=this.index)}this.parent=void 0}}};function Pe(e){return new Ne(e)}function Fe(){return Me}function Ie(e,t=!1){Me&&Me.cleanups.push(e)}var Le,Re=new WeakSet,ze=class{constructor(e){this.fn=e,this.deps=void 0,this.depsTail=void 0,this.flags=5,this.next=void 0,this.cleanup=void 0,this.scheduler=void 0,Me&&(Me.active?Me.effects.push(this):this.flags&=-2)}pause(){this.flags|=64}resume(){this.flags&64&&(this.flags&=-65,Re.has(this)&&(Re.delete(this),this.trigger()))}notify(){this.flags&2&&!(this.flags&32)||this.flags&8||Ue(this)}run(){if(!(this.flags&1))return this.fn();this.flags|=2,it(this),Ke(this);let e=Le,t=et;Le=this,et=!0;try{return this.fn()}finally{qe(this),Le=e,et=t,this.flags&=-3}}stop(){if(this.flags&1){for(let e=this.deps;e;e=e.nextDep)Xe(e);this.deps=this.depsTail=void 0,it(this),this.onStop&&this.onStop(),this.flags&=-2}}trigger(){this.flags&64?Re.add(this):this.scheduler?this.scheduler():this.runIfDirty()}runIfDirty(){Je(this)&&this.run()}get dirty(){return Je(this)}},Be=0,Ve,He;function Ue(e,t=!1){if(e.flags|=8,t){e.next=He,He=e;return}e.next=Ve,Ve=e}function We(){Be++}function Ge(){if(--Be>0)return;if(He){let e=He;for(He=void 0;e;){let t=e.next;e.next=void 0,e.flags&=-9,e=t}}let e;for(;Ve;){let t=Ve;for(Ve=void 0;t;){let n=t.next;if(t.next=void 0,t.flags&=-9,t.flags&1)try{t.trigger()}catch(t){e||=t}t=n}}if(e)throw e}function Ke(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function qe(e){let t,n=e.depsTail,r=n;for(;r;){let e=r.prevDep;r.version===-1?(r===n&&(n=e),Xe(r),Ze(r)):t=r,r.dep.activeLink=r.prevActiveLink,r.prevActiveLink=void 0,r=e}e.deps=t,e.depsTail=n}function Je(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(Ye(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function Ye(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===at)||(e.globalVersion=at,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!Je(e))))return;e.flags|=2;let t=e.dep,n=Le,r=et;Le=e,et=!0;try{Ke(e);let n=e.fn(e._value);(t.version===0||D(n,e._value))&&(e.flags|=128,e._value=n,t.version++)}catch(e){throw t.version++,e}finally{Le=n,et=r,qe(e),e.flags&=-3}}function Xe(e,t=!1){let{dep:n,prevSub:r,nextSub:i}=e;if(r&&(r.nextSub=i,e.prevSub=void 0),i&&(i.prevSub=r,e.nextSub=void 0),n.subs===e&&(n.subs=r,!r&&n.computed)){n.computed.flags&=-5;for(let e=n.computed.deps;e;e=e.nextDep)Xe(e,!0)}!t&&!--n.sc&&n.map&&n.map.delete(n.key)}function Ze(e){let{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}function Qe(e,t){e.effect instanceof ze&&(e=e.effect.fn);let n=new ze(e);t&&l(n,t);try{n.run()}catch(e){throw n.stop(),e}let r=n.run.bind(n);return r.effect=n,r}function $e(e){e.effect.stop()}var et=!0,tt=[];function nt(){tt.push(et),et=!1}function rt(){let e=tt.pop();et=e===void 0||e}function it(e){let{cleanup:t}=e;if(e.cleanup=void 0,t){let e=Le;Le=void 0;try{t()}finally{Le=e}}}var at=0,ot=class{constructor(e,t){this.sub=e,this.dep=t,this.version=t.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}},st=class{constructor(e){this.computed=e,this.version=0,this.activeLink=void 0,this.subs=void 0,this.map=void 0,this.key=void 0,this.sc=0,this.__v_skip=!0}track(e){if(!Le||!et||Le===this.computed)return;let t=this.activeLink;if(t===void 0||t.sub!==Le)t=this.activeLink=new ot(Le,this),Le.deps?(t.prevDep=Le.depsTail,Le.depsTail.nextDep=t,Le.depsTail=t):Le.deps=Le.depsTail=t,ct(t);else if(t.version===-1&&(t.version=this.version,t.nextDep)){let e=t.nextDep;e.prevDep=t.prevDep,t.prevDep&&(t.prevDep.nextDep=e),t.prevDep=Le.depsTail,t.nextDep=void 0,Le.depsTail.nextDep=t,Le.depsTail=t,Le.deps===t&&(Le.deps=e)}return t}trigger(e){this.version++,at++,this.notify(e)}notify(e){We();try{for(let e=this.subs;e;e=e.prevSub)e.sub.notify()&&e.sub.dep.notify()}finally{Ge()}}};function ct(e){if(e.dep.sc++,e.sub.flags&4){let t=e.dep.computed;if(t&&!e.dep.subs){t.flags|=20;for(let e=t.deps;e;e=e.nextDep)ct(e)}let n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}var lt=new WeakMap,ut=Symbol(``),dt=Symbol(``),ft=Symbol(``);function pt(e,t,n){if(et&&Le){let t=lt.get(e);t||lt.set(e,t=new Map);let r=t.get(n);r||(t.set(n,r=new st),r.map=t,r.key=n),r.track()}}function mt(e,t,n,r,i,a){let o=lt.get(e);if(!o){at++;return}let s=e=>{e&&e.trigger()};if(We(),t===`clear`)o.forEach(s);else{let i=p(e),a=i&&T(n);if(i&&n===`length`){let e=Number(r);o.forEach((t,n)=>{(n===`length`||n===ft||!b(n)&&n>=e)&&s(t)})}else switch((n!==void 0||o.has(void 0))&&s(o.get(n)),a&&s(o.get(ft)),t){case`add`:i?a&&s(o.get(`length`)):(s(o.get(ut)),m(e)&&s(o.get(dt)));break;case`delete`:i||(s(o.get(ut)),m(e)&&s(o.get(dt)));break;case`set`:m(e)&&s(o.get(ut))}}Ge()}function ht(e,t){let n=lt.get(e);return n&&n.get(t)}function gt(e){let t=A(e);return t===e?t:(pt(t,`iterate`,ft),an(e)?t:t.map(cn))}function _t(e){return pt(e=A(e),`iterate`,ft),e}function vt(e,t){return rn(e)?ln(nn(e)?cn(t):t):cn(t)}var yt={__proto__:null,[Symbol.iterator](){return bt(this,Symbol.iterator,e=>vt(this,e))},concat(...e){return gt(this).concat(...e.map(e=>p(e)?gt(e):e))},entries(){return bt(this,`entries`,e=>(e[1]=vt(this,e[1]),e))},every(e,t){return St(this,`every`,e,t,void 0,arguments)},filter(e,t){return St(this,`filter`,e,t,e=>e.map(e=>vt(this,e)),arguments)},find(e,t){return St(this,`find`,e,t,e=>vt(this,e),arguments)},findIndex(e,t){return St(this,`findIndex`,e,t,void 0,arguments)},findLast(e,t){return St(this,`findLast`,e,t,e=>vt(this,e),arguments)},findLastIndex(e,t){return St(this,`findLastIndex`,e,t,void 0,arguments)},forEach(e,t){return St(this,`forEach`,e,t,void 0,arguments)},includes(...e){return wt(this,`includes`,e)},indexOf(...e){return wt(this,`indexOf`,e)},join(e){return gt(this).join(e)},lastIndexOf(...e){return wt(this,`lastIndexOf`,e)},map(e,t){return St(this,`map`,e,t,void 0,arguments)},pop(){return Tt(this,`pop`)},push(...e){return Tt(this,`push`,e)},reduce(e,...t){return Ct(this,`reduce`,e,t)},reduceRight(e,...t){return Ct(this,`reduceRight`,e,t)},shift(){return Tt(this,`shift`)},some(e,t){return St(this,`some`,e,t,void 0,arguments)},splice(...e){return Tt(this,`splice`,e)},toReversed(){return gt(this).toReversed()},toSorted(e){return gt(this).toSorted(e)},toSpliced(...e){return gt(this).toSpliced(...e)},unshift(...e){return Tt(this,`unshift`,e)},values(){return bt(this,`values`,e=>vt(this,e))}};function bt(e,t,n){let r=_t(e),i=r[t]();return r!==e&&!an(e)&&(i._next=i.next,i.next=()=>{let e=i._next();return e.done||(e.value=n(e.value)),e}),i}var xt=Array.prototype;function St(e,t,n,r,i,a){let o=_t(e),s=o!==e&&!an(e),c=o[t];if(c!==xt[t]){let t=c.apply(e,a);return s?cn(t):t}let l=n;o!==e&&(s?l=function(t,r){return n.call(this,vt(e,t),r,e)}:n.length>2&&(l=function(t,r){return n.call(this,t,r,e)}));let u=c.call(o,l,r);return s&&i?i(u):u}function Ct(e,t,n,r){let i=_t(e),a=i!==e&&!an(e),o=n,s=!1;i!==e&&(a?(s=r.length===0,o=function(t,r,i){return s&&(s=!1,t=vt(e,t)),n.call(this,t,vt(e,r),i,e)}):n.length>3&&(o=function(t,r,i){return n.call(this,t,r,i,e)}));let c=i[t](o,...r);return s?vt(e,c):c}function wt(e,t,n){let r=A(e);pt(r,`iterate`,ft);let i=r[t](...n);return(i===-1||i===!1)&&on(n[0])?(n[0]=A(n[0]),r[t](...n)):i}function Tt(e,t,n=[]){nt(),We();let r=A(e)[t].apply(e,n);return Ge(),rt(),r}var Et=n(`__proto__,__v_isRef,__isVue`),Dt=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!==`arguments`&&e!==`caller`).map(e=>Symbol[e]).filter(b));function Ot(e){b(e)||(e=String(e));let t=A(this);return pt(t,`has`,e),t.hasOwnProperty(e)}var kt=class{constructor(e=!1,t=!1){this._isReadonly=e,this._isShallow=t}get(e,t,n){if(t===`__v_skip`)return e.__v_skip;let r=this._isReadonly,i=this._isShallow;if(t===`__v_isReactive`)return!r;if(t===`__v_isReadonly`)return r;if(t===`__v_isShallow`)return i;if(t===`__v_raw`)return n===(r?i?Yt:Jt:i?qt:Kt).get(e)||Object.getPrototypeOf(e)===Object.getPrototypeOf(n)?e:void 0;let a=p(e);if(!r){let e;if(a&&(e=yt[t]))return e;if(t===`hasOwnProperty`)return Ot}let o=Reflect.get(e,t,j(e)?e:n);if((b(t)?Dt.has(t):Et(t))||(r||pt(e,`get`,t),i))return o;if(j(o)){let e=a&&T(t)?o:o.value;return r&&x(e)?$t(e):e}return x(o)?r?$t(o):Zt(o):o}},At=class extends kt{constructor(e=!1){super(!1,e)}set(e,t,n,r){let i=e[t],a=p(e)&&T(t);if(!this._isShallow){let e=rn(i);if(!an(n)&&!rn(n)&&(i=A(i),n=A(n)),!a&&j(i)&&!j(n))return e||(i.value=n),!0}let o=a?Number(t)<e.length:f(e,t),s=Reflect.set(e,t,n,j(e)?e:r);return e===A(r)&&s&&(o?D(n,i)&&mt(e,`set`,t,n,i):mt(e,`add`,t,n)),s}deleteProperty(e,t){let n=f(e,t),r=e[t],i=Reflect.deleteProperty(e,t);return i&&n&&mt(e,`delete`,t,void 0,r),i}has(e,t){let n=Reflect.has(e,t);return(!b(t)||!Dt.has(t))&&pt(e,`has`,t),n}ownKeys(e){return pt(e,`iterate`,p(e)?`length`:ut),Reflect.ownKeys(e)}},jt=class extends kt{constructor(e=!1){super(!0,e)}set(e,t){return!0}deleteProperty(e,t){return!0}},Mt=new At,Nt=new jt,Pt=new At(!0),Ft=new jt(!0),It=e=>e,Lt=e=>Reflect.getPrototypeOf(e);function Rt(e,t,n){return function(...r){let i=this.__v_raw,a=A(i),o=m(a),s=e===`entries`||e===Symbol.iterator&&o,c=e===`keys`&&o,u=i[e](...r),d=n?It:t?ln:cn;return!t&&pt(a,`iterate`,c?dt:ut),l(Object.create(u),{next(){let{value:e,done:t}=u.next();return t?{value:e,done:t}:{value:s?[d(e[0]),d(e[1])]:d(e),done:t}}})}}function zt(e){return function(...t){return e===`delete`?!1:e===`clear`?void 0:this}}function Bt(e,t){let n={get(n){let r=this.__v_raw,i=A(r),a=A(n);e||(D(n,a)&&pt(i,`get`,n),pt(i,`get`,a));let{has:o}=Lt(i),s=t?It:e?ln:cn;if(o.call(i,n))return s(r.get(n));if(o.call(i,a))return s(r.get(a));r!==i&&r.get(n)},get size(){let t=this.__v_raw;return!e&&pt(A(t),`iterate`,ut),t.size},has(t){let n=this.__v_raw,r=A(n),i=A(t);return e||(D(t,i)&&pt(r,`has`,t),pt(r,`has`,i)),t===i?n.has(t):n.has(t)||n.has(i)},forEach(n,r){let i=this,a=i.__v_raw,o=A(a),s=t?It:e?ln:cn;return!e&&pt(o,`iterate`,ut),a.forEach((e,t)=>n.call(r,s(e),s(t),i))}};return l(n,e?{add:zt(`add`),set:zt(`set`),delete:zt(`delete`),clear:zt(`clear`)}:{add(e){let n=A(this),r=Lt(n),i=A(e),a=!t&&!an(e)&&!rn(e)?i:e;return r.has.call(n,a)||D(e,a)&&r.has.call(n,e)||D(i,a)&&r.has.call(n,i)||(n.add(a),mt(n,`add`,a,a)),this},set(e,n){!t&&!an(n)&&!rn(n)&&(n=A(n));let r=A(this),{has:i,get:a}=Lt(r),o=i.call(r,e);o||=(e=A(e),i.call(r,e));let s=a.call(r,e);return r.set(e,n),o?D(n,s)&&mt(r,`set`,e,n,s):mt(r,`add`,e,n),this},delete(e){let t=A(this),{has:n,get:r}=Lt(t),i=n.call(t,e);i||=(e=A(e),n.call(t,e));let a=r?r.call(t,e):void 0,o=t.delete(e);return i&&mt(t,`delete`,e,void 0,a),o},clear(){let e=A(this),t=e.size!==0,n=e.clear();return t&&mt(e,`clear`,void 0,void 0,void 0),n}}),[`keys`,`values`,`entries`,Symbol.iterator].forEach(r=>{n[r]=Rt(r,e,t)}),n}function Vt(e,t){let n=Bt(e,t);return(t,r,i)=>r===`__v_isReactive`?!e:r===`__v_isReadonly`?e:r===`__v_raw`?t:Reflect.get(f(n,r)&&r in t?n:t,r,i)}var Ht={get:Vt(!1,!1)},Ut={get:Vt(!1,!0)},Wt={get:Vt(!0,!1)},Gt={get:Vt(!0,!0)},Kt=new WeakMap,qt=new WeakMap,Jt=new WeakMap,Yt=new WeakMap;function Xt(e){switch(e){case`Object`:case`Array`:return 1;case`Map`:case`Set`:case`WeakMap`:case`WeakSet`:return 2;default:return 0}}function Zt(e){return rn(e)?e:tn(e,!1,Mt,Ht,Kt)}function Qt(e){return tn(e,!1,Pt,Ut,qt)}function $t(e){return tn(e,!0,Nt,Wt,Jt)}function en(e){return tn(e,!0,Ft,Gt,Yt)}function tn(e,t,n,r,i){if(!x(e)||e.__v_raw&&!(t&&e.__v_isReactive)||e.__v_skip||!Object.isExtensible(e))return e;let a=i.get(e);if(a)return a;let o=Xt(ee(e));if(o===0)return e;let s=new Proxy(e,o===2?r:n);return i.set(e,s),s}function nn(e){return rn(e)?nn(e.__v_raw):!!(e&&e.__v_isReactive)}function rn(e){return!!(e&&e.__v_isReadonly)}function an(e){return!!(e&&e.__v_isShallow)}function on(e){return e?!!e.__v_raw:!1}function A(e){let t=e&&e.__v_raw;return t?A(t):e}function sn(e){return!f(e,`__v_skip`)&&Object.isExtensible(e)&&ue(e,`__v_skip`,!0),e}var cn=e=>x(e)?Zt(e):e,ln=e=>x(e)?$t(e):e;function j(e){return e?e.__v_isRef===!0:!1}function M(e){return dn(e,!1)}function un(e){return dn(e,!0)}function dn(e,t){return j(e)?e:new fn(e,t)}var fn=class{constructor(e,t){this.dep=new st,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=t?e:A(e),this._value=t?e:cn(e),this.__v_isShallow=t}get value(){return this.dep.track(),this._value}set value(e){let t=this._rawValue,n=this.__v_isShallow||an(e)||rn(e);e=n?e:A(e),D(e,t)&&(this._rawValue=e,this._value=n?e:cn(e),this.dep.trigger())}};function pn(e){e.dep&&e.dep.trigger()}function N(e){return j(e)?e.value:e}function mn(e){return v(e)?e():N(e)}var hn={get:(e,t,n)=>t===`__v_raw`?e:N(Reflect.get(e,t,n)),set:(e,t,n,r)=>{let i=e[t];return j(i)&&!j(n)?(i.value=n,!0):Reflect.set(e,t,n,r)}};function gn(e){return nn(e)?e:new Proxy(e,hn)}var _n=class{constructor(e){this.__v_isRef=!0,this._value=void 0;let t=this.dep=new st,{get:n,set:r}=e(t.track.bind(t),t.trigger.bind(t));this._get=n,this._set=r}get value(){return this._value=this._get()}set value(e){this._set(e)}};function vn(e){return new _n(e)}function yn(e){let t=p(e)?Array(e.length):{};for(let n in e)t[n]=Cn(e,n);return t}var bn=class{constructor(e,t,n){this._object=e,this._defaultValue=n,this.__v_isRef=!0,this._value=void 0,this._key=b(t)?t:String(t),this._raw=A(e);let r=!0,i=e;if(!p(e)||b(this._key)||!T(this._key))do r=!on(i)||an(i);while(r&&(i=i.__v_raw));this._shallow=r}get value(){let e=this._object[this._key];return this._shallow&&(e=N(e)),this._value=e===void 0?this._defaultValue:e}set value(e){if(this._shallow&&j(this._raw[this._key])){let t=this._object[this._key];if(j(t)){t.value=e;return}}this._object[this._key]=e}get dep(){return ht(this._raw,this._key)}},xn=class{constructor(e){this._getter=e,this.__v_isRef=!0,this.__v_isReadonly=!0,this._value=void 0}get value(){return this._value=this._getter()}};function Sn(e,t,n){return j(e)?e:v(e)?new xn(e):x(e)&&arguments.length>1?Cn(e,t,n):M(e)}function Cn(e,t,n){return new bn(e,t,n)}var wn=class{constructor(e,t,n){this.fn=e,this.setter=t,this._value=void 0,this.dep=new st(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=at-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!t,this.isSSR=n}notify(){if(this.flags|=16,!(this.flags&8)&&Le!==this)return Ue(this,!0),!0}get value(){let e=this.dep.track();return Ye(this),e&&(e.version=this.dep.version),this._value}set value(e){this.setter&&this.setter(e)}};function Tn(e,t,n=!1){let r,i;return v(e)?r=e:(r=e.get,i=e.set),new wn(r,i,n)}var En={GET:`get`,HAS:`has`,ITERATE:`iterate`},Dn={SET:`set`,ADD:`add`,DELETE:`delete`,CLEAR:`clear`},On={},kn=new WeakMap,An=void 0;function jn(){return An}function Mn(e,t=!1,n=An){if(n){let t=kn.get(n);t||kn.set(n,t=[]),t.push(e)}}function Nn(e,t,n=r){let{immediate:i,deep:o,once:s,scheduler:c,augmentJob:l,call:d}=n,f=e=>o?e:an(e)||o===!1||o===0?Pn(e,1):Pn(e),m,h,g,_,y=!1,b=!1;if(j(e)?(h=()=>e.value,y=an(e)):nn(e)?(h=()=>f(e),y=!0):p(e)?(b=!0,y=e.some(e=>nn(e)||an(e)),h=()=>e.map(e=>{if(j(e))return e.value;if(nn(e))return f(e);if(v(e))return d?d(e,2):e()})):h=v(e)?t?d?()=>d(e,2):e:()=>{if(g){nt();try{g()}finally{rt()}}let t=An;An=m;try{return d?d(e,3,[_]):e(_)}finally{An=t}}:a,t&&o){let e=h,t=o===!0?1/0:o;h=()=>Pn(e(),t)}let x=Fe(),S=()=>{m.stop(),x&&x.active&&u(x.effects,m)};if(s&&t){let e=t;t=(...t)=>{let n=e(...t);return S(),n}}let C=b?Array(e.length).fill(On):On,w=e=>{if(!(!(m.flags&1)||!m.dirty&&!e)){if(t){let n=m.run();if(e||o||y||(b?n.some((e,t)=>D(e,C[t])):D(n,C))){g&&g();let e=An;An=m;try{let e=[n,C===On?void 0:b&&C[0]===On?[]:C,_];C=n,d?d(t,3,e):t(...e)}finally{An=e}}}else m.run()}};return l&&l(w),m=new ze(h),m.scheduler=c?()=>c(w,!1):w,_=e=>Mn(e,!1,m),g=m.onStop=()=>{let e=kn.get(m);if(e){if(d)d(e,4);else for(let t of e)t();kn.delete(m)}},t?i?w(!0):C=m.run():c?c(w.bind(null,!0),!0):m.run(),S.pause=m.pause.bind(m),S.resume=m.resume.bind(m),S.stop=S,S}function Pn(e,t=1/0,n){if(t<=0||!x(e)||e.__v_skip||(n||=new Map,(n.get(e)||0)>=t))return e;if(n.set(e,t),t--,j(e))Pn(e.value,t,n);else if(p(e))for(let r=0;r<e.length;r++)Pn(e[r],t,n);else if(h(e)||m(e))e.forEach(e=>{Pn(e,t,n)});else if(te(e)){for(let r in e)Pn(e[r],t,n);for(let r of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,r)&&Pn(e[r],t,n)}return e}var Fn=[];function In(e){Fn.push(e)}function Ln(){Fn.pop()}function Rn(e,t){}var zn={SETUP_FUNCTION:0,0:`SETUP_FUNCTION`,RENDER_FUNCTION:1,1:`RENDER_FUNCTION`,NATIVE_EVENT_HANDLER:5,5:`NATIVE_EVENT_HANDLER`,COMPONENT_EVENT_HANDLER:6,6:`COMPONENT_EVENT_HANDLER`,VNODE_HOOK:7,7:`VNODE_HOOK`,DIRECTIVE_HOOK:8,8:`DIRECTIVE_HOOK`,TRANSITION_HOOK:9,9:`TRANSITION_HOOK`,APP_ERROR_HANDLER:10,10:`APP_ERROR_HANDLER`,APP_WARN_HANDLER:11,11:`APP_WARN_HANDLER`,FUNCTION_REF:12,12:`FUNCTION_REF`,ASYNC_COMPONENT_LOADER:13,13:`ASYNC_COMPONENT_LOADER`,SCHEDULER:14,14:`SCHEDULER`,COMPONENT_UPDATE:15,15:`COMPONENT_UPDATE`,APP_UNMOUNT_CLEANUP:16,16:`APP_UNMOUNT_CLEANUP`},Bn={sp:`serverPrefetch hook`,bc:`beforeCreate hook`,c:`created hook`,bm:`beforeMount hook`,m:`mounted hook`,bu:`beforeUpdate hook`,u:`updated`,bum:`beforeUnmount hook`,um:`unmounted hook`,a:`activated hook`,da:`deactivated hook`,ec:`errorCaptured hook`,rtc:`renderTracked hook`,rtg:`renderTriggered hook`,0:`setup function`,1:`render function`,2:`watcher getter`,3:`watcher callback`,4:`watcher cleanup function`,5:`native event handler`,6:`component event handler`,7:`vnode hook`,8:`directive hook`,9:`transition hook`,10:`app errorHandler`,11:`app warnHandler`,12:`ref function`,13:`async component loader`,14:`scheduler flush`,15:`component update`,16:`app unmount cleanup function`};function Vn(e,t,n,r){try{return r?e(...r):e()}catch(e){Un(e,t,n)}}function Hn(e,t,n,r){if(v(e)){let i=Vn(e,t,n,r);return i&&S(i)&&i.catch(e=>{Un(e,t,n)}),i}if(p(e)){let i=[];for(let a=0;a<e.length;a++)i.push(Hn(e[a],t,n,r));return i}}function Un(e,t,n,i=!0){let a=t?t.vnode:null,{errorHandler:o,throwUnhandledErrorInProduction:s}=t&&t.appContext.config||r;if(t){let r=t.parent,i=t.proxy,a=`https://vuejs.org/error-reference/#runtime-${n}`;for(;r;){let t=r.ec;if(t){for(let n=0;n<t.length;n++)if(t[n](e,i,a)===!1)return}r=r.parent}if(o){nt(),Vn(o,null,10,[e,i,a]),rt();return}}Wn(e,n,a,i,s)}function Wn(e,t,n,r=!0,i=!1){if(i)throw e;console.error(e)}var Gn=[],Kn=-1,qn=[],Jn=null,Yn=0,Xn=Promise.resolve(),Zn=null;function Qn(e){let t=Zn||Xn;return e?t.then(this?e.bind(this):e):t}function $n(e){let t=Kn+1,n=Gn.length;for(;t<n;){let r=t+n>>>1,i=Gn[r],a=ar(i);a<e||a===e&&i.flags&2?t=r+1:n=r}return t}function er(e){if(!(e.flags&1)){let t=ar(e),n=Gn[Gn.length-1];!n||!(e.flags&2)&&t>=ar(n)?Gn.push(e):Gn.splice($n(t),0,e),e.flags|=1,tr()}}function tr(){Zn||=Xn.then(or)}function nr(e){if(!p(e))Jn&&e.id===-1?Jn.splice(Yn+1,0,e):e.flags&1||(qn.push(e),e.flags|=1);else for(let t=0;t<e.length;t++)qn.push(e[t]);tr()}function rr(e,t,n=Kn+1){for(;n<Gn.length;n++){let t=Gn[n];if(t&&t.flags&2){if(e&&t.id!==e.uid)continue;Gn.splice(n,1),n--,t.flags&4&&(t.flags&=-2),t(),t.flags&4||(t.flags&=-2)}}}function ir(e){if(qn.length){let e=[...new Set(qn)].sort((e,t)=>ar(e)-ar(t));if(qn.length=0,Jn){for(let t=0;t<e.length;t++)Jn.push(e[t]);return}for(Jn=e,Yn=0;Yn<Jn.length;Yn++){let e=Jn[Yn];e.flags&4&&(e.flags&=-2),e.flags&8||e(),e.flags&=-2}Jn=null,Yn=0}}var ar=e=>e.id==null?e.flags&2?-1:1/0:e.id;function or(e){try{for(Kn=0;Kn<Gn.length;Kn++){let e=Gn[Kn];e&&!(e.flags&8)&&(e.flags&4&&(e.flags&=-2),Vn(e,e.i,e.i?15:14),e.flags&4||(e.flags&=-2))}}finally{for(;Kn<Gn.length;Kn++){let e=Gn[Kn];e&&(e.flags&=-2)}Kn=-1,Gn.length=0,ir(e),Zn=null,(Gn.length||qn.length)&&or(e)}}var sr,cr=[];function lr(e,t){sr=e,sr?(sr.enabled=!0,cr.forEach(({event:e,args:t})=>sr.emit(e,...t)),cr=[]):typeof window<`u`&&window.HTMLElement&&!(window.navigator?.userAgent)?.includes(`jsdom`)?((t.__VUE_DEVTOOLS_HOOK_REPLAY__=t.__VUE_DEVTOOLS_HOOK_REPLAY__||[]).push(e=>{lr(e,t)}),setTimeout(()=>{sr||(t.__VUE_DEVTOOLS_HOOK_REPLAY__=null,cr=[])},3e3)):cr=[]}var ur=null,dr=null;function fr(e){let t=ur;return ur=e,dr=e&&e.type.__scopeId||null,t}function pr(e){dr=e}function mr(){dr=null}var hr=e=>P;function P(e,t=ur,n){if(!t||e._n)return e;let r=(...n)=>{r._d&&ms(-1);let i=fr(t),a=us.length,o;try{o=e(...n)}finally{for(let e=us.length;e>a;e--)fs();fr(i),r._d&&ms(1)}return o};return r._n=!0,r._c=!0,r._d=!0,r}function gr(e,t){if(ur===null)return e;let n=Qs(ur),i=e.dirs||=[];for(let e=0;e<t.length;e++){let[a,o,s,c=r]=t[e];a&&(v(a)&&(a={mounted:a,updated:a}),a.deep&&Pn(o),i.push({dir:a,instance:n,value:o,oldValue:void 0,arg:s,modifiers:c}))}return e}function _r(e,t,n,r){let i=e.dirs,a=t&&t.dirs;for(let o=0;o<i.length;o++){let s=i[o];a&&(s.oldValue=a[o].value);let c=s.dir[r];c&&(nt(),Hn(c,n,8,[e.el,s,e,t]),rt())}}function vr(e,t){if(Ps){let n=Ps.provides,r=Ps.parent&&Ps.parent.provides;r===n&&(n=Ps.provides=Object.create(r)),n[e]=t}}function yr(e,t,n=!1){let r=Fs();if(r||no){let i=no?no._context.provides:r?r.parent==null||r.ce?r.vnode.appContext&&r.vnode.appContext.provides:r.parent.provides:void 0;if(i&&e in i)return i[e];if(arguments.length>1)return n&&v(t)?t.call(r&&r.proxy):t}}function br(){return!!(Fs()||no)}var xr=Symbol.for(`v-scx`),Sr=()=>yr(xr);function Cr(e,t){return Dr(e,null,t)}function wr(e,t){return Dr(e,null,{flush:`post`})}function Tr(e,t){return Dr(e,null,{flush:`sync`})}function Er(e,t,n){return Dr(e,t,n)}function Dr(e,t,n=r){let{immediate:i,deep:o,flush:s,once:c}=n,u=l({},n),d=t&&i||!t&&s!==`post`,f;if(Vs){if(s===`sync`){let e=Sr();f=e.__watcherHandles||=[]}else if(!d){let e=()=>{};return e.stop=a,e.resume=a,e.pause=a,e}}let p=Ps;u.call=(e,t,n)=>Hn(e,p,t,n);let m=!1;s===`post`?u.scheduler=e=>{Io(e,p&&p.suspense)}:s!==`sync`&&(m=!0,u.scheduler=(e,t)=>{t?e():er(e)}),u.augmentJob=e=>{t&&(e.flags|=4),m&&(e.flags|=2,p&&(e.id=p.uid,e.i=p))};let h=Nn(e,t,u);return Vs&&(f?f.push(h):d&&h()),h}function Or(e,t,n){let r=this.proxy,i=y(e)?e.includes(`.`)?kr(r,e):()=>r[e]:e.bind(r,r),a;v(t)?a=t:(a=t.handler,n=t);let o=Rs(this),s=Dr(i,a.bind(r),n);return o(),s}function kr(e,t){let n=t.split(`.`);return()=>{let t=e;for(let e=0;e<n.length&&t;e++)t=t[n[e]];return t}}var Ar=new WeakMap,jr=Symbol(`_vte`),Mr=e=>e.__isTeleport,Nr=e=>e&&(e.disabled||e.disabled===``),Pr=e=>e&&(e.defer||e.defer===``),Fr=e=>typeof SVGElement<`u`&&e instanceof SVGElement,Ir=e=>typeof MathMLElement==`function`&&e instanceof MathMLElement,Lr=(e,t)=>{let n=e&&e.to;return y(n)?t?t(n):null:n},Rr={name:`Teleport`,__isTeleport:!0,process(e,t,n,r,i,a,o,s,c,l){let{mc:u,pc:d,pbc:f,o:{insert:p,querySelector:m,createText:h,createComment:g,parentNode:_}}=l,v=Nr(t.props),{dynamicChildren:y}=t,b=(e,t,n)=>{e.shapeFlag&16&&u(e.children,t,n,i,a,o,s,c)},x=(e=t)=>{let n=Nr(e.props),r=e.target=Lr(e.props,m),a=Ur(r,e,h,p);r&&(o!==`svg`&&Fr(r)?o=`svg`:o!==`mathml`&&Ir(r)&&(o=`mathml`),i&&i.isCE&&(i.ce._teleportTargets||(i.ce._teleportTargets=new Set)).add(r),n||(b(e,r,a),Hr(e,!1)))},S=e=>{let t=()=>{if(Ar.get(e)===t){if(Ar.delete(e),Nr(e.props)){let t=_(e.el)||n;b(e,t,e.anchor),Hr(e,!0)}x(e)}};Ar.set(e,t),Io(t,a)};if(e==null){let e=t.el=h(``),i=t.anchor=h(``);if(p(e,n,r),p(i,n,r),Pr(t.props)||a&&a.pendingBranch){S(t);return}v&&(b(t,n,i),Hr(t,!0)),x()}else{t.el=e.el;let r=t.anchor=e.anchor,u=Ar.get(e);if(u){u.flags|=8,Ar.delete(e),S(t);return}t.targetStart=e.targetStart;let p=t.target=e.target,h=t.targetAnchor=e.targetAnchor,g=Nr(e.props),_=g?n:p,b=g?r:h;if(o===`svg`||Fr(p)?o=`svg`:(o===`mathml`||Ir(p))&&(o=`mathml`),y?(f(e.dynamicChildren,y,_,i,a,o,s),Uo(e,t,!0)):c||d(e,t,_,b,i,a,o,s,!1),v)g?t.props&&e.props&&t.props.to!==e.props.to&&(t.props.to=e.props.to):zr(t,n,r,l,1);else if((t.props&&t.props.to)!==(e.props&&e.props.to)){let e=Lr(t.props,m);e&&(t.target=e,zr(t,e,null,l,0))}else g&&zr(t,p,h,l,1);Hr(t,v)}},remove(e,t,n,{um:r,o:{remove:i}},a){let{shapeFlag:o,children:s,anchor:c,targetStart:l,targetAnchor:u,target:d,props:f}=e,p=Nr(f),m=a||!p,h=Ar.get(e);if(h&&(h.flags|=8,Ar.delete(e)),d&&(i(l),i(u)),a&&i(c),!h&&(p||d)&&o&16)for(let e=0;e<s.length;e++){let i=s[e];r(i,t,n,m,!!i.dynamicChildren)}},move:zr,hydrate:Br};function zr(e,t,n,{o:{insert:r},m:i},a=2){a===0&&r(e.targetAnchor,t,n);let{el:o,anchor:s,shapeFlag:c,children:l,props:u}=e,d=a===2;if(d&&r(o,t,n),!Ar.has(e)&&(!d||Nr(u))&&c&16)for(let e=0;e<l.length;e++)i(l[e],t,n,2);d&&r(s,t,n)}function Br(e,t,n,r,i,a,{o:{nextSibling:o,parentNode:s,querySelector:c,insert:l,createText:u}},d){function f(e,n){let r=n;for(;r;){if(r&&r.nodeType===8){if(r.data===`teleport start anchor`)t.targetStart=r;else if(r.data===`teleport anchor`){t.targetAnchor=r,e._lpa=t.targetAnchor&&o(t.targetAnchor);break}}r=o(r)}}function p(e,t){t.anchor=d(o(e),t,s(e),n,r,i,a)}let m=t.target=Lr(t.props,c),h=Nr(t.props);if(m){let c=m._lpa||m.firstChild;t.shapeFlag&16&&(h?(p(e,t),f(m,c),t.targetAnchor||Ur(m,t,u,l,s(e)===m?e:null)):(t.anchor=o(e),f(m,c),t.targetAnchor||Ur(m,t,u,l),d(c&&o(c),t,m,n,r,i,a))),Hr(t,h)}else h&&t.shapeFlag&16&&(p(e,t),t.targetStart=e,t.targetAnchor=o(e));return t.anchor&&o(t.anchor)}var Vr=Rr;function Hr(e,t){let n=e.ctx;if(n&&n.ut){let r,i;for(t?(r=e.el,i=e.anchor):(r=e.targetStart,i=e.targetAnchor);r&&r!==i;)r.nodeType===1&&r.setAttribute(`data-v-owner`,n.uid),r=r.nextSibling;n.ut()}}function Ur(e,t,n,r,i=null){let a=t.targetStart=n(``),o=t.targetAnchor=n(``);return a[jr]=o,e&&(r(a,e,i),r(o,e,i)),o}var Wr=Symbol(`_leaveCb`),Gr=Symbol(`_enterCb`);function Kr(){let e={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return Zi(()=>{e.isMounted=!0}),ea(()=>{e.isUnmounting=!0}),e}var qr=[Function,Array],Jr={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:qr,onEnter:qr,onAfterEnter:qr,onEnterCancelled:qr,onBeforeLeave:qr,onLeave:qr,onAfterLeave:qr,onLeaveCancelled:qr,onBeforeAppear:qr,onAppear:qr,onAfterAppear:qr,onAppearCancelled:qr},Yr=e=>{let t=e.subTree;return t.component?Yr(t.component):t},Xr={name:`BaseTransition`,props:Jr,setup(e,{slots:t}){let n=Fs(),r=Kr();return()=>{let i=t.default&&ii(t.default(),!0),a=i&&i.length?Zr(i):n.subTree?Ts():void 0;if(!a)return;let o=A(e),{mode:s}=o;if(r.isLeaving)return ti(a);let c=ni(a);if(!c)return ti(a);let l=ei(c,o,r,n,e=>l=e);c.type!==cs&&ri(c,l);let u=n.subTree&&ni(n.subTree);if(u&&u.type!==cs&&!_s(u,c)&&Yr(n).type!==cs){let e=ei(u,o,r,n);if(ri(u,e),s===`out-in`&&c.type!==cs)return r.isLeaving=!0,e.afterLeave=()=>{r.isLeaving=!1,n.job.flags&8||n.update(),delete e.afterLeave,u=void 0},ti(a);s===`in-out`&&c.type!==cs?e.delayLeave=(e,t,n)=>{let i=$r(r,u);i[String(u.key)]=u,e[Wr]=()=>{t(),e[Wr]=void 0,delete l.delayedLeave,u=void 0},l.delayedLeave=()=>{n(),delete l.delayedLeave,u=void 0}}:u=void 0}else u&&=void 0;return a}}};function Zr(e){let t=e[0];if(e.length>1){for(let n of e)if(n.type!==cs){t=n;break}}return t}var Qr=Xr;function $r(e,t){let{leavingVNodes:n}=e,r=n.get(t.type);return r||(r=Object.create(null),n.set(t.type,r)),r}function ei(e,t,n,r,i){let{appear:a,mode:o,persisted:s=!1,onBeforeEnter:c,onEnter:l,onAfterEnter:u,onEnterCancelled:d,onBeforeLeave:f,onLeave:m,onAfterLeave:h,onLeaveCancelled:g,onBeforeAppear:_,onAppear:v,onAfterAppear:y,onAppearCancelled:b}=t,x=String(e.key),S=$r(n,e),C=(e,t)=>{e&&Hn(e,r,9,t)},w=(e,t)=>{let n=t[1];C(e,t),p(e)?e.every(e=>e.length<=1)&&n():e.length<=1&&n()},ee={mode:o,persisted:s,beforeEnter(t){let r=c;if(!n.isMounted){if(a)r=_||c;else return}t[Wr]&&t[Wr](!0);let i=S[x];i&&_s(e,i)&&i.el[Wr]&&i.el[Wr](),C(r,[t])},enter(t){if(S[x]===e)return;let r=l,i=u,o=d;if(!n.isMounted){if(a)r=v||l,i=y||u,o=b||d;else return}let s=!1;t[Gr]=e=>{s||(s=!0,C(e?o:i,[t]),ee.delayedLeave&&ee.delayedLeave(),t[Gr]=void 0)};let c=t[Gr].bind(null,!1);r?w(r,[t,c]):c()},leave(t,r){let i=String(e.key);if(t[Gr]&&t[Gr](!0),n.isUnmounting)return r();C(f,[t]);let a=!1;t[Wr]=n=>{a||(a=!0,r(),C(n?g:h,[t]),t[Wr]=void 0,S[i]===e&&delete S[i])};let o=t[Wr].bind(null,!1);S[i]=e,m?w(m,[t,o]):o()},clone(e){let a=ei(e,t,n,r,i);return i&&i(a),a}};return ee}function ti(e){if(zi(e))return e=Cs(e),e.children=null,e}function ni(e){if(!zi(e))return Mr(e.type)&&e.children?Zr(e.children):e;if(e.component)return e.component.subTree;let{shapeFlag:t,children:n}=e;if(n){if(t&16)return n[0];if(t&32&&v(n.default))return n.default()}}function ri(e,t){if(e.shapeFlag&6&&e.component){e.transition=t;let n=e.component.subTree;ri(Mr(n.type)&&ni(n)||n,t)}else e.shapeFlag&128?(e.ssContent.transition=t.clone(e.ssContent),e.ssFallback.transition=t.clone(e.ssFallback)):e.transition=t}function ii(e,t=!1,n){let r=[],i=0;for(let a=0;a<e.length;a++){let o=e[a],s=n==null?o.key:String(n)+String(o.key==null?a:o.key);o.type===L?(o.patchFlag&128&&i++,r=r.concat(ii(o.children,t,s))):(t||o.type!==cs)&&r.push(s==null?o:Cs(o,{key:s}))}if(i>1)for(let e=0;e<r.length;e++)r[e].patchFlag=-2;return r}function F(e,t){return v(e)?l({name:e.name},t,{setup:e}):e}function ai(){let e=Fs();return e?(e.appContext.config.idPrefix||`v`)+`-`+e.ids[0]+e.ids[1]++:``}function oi(e){e.ids=[e.ids[0]+e.ids[2]+++`-`,0,0]}function si(e){let t=Fs(),n=un(null);if(t){let i=t.refs===r?t.refs={}:t.refs;Object.defineProperty(i,e,{enumerable:!0,get:()=>n.value,set:e=>n.value=e})}return n}function ci(e,t){let n;return!!((n=Object.getOwnPropertyDescriptor(e,t))&&!n.configurable)}var li=new WeakMap;function ui(e,t,n,i,a=!1){if(p(e)){e.forEach((e,r)=>ui(e,t&&(p(t)?t[r]:t),n,i,a));return}if(Ii(i)&&!a){i.shapeFlag&512&&i.type.__asyncResolved&&i.component.subTree.component&&ui(e,t,n,i.component.subTree);return}let s=i.shapeFlag&4?Qs(i.component):i.el,c=a?null:s,{i:l,r:d}=e,m=t&&t.r,h=l.refs===r?l.refs={}:l.refs,g=l.setupState,_=A(g),b=g===r?o:e=>!ci(h,e)&&f(_,e),x=(e,t)=>!(t&&ci(h,t));if(m!=null&&m!==d){if(di(t),y(m))h[m]=null,b(m)&&(g[m]=null);else if(j(m)){let e=t;x(m,e.k)&&(m.value=null),e.k&&(h[e.k]=null)}}if(v(d))Vn(d,l,12,[c,h]);else{let t=y(d),r=j(d);if(t||r){let i=()=>{if(e.f){let n=t?b(d)?g[d]:h[d]:x(d)||!e.k?d.value:h[e.k];if(a)p(n)&&u(n,s);else if(p(n))n.includes(s)||n.push(s);else if(t)h[d]=[s],b(d)&&(g[d]=h[d]);else{let t=[s];x(d,e.k)&&(d.value=t),e.k&&(h[e.k]=t)}}else t?(h[d]=c,b(d)&&(g[d]=c)):r&&(x(d,e.k)&&(d.value=c),e.k&&(h[e.k]=c))};if(c){let t=()=>{i(),li.delete(e)};t.id=-1,li.set(e,t),Io(t,n)}else di(e),i()}}}function di(e){let t=li.get(e);t&&(t.flags|=8,li.delete(e))}var fi=!1,pi=()=>{fi||=(console.error(`Hydration completed but contains mismatches.`),!0)},mi=e=>e.namespaceURI.includes(`svg`)&&e.tagName!==`foreignObject`,hi=e=>e.namespaceURI.includes(`MathML`),gi=e=>{if(e.nodeType===1){if(mi(e))return`svg`;if(hi(e))return`mathml`}},_i=e=>e.nodeType===8;function vi(e){let{mt:t,p:n,o:{patchProp:r,createText:i,nextSibling:a,parentNode:o,remove:c,insert:l,createComment:u}}=e,d=(e,t)=>{if(!t.hasChildNodes()){n(null,e,t),ir(),t._vnode=e;return}f(t.firstChild,e,null,null,null),ir(),t._vnode=e},f=(n,r,s,c,u,d=!1)=>{d||=!!r.dynamicChildren;let b=_i(n)&&n.data===`[`,x=()=>g(n,r,s,c,u,b),{type:S,ref:C,shapeFlag:w,patchFlag:ee}=r,te=n.nodeType;r.el=n,ee===-2&&(d=!1,r.dynamicChildren=null);let T=null;switch(S){case ss:te===3?(n.data!==r.children&&(pi(),n.data=r.children),T=a(n)):r.children===``?(l(r.el=i(``),o(n),n),T=n):T=x();break;case cs:y(n)?(T=a(n),v(r.el=n.content.firstChild,n,s)):T=te!==8||b?x():a(n);break;case ls:if(b&&(n=a(n),te=n.nodeType),te===1||te===3){T=n;let e=!r.children.length;for(let t=0;t<r.staticCount;t++)e&&(r.children+=T.nodeType===1?T.outerHTML:T.data),t===r.staticCount-1&&(r.anchor=T),T=a(T);return b?a(T):T}x();break;case L:T=b?h(n,r,s,c,u,d):x();break;default:if(w&1)T=(te!==1||r.type.toLowerCase()!==n.tagName.toLowerCase())&&!y(n)?x():p(n,r,s,c,u,d);else if(w&6){r.slotScopeIds=u;let e=o(n);if(T=b?_(n):_i(n)&&n.data===`teleport start`?_(n,n.data,`teleport end`):a(n),t(r,e,null,s,c,gi(e),d),Ii(r)&&!r.type.__asyncResolved){let t;b?(t=H(L),t.anchor=T?T.previousSibling:e.lastChild):t=n.nodeType===3?U(``):H(`div`),t.el=n,r.component.subTree=t}}else w&64?T=te===8?r.type.hydrate(n,r,s,c,u,d,e,m):x():w&128&&(T=r.type.hydrate(n,r,s,c,gi(o(n)),u,d,e,f))}return C!=null&&ui(C,null,c,r),T},p=(e,t,n,i,a,o)=>{o||=!!t.dynamicChildren;let{type:l,dynamicProps:u,props:d,patchFlag:f,shapeFlag:p,dirs:h,transition:g}=t,_=l===`input`||l===`option`,b=!!u;if(_||b||f!==-1){h&&_r(t,null,n,`created`);let l=!1;if(y(e)){l=Ho(null,g)&&n&&n.vnode.props&&n.vnode.props.appear;let r=e.content.firstChild;if(l){let e=r.getAttribute(`class`);e&&(r.$cls=e),g.beforeEnter(r)}v(r,e,n),t.el=e=r}if(p&16&&!(d&&(d.innerHTML||d.textContent))){let r=m(e.firstChild,t,e,n,i,a,o);for(r&&!Ci(e,1)&&pi();r;){let e=r;r=r.nextSibling,c(e)}}else if(p&8){let n=t.children;n[0]===`
`&&(e.tagName===`PRE`||e.tagName===`TEXTAREA`)&&(n=n.slice(1));let{textContent:r}=e;r!==n&&r!==n.replace(/\r\n|\r/g,`
`)&&(Ci(e,0)||pi(),e.textContent=t.children)}if(d){if(_||b||!o||f&48){let t=e.tagName.includes(`-`),i=e.namespaceURI.includes(`svg`)?`svg`:e.namespaceURI.includes(`MathML`)?`mathml`:void 0;for(let a in d)if(_&&(a.endsWith(`value`)||a===`indeterminate`)||s(a)&&!ne(a)||a[0]===`.`||t&&!ne(a)||u&&u.includes(a)){if(bi(e,a,d[a]))continue;r(e,a,null,d[a],i,n)}}else if(d.onClick)r(e,`onClick`,null,d.onClick,void 0,n);else if(f&4&&nn(d.style))for(let e in d.style)d.style[e]}let x;(x=d&&d.onVnodeBeforeMount)&&As(x,n,t),h&&_r(t,null,n,`beforeMount`),((x=d&&d.onVnodeMounted)||h||l)&&is(()=>{x&&As(x,n,t),l&&g.enter(e),h&&_r(t,null,n,`mounted`)},i)}return e.nextSibling},m=(e,t,r,o,s,c,u)=>{u||=!!t.dynamicChildren;let d=t.children,p=d.length,m=!1;for(let t=0;t<p;t++){let h=u?d[t]:d[t]=Es(d[t]),g=h.type===ss;e?(g&&!u&&t+1<p&&Es(d[t+1]).type===ss&&(l(i(e.data.slice(h.children.length)),r,a(e)),e.data=h.children),e=f(e,h,o,s,c,u)):g&&!h.children?l(h.el=i(``),r):(m||(m=!0,Ci(r,1)||pi()),n(null,h,r,null,o,s,gi(r),c))}return e},h=(e,t,n,r,i,s)=>{let{slotScopeIds:c}=t;c&&(i=i?i.concat(c):c);let d=o(e),f=m(a(e),t,d,n,r,i,s);return f&&_i(f)&&f.data===`]`?a(t.anchor=f):(pi(),l(t.anchor=u(`]`),d,f),f)},g=(e,t,r,i,s,l)=>{if(Ti(e,t)||pi(),t.el=null,l){let t=_(e);for(;;){let n=a(e);if(n&&n!==t)c(n);else break}}let u=a(e),d=o(e);return c(e),n(null,t,d,u,r,i,gi(d),s),r&&(r.vnode.el=t.el,_o(r,t.el)),u},_=(e,t=`[`,n=`]`)=>{let r=0;for(;e;)if(e=a(e),e&&_i(e)&&(e.data===t&&r++,e.data===n)){if(r===0)return a(e);r--}return e},v=(e,t,n)=>{let r=t.parentNode;r&&r.replaceChild(e,t);let i=n;for(;i;)i.vnode.el===t&&(i.vnode.el=i.subTree.el=e),i=i.parent},y=e=>e.nodeType===1&&e.tagName===`TEMPLATE`;return[d,f]}var yi=new Set([`src`,`srcset`,`href`,`poster`]);function bi(e,t,n){return yi.has(t)?e.getAttribute(t)===(n==null?null:`${n}`):!1}var xi=`data-allow-mismatch`,Si={0:`text`,1:`children`,2:`class`,3:`style`,4:`attribute`};function Ci(e,t){if(t===0||t===1)for(;e&&!e.hasAttribute(xi);)e=e.parentElement;return wi(e&&e.getAttribute(xi),t)}function wi(e,t){if(e==null)return!1;if(e===``)return!0;{let n=e.split(`,`);return t===0&&n.includes(`children`)?!0:n.includes(Si[t])}}function Ti(e,t){return Ci(e.parentElement,1)||Ei(e)||Di(t)}function Ei(e){return e.nodeType===1&&wi(e.getAttribute(xi),1)}function Di({props:e}){let t=e&&e[xi];return typeof t==`string`&&wi(t,1)}var Oi=me().requestIdleCallback||(e=>setTimeout(e,1)),ki=me().cancelIdleCallback||(e=>clearTimeout(e)),Ai=(e=1e4)=>t=>{let n=Oi(t,{timeout:e});return()=>ki(n)};function ji(e){let{top:t,left:n,bottom:r,right:i}=e.getBoundingClientRect(),{innerHeight:a,innerWidth:o}=window;return(t>0&&t<a||r>0&&r<a)&&(n>0&&n<o||i>0&&i<o)}var Mi=e=>(t,n)=>{let r=new IntersectionObserver(e=>{for(let n of e)if(n.isIntersecting){r.disconnect(),t();break}},e);return n(e=>{if(e instanceof Element){if(ji(e))return t(),r.disconnect(),!1;r.observe(e)}}),()=>r.disconnect()},Ni=e=>t=>{if(e){let n=matchMedia(e);if(n.matches)t();else return n.addEventListener(`change`,t,{once:!0}),()=>n.removeEventListener(`change`,t)}},Pi=(e=[])=>(t,n)=>{y(e)&&(e=[e]);let r=!1,i=e=>{r||(r=!0,a(),t(),e.target.dispatchEvent(new e.constructor(e.type,e)))},a=()=>{n(t=>{for(let n of e)t.removeEventListener(n,i)})};return n(t=>{for(let n of e)t.addEventListener(n,i,{once:!0})}),a};function Fi(e,t){if(_i(e)&&e.data===`[`){let n=1,r=e.nextSibling;for(;r;){if(r.nodeType===1){if(t(r)===!1)break}else if(_i(r)){if(r.data===`]`){if(--n===0)break}else r.data===`[`&&n++}r=r.nextSibling}}else t(e)}var Ii=e=>!!e.type.__asyncLoader;function Li(e){v(e)&&(e={loader:e});let{loader:t,loadingComponent:n,errorComponent:r,delay:i=200,hydrate:a,timeout:o,suspensible:s=!0,onError:c}=e,l=null,u,d=0,f=()=>(d++,l=null,p()),p=()=>{let e;return l||(e=l=t().catch(e=>{if(e=e instanceof Error?e:Error(String(e)),c)return new Promise((t,n)=>{c(e,()=>t(f()),()=>n(e),d+1)});throw e}).then(t=>e!==l&&l?l:(t&&(t.__esModule||t[Symbol.toStringTag]===`Module`)&&(t=t.default),u=t,t)))};return F({name:`AsyncComponentWrapper`,__asyncLoader:p,__asyncHydrate(e,t,n){let r=e.isConnected,i=!1;(t.bu||=[]).push(()=>i=!0);let o=()=>{i||!e.parentNode||r&&!e.isConnected||n()},s=a?()=>{let n=a(o,t=>Fi(e,t));n&&(t.bum||=[]).push(n)}:o;u?s():p().then(()=>!t.isUnmounted&&s())},get __asyncResolved(){return u},setup(){let e=Ps;if(oi(e),u)return()=>Ri(u,e);let t=t=>{l=null,Un(t,e,13,!r)};if(s&&e.suspense||Vs)return p().then(t=>()=>Ri(t,e)).catch(e=>(t(e),()=>r?H(r,{error:e}):null));let a=M(!1),c=M(),d=M(!!i),f,m;return ta(()=>{f!=null&&clearTimeout(f),m!=null&&clearTimeout(m)}),i&&(m=setTimeout(()=>{e.isUnmounted||(d.value=!1)},i)),o!=null&&(f=setTimeout(()=>{if(!e.isUnmounted&&!a.value&&!c.value){let e=Error(`Async component timed out after ${o}ms.`);t(e),c.value=e}},o)),p().then(()=>{e.isUnmounted||(a.value=!0,e.parent&&zi(e.parent.vnode)&&e.parent.update())}).catch(n=>{if(e.isUnmounted){l=null;return}t(n),c.value=n}),()=>{if(a.value&&u)return Ri(u,e);if(c.value&&r)return H(r,{error:c.value});if(n&&!d.value)return Ri(n,e)}}})}function Ri(e,t){let{ref:n,props:r,children:i,ce:a}=t.vnode,o=H(e,r,i);return o.ref=n,o.ce=a,delete t.vnode.ce,o}var zi=e=>e.type.__isKeepAlive,Bi={name:`KeepAlive`,__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(e,{slots:t}){let n=Fs(),r=n.ctx;if(!r.renderer)return()=>{let e=t.default&&t.default();return e&&e.length===1?e[0]:e};let i=new Map,a=new Set,o=null,s=n.suspense,{renderer:{p:c,m:l,um:u,o:{createElement:d}}}=r,f=d(`div`);r.activate=(e,t,n,r,i)=>{let a=e.component;l(e,t,n,0,s),c(a.vnode,e,t,n,a,s,r,e.slotScopeIds,i),Io(()=>{a.isDeactivated=!1,a.a&&le(a.a);let t=e.props&&e.props.onVnodeMounted;t&&As(t,a.parent,e)},s)},r.deactivate=e=>{let t=e.component;Ko(t.m),Ko(t.a),l(e,f,null,1,s),Io(()=>{t.da&&le(t.da);let n=e.props&&e.props.onVnodeUnmounted;n&&As(n,t.parent,e),t.isDeactivated=!0},s)};function p(e){Ki(e),u(e,n,s,!0)}function m(e){i.forEach((t,n)=>{let r=$s(Ii(t)?t.type.__asyncResolved||{}:t.type);r&&!e(r)&&h(n)})}function h(e){let t=i.get(e);t&&(!o||!_s(t,o))?p(t):o&&Ki(o),i.delete(e),a.delete(e)}Er(()=>[e.include,e.exclude],([e,t])=>{e&&m(t=>Vi(e,t)),t&&m(e=>!Vi(t,e))},{flush:`post`,deep:!0});let g=null,_=()=>{g!=null&&(Jo(n.subTree.type)?Io(()=>{i.set(g,qi(n.subTree))},n.subTree.suspense):i.set(g,qi(n.subTree)))};return Zi(_),$i(_),ea(()=>{i.forEach(e=>{let{subTree:t,suspense:r}=n,i=qi(t);if(e.type===i.type&&e.key===i.key){Ki(i);let e=i.component.da;e&&Io(e,r);return}p(e)})}),()=>{if(g=null,!t.default)return o=null;let n=t.default(),r=n[0];if(n.length>1)return o=null,n;if(!gs(r)||!(r.shapeFlag&4)&&!(r.shapeFlag&128))return o=null,r;let s=qi(r);if(s.type===cs)return o=null,s;let c=s.type,l=$s(Ii(s)?s.type.__asyncResolved||{}:c),{include:u,exclude:d,max:f}=e;if(u&&(!l||!Vi(u,l))||d&&l&&Vi(d,l))return s.shapeFlag&=-257,o=s,r;let p=s.key==null?c:s.key,m=i.get(p);return s.el&&(s=Cs(s),r.shapeFlag&128&&(r.ssContent=s)),g=p,m?(s.el=m.el,s.component=m.component,s.transition&&ri(s,s.transition),s.shapeFlag|=512,a.delete(p),a.add(p)):(a.add(p),f&&a.size>parseInt(f,10)&&h(a.values().next().value)),s.shapeFlag|=256,o=s,Jo(r.type)?r:s}}};function Vi(e,t){return p(e)?e.some(e=>Vi(e,t)):y(e)?e.split(`,`).includes(t):_(e)?(e.lastIndex=0,e.test(t)):!1}function Hi(e,t){Wi(e,`a`,t)}function Ui(e,t){Wi(e,`da`,t)}function Wi(e,t,n=Ps){let r=e.__wdc||=()=>{let t=n;for(;t;){if(t.isDeactivated)return;t=t.parent}return e()};if(Ji(t,r,n),n){let e=n.parent;for(;e&&e.parent;)zi(e.parent.vnode)&&Gi(r,t,n,e),e=e.parent}}function Gi(e,t,n,r){let i=Ji(t,e,r,!0);ta(()=>{u(r[t],i)},n)}function Ki(e){e.shapeFlag&=-257,e.shapeFlag&=-513}function qi(e){return e.shapeFlag&128?e.ssContent:e}function Ji(e,t,n=Ps,r=!1){if(n){let i=n[e]||(n[e]=[]),a=t.__weh||=(...r)=>{nt();let i=Rs(n),a=Hn(t,n,e,r);return i(),rt(),a};return r?i.unshift(a):i.push(a),a}}var Yi=e=>(t,n=Ps)=>{(!Vs||e===`sp`)&&Ji(e,(...e)=>t(...e),n)},Xi=Yi(`bm`),Zi=Yi(`m`),Qi=Yi(`bu`),$i=Yi(`u`),ea=Yi(`bum`),ta=Yi(`um`),na=Yi(`sp`),ra=Yi(`rtg`),ia=Yi(`rtc`);function aa(e,t=Ps){Ji(`ec`,e,t)}var oa=`components`,sa=`directives`;function ca(e,t){return fa(oa,e,!0,t)||e}var la=Symbol.for(`v-ndc`);function ua(e){return y(e)?fa(oa,e,!1)||e:e||la}function da(e){return fa(sa,e)}function fa(e,t,n=!0,r=!1){let i=ur||Ps;if(i){let n=i.type;if(e===oa){let e=$s(n,!1);if(e&&(e===t||e===E(t)||e===se(E(t))))return n}let a=pa(i[e]||n[e],t)||pa(i.appContext[e],t);return!a&&r?n:a}}function pa(e,t){return e&&(e[t]||e[E(t)]||e[se(E(t))])}function ma(e,t,n,r){let i,a=n&&n[r],o=p(e);if(o||y(e)){let n=o&&nn(e),r=!1,s=!1;n&&(r=!an(e),s=rn(e),e=_t(e)),i=Array(e.length);for(let n=0,o=e.length;n<o;n++)i[n]=t(r?s?ln(cn(e[n])):cn(e[n]):e[n],n,void 0,a&&a[n])}else if(typeof e==`number`){i=Array(e);for(let n=0;n<e;n++)i[n]=t(n+1,n,void 0,a&&a[n])}else if(x(e)){if(e[Symbol.iterator])i=Array.from(e,(e,n)=>t(e,n,void 0,a&&a[n]));else{let n=Object.keys(e);i=Array(n.length);for(let r=0,o=n.length;r<o;r++){let o=n[r];i[r]=t(e[o],o,r,a&&a[r])}}}else i=[];return n&&(n[r]=i),i}function ha(e,t){for(let n=0;n<t.length;n++){let r=t[n];if(p(r))for(let t=0;t<r.length;t++)e[r[t].name]=r[t].fn;else r&&(e[r.name]=r.key?(...e)=>{let t=r.fn(...e);return t&&(t.key=r.key),t}:r.fn)}return e}function I(e,t,n,r,i,a){if(n??={},ur.ce||ur.parent&&Ii(ur.parent)&&ur.parent.ce){let e=a!=null&&n.key==null?l({},n,{key:a}):n,i=Object.keys(e).length>0;return t!=="default"&&(e.name=t),R(),B(L,null,[H(`slot`,e,r&&r())],i?-2:64)}let o=e[t];o&&o._c&&(o._d=!1);let s=us.length;R();let c;try{let i=o&&ga(o(n)),s=n.key||a||i&&i.key;c=B(L,{key:(s&&!b(s)?s:`_${t}`)+(!i&&r?`_fb`:``)},i||(r?r():[]),i&&e._===1?64:-2)}catch(e){for(let e=us.length;e>s;e--)fs();throw e}finally{o&&o._c&&(o._d=!0)}return!i&&c.scopeId&&(c.slotScopeIds=[c.scopeId+`-s`]),c}function ga(e){return e.some(e=>!gs(e)||!(e.type===cs||e.type===L&&!ga(e.children)))?e:null}function _a(e,t){let n={};for(let r in e)n[t&&/[A-Z]/.test(r)?`on:${r}`:ce(r)]=e[r];return n}var va=e=>e?Bs(e)?Qs(e):va(e.parent):null,ya=l(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>e.props,$attrs:e=>e.attrs,$slots:e=>e.slots,$refs:e=>e.refs,$parent:e=>va(e.parent),$root:e=>va(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>Ua(e),$forceUpdate:e=>e.f||=()=>{er(e.update)},$nextTick:e=>e.n||=Qn.bind(e.proxy),$watch:e=>Or.bind(e)}),ba=(e,t)=>e!==r&&!e.__isScriptSetup&&f(e,t),xa={get({_:e},t){if(t===`__v_skip`)return!0;let{ctx:n,setupState:i,data:a,props:o,accessCache:s,type:c,appContext:l}=e;if(t[0]!==`$`){let e=s[t];if(e!==void 0)switch(e){case 1:return i[t];case 2:return a[t];case 4:return n[t];case 3:return o[t]}else if(ba(i,t))return s[t]=1,i[t];else if(a!==r&&f(a,t))return s[t]=2,a[t];else if(f(o,t))return s[t]=3,o[t];else if(n!==r&&f(n,t))return s[t]=4,n[t];else Ra&&(s[t]=0)}let u=ya[t],d,p;if(u)return t===`$attrs`&&pt(e.attrs,`get`,``),u(e);if((d=c.__cssModules)&&(d=d[t]))return d;if(n!==r&&f(n,t))return s[t]=4,n[t];if(p=l.config.globalProperties,f(p,t))return p[t]},set({_:e},t,n){let{data:i,setupState:a,ctx:o}=e;return ba(a,t)?(a[t]=n,!0):i!==r&&f(i,t)?(i[t]=n,!0):f(e.props,t)||t[0]===`$`&&t.slice(1)in e?!1:(o[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:i,appContext:a,props:o,type:s}},c){let l;return!!(n[c]||e!==r&&c[0]!==`$`&&f(e,c)||ba(t,c)||f(o,c)||f(i,c)||f(ya,c)||f(a.config.globalProperties,c)||(l=s.__cssModules)&&l[c])},defineProperty(e,t,n){return n.get==null?f(n,`value`)&&this.set(e,t,n.value,null):e._.accessCache[t]=0,Reflect.defineProperty(e,t,n)}},Sa=l({},xa,{get(e,t){if(t!==Symbol.unscopables)return xa.get(e,t,e)},has(e,t){return t[0]!==`_`&&!he(t)}});function Ca(){return null}function wa(){return null}function Ta(e){}function Ea(e){}function Da(){return null}function Oa(){}function ka(e,t){return null}function Aa(){return Ma(`useSlots`).slots}function ja(){return Ma(`useAttrs`).attrs}function Ma(e){let t=Fs();return t.setupContext||=Zs(t)}function Na(e){return p(e)?e.reduce((e,t)=>(e[t]=null,e),{}):e}function Pa(e,t){let n=Na(e);for(let e in t){if(e.startsWith(`__skip`))continue;let r=n[e];r?p(r)||v(r)?r=n[e]={type:r,default:t[e]}:r.default=t[e]:r===null&&(r=n[e]={default:t[e]}),r&&t[`__skip_${e}`]&&(r.skipFactory=!0)}return n}function Fa(e,t){return!e||!t?e||t:p(e)&&p(t)?e.concat(t):l({},Na(e),Na(t))}function Ia(e,t){let n={};for(let r in e)t.includes(r)||Object.defineProperty(n,r,{enumerable:!0,get:()=>e[r]});return n}function La(e){let t=Fs(),n=Vs,r=e();zs(),n&&Ls(!1);let i=()=>{Rs(t),n&&Ls(!0)},a=()=>{Fs()!==t&&t.scope.off(),zs(),n&&Ls(!1)};return S(r)&&(r=r.catch(e=>{throw i(),Promise.resolve().then(()=>Promise.resolve().then(a)),e})),[r,()=>{i(),Promise.resolve().then(a)}]}var Ra=!0;function za(e){let t=Ua(e),n=e.proxy,r=e.ctx;Ra=!1,t.beforeCreate&&Va(t.beforeCreate,e,`bc`);let{data:i,computed:o,methods:s,watch:c,provide:l,inject:u,created:d,beforeMount:f,mounted:m,beforeUpdate:h,updated:g,activated:_,deactivated:y,beforeDestroy:b,beforeUnmount:S,destroyed:C,unmounted:w,render:ee,renderTracked:te,renderTriggered:T,errorCaptured:ne,serverPrefetch:re,expose:ie,inheritAttrs:E,components:ae,directives:oe,filters:se}=t;if(u&&Ba(u,r,null),s)for(let e in s){let t=s[e];v(t)&&(r[e]=t.bind(n))}if(i){let t=i.call(n,n);x(t)&&(e.data=Zt(t))}if(Ra=!0,o)for(let e in o){let t=o[e],i=W({get:v(t)?t.bind(n,n):v(t.get)?t.get.bind(n,n):a,set:!v(t)&&v(t.set)?t.set.bind(n):a});Object.defineProperty(r,e,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e})}if(c)for(let e in c)Ha(c[e],r,n,e);if(l){let e=v(l)?l.call(n):l;Reflect.ownKeys(e).forEach(t=>{vr(t,e[t])})}d&&Va(d,e,`c`);function ce(e,t){p(t)?t.forEach(t=>e(t.bind(n))):t&&e(t.bind(n))}if(ce(Xi,f),ce(Zi,m),ce(Qi,h),ce($i,g),ce(Hi,_),ce(Ui,y),ce(aa,ne),ce(ia,te),ce(ra,T),ce(ea,S),ce(ta,w),ce(na,re),p(ie)){if(ie.length){let t=e.exposed||={};ie.forEach(e=>{Object.defineProperty(t,e,{get:()=>n[e],set:t=>n[e]=t,enumerable:!0})})}else e.exposed||={}}ee&&e.render===a&&(e.render=ee),E!=null&&(e.inheritAttrs=E),ae&&(e.components=ae),oe&&(e.directives=oe),re&&oi(e)}function Ba(e,t,n=a){p(e)&&(e=Ja(e));for(let n in e){let r=e[n],i;i=x(r)?`default`in r?yr(r.from||n,r.default,!0):yr(r.from||n):yr(r),j(i)?Object.defineProperty(t,n,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e}):t[n]=i}}function Va(e,t,n){Hn(p(e)?e.map(e=>e.bind(t.proxy)):e.bind(t.proxy),t,n)}function Ha(e,t,n,r){let i=r.includes(`.`)?kr(n,r):()=>n[r];if(y(e)){let n=t[e];v(n)&&Er(i,n)}else if(v(e))Er(i,e.bind(n));else if(x(e)){if(p(e))e.forEach(e=>Ha(e,t,n,r));else{let r=v(e.handler)?e.handler.bind(n):t[e.handler];v(r)&&Er(i,r,e)}}}function Ua(e){let t=e.type,{mixins:n,extends:r}=t,{mixins:i,optionsCache:a,config:{optionMergeStrategies:o}}=e.appContext,s=a.get(t),c;return s?c=s:!i.length&&!n&&!r?c=t:(c={},i.length&&i.forEach(e=>Wa(c,e,o,!0)),Wa(c,t,o)),x(t)&&a.set(t,c),c}function Wa(e,t,n,r=!1){let{mixins:i,extends:a}=t;a&&Wa(e,a,n,!0),i&&i.forEach(t=>Wa(e,t,n,!0));for(let i in t)if(!(r&&i===`expose`)){let r=Ga[i]||n&&n[i];e[i]=r?r(e[i],t[i]):t[i]}return e}var Ga={data:Ka,props:Za,emits:Za,methods:Xa,computed:Xa,beforeCreate:Ya,created:Ya,beforeMount:Ya,mounted:Ya,beforeUpdate:Ya,updated:Ya,beforeDestroy:Ya,beforeUnmount:Ya,destroyed:Ya,unmounted:Ya,activated:Ya,deactivated:Ya,errorCaptured:Ya,serverPrefetch:Ya,components:Xa,directives:Xa,watch:Qa,provide:Ka,inject:qa};function Ka(e,t){return t?e?function(){return l(v(e)?e.call(this,this):e,v(t)?t.call(this,this):t)}:t:e}function qa(e,t){return Xa(Ja(e),Ja(t))}function Ja(e){if(p(e)){let t={};for(let n=0;n<e.length;n++)t[e[n]]=e[n];return t}return e}function Ya(e,t){return e?[...new Set([].concat(e,t))]:t}function Xa(e,t){return e?l(Object.create(null),e,t):t}function Za(e,t){return e?p(e)&&p(t)?[...new Set([...e,...t])]:l(Object.create(null),Na(e),Na(t??{})):t}function Qa(e,t){if(!e)return t;if(!t)return e;let n=l(Object.create(null),e);for(let r in t)n[r]=Ya(e[r],t[r]);return n}function $a(){return{app:null,config:{isNativeTag:o,performance:!1,globalProperties:{},optionMergeStrategies:{},errorHandler:void 0,warnHandler:void 0,compilerOptions:{}},mixins:[],components:{},directives:{},provides:Object.create(null),optionsCache:new WeakMap,propsCache:new WeakMap,emitsCache:new WeakMap}}var eo=0;function to(e,t){return function(n,r=null){v(n)||(n=l({},n)),r!=null&&!x(r)&&(r=null);let i=$a(),a=new WeakSet,o=[],s=!1,c=i.app={_uid:eo++,_component:n,_props:r,_container:null,_context:i,_instance:null,version:ic,get config(){return i.config},set config(e){},use(e,...t){return a.has(e)||(e&&v(e.install)?(a.add(e),e.install(c,...t)):v(e)&&(a.add(e),e(c,...t))),c},mixin(e){return i.mixins.includes(e)||i.mixins.push(e),c},component(e,t){return t?(i.components[e]=t,c):i.components[e]},directive(e,t){return t?(i.directives[e]=t,c):i.directives[e]},mount(a,o,l){if(!s){let u=c._ceVNode||H(n,r);return u.appContext=i,l===!0?l=`svg`:l===!1&&(l=void 0),o&&t?t(u,a):e(u,a,l),s=!0,c._container=a,a.__vue_app__=c,Qs(u.component)}},onUnmount(e){o.push(e)},unmount(){s&&(Hn(o,c._instance,16),e(null,c._container),delete c._container.__vue_app__)},provide(e,t){return i.provides[e]=t,c},runWithContext(e){let t=no;no=c;try{return e()}finally{no=t}}};return c}}var no=null;function ro(e,t,n=r){let i=Fs(),a=E(t),o=oe(t),s=io(e,a),c=vn((s,c)=>{let l,u=r,d;return Tr(()=>{let t=e[a];D(l,t)&&(l=t,c())}),{get(){return s(),n.get?n.get(l):l},set(e){let s=n.set?n.set(e):e;if(!D(s,l)&&!(u!==r&&D(e,u)))return;let f=i.vnode.props,p=!!(f&&(t in f||a in f||o in f)&&(`onUpdate:${t}`in f||`onUpdate:${a}`in f||`onUpdate:${o}`in f));p||(l=e,c()),i.emit(`update:${t}`,s),D(e,u)&&(D(e,s)&&!D(s,d)||p&&u!==r&&!D(s,l))&&c(),u=e,d=s}}});return c[Symbol.iterator]=()=>{let e=0;return{next(){return e<2?{value:e++?s||r:c,done:!1}:{done:!0}}}},c}var io=(e,t)=>t===`modelValue`||t===`model-value`?e.modelModifiers:e[`${t}Modifiers`]||e[`${E(t)}Modifiers`]||e[`${oe(t)}Modifiers`];function ao(e,t,...n){if(e.isUnmounted)return;let i=e.vnode.props||r,a=n,o=t.startsWith(`update:`),s=o&&io(i,t.slice(7));s&&(s.trim&&(a=n.map(e=>y(e)?e.trim():e)),s.number&&(a=n.map(de)));let c,l=i[c=ce(t)]||i[c=ce(E(t))];!l&&o&&(l=i[c=ce(oe(t))]),l&&Hn(l,e,6,a);let u=i[c+`Once`];if(u){if(!e.emitted)e.emitted={};else if(e.emitted[c])return;e.emitted[c]=!0,Hn(u,e,6,a)}}var oo=new WeakMap;function so(e,t,n=!1){let r=n?oo:t.emitsCache,i=r.get(e);if(i!==void 0)return i;let a=e.emits,o={},s=!1;if(!v(e)){let r=e=>{let n=so(e,t,!0);n&&(s=!0,l(o,n))};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}return!a&&!s?(x(e)&&r.set(e,null),null):(p(a)?a.forEach(e=>o[e]=null):l(o,a),x(e)&&r.set(e,o),o)}function co(e,t){return!e||!s(t)?!1:(t=t.slice(2),t=t===`Once`?t:t.replace(/Once$/,``),f(e,t[0].toLowerCase()+t.slice(1))||f(e,oe(t))||f(e,t))}function lo(e){let{type:t,vnode:n,proxy:r,withProxy:i,propsOptions:[a],slots:o,attrs:s,emit:l,render:u,renderCache:d,props:f,data:p,setupState:m,ctx:h,inheritAttrs:g}=e,_=fr(e),v,y;try{if(n.shapeFlag&4){let e=i||r,t=e;v=Es(u.call(t,e,d,f,m,p,h)),y=s}else{let e=t;v=Es(e.length>1?e(f,{attrs:s,slots:o,emit:l}):e(f,null)),y=t.props?s:fo(s)}}catch(t){us.length=0,Un(t,e,1),v=H(cs)}let b=v;if(y&&g!==!1){let e=Object.keys(y),{shapeFlag:t}=b;e.length&&t&7&&(a&&e.some(c)&&(y=po(y,a)),b=Cs(b,y,!1,!0))}return n.dirs&&(b=Cs(b,null,!1,!0),b.dirs=b.dirs?b.dirs.concat(n.dirs):n.dirs),n.transition&&ri(Mr(b.type)&&ni(b)||b,n.transition),v=b,fr(_),v}function uo(e,t=!0){let n;for(let t=0;t<e.length;t++){let r=e[t];if(gs(r)){if(r.type!==cs||r.children===`v-if`){if(n)return;n=r}}else return}return n}var fo=e=>{let t;for(let n in e)(n===`class`||n===`style`||s(n))&&((t||={})[n]=e[n]);return t},po=(e,t)=>{let n={};for(let r in e)(!c(r)||!(r.slice(9)in t))&&(n[r]=e[r]);return n};function mo(e,t,n){let{props:r,children:i,component:a}=e,{props:o,children:s,patchFlag:c}=t,l=a.emitsOptions;if(t.dirs||t.transition)return!0;if(n&&c>=0){if(c&1024)return!0;if(c&16)return r?ho(r,o,l):!!o;if(c&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let n=e[t];if(go(o,r,n)&&!co(l,n))return!0}}}else return(i||s)&&(!s||!s.$stable)?!0:r===o?!1:r?!o||ho(r,o,l):!!o;return!1}function ho(e,t,n){let r=Object.keys(t);if(r.length!==Object.keys(e).length)return!0;for(let i=0;i<r.length;i++){let a=r[i];if(go(t,e,a)&&!co(n,a))return!0}return!1}function go(e,t,n){let r=e[n],i=t[n];return n===`style`&&x(r)&&x(i)?!Ee(r,i):r!==i}function _o({vnode:e,parent:t,suspense:n},r){for(;t;){let n=t.subTree;if(n.suspense&&n.suspense.activeBranch===e&&(n.suspense.vnode.el=n.el=r,e=n),n===e)(e=t.vnode).el=r,t=t.parent;else break}n&&n.activeBranch===e&&(n.vnode.el=r)}var vo={},yo=()=>Object.create(vo),bo=e=>Object.getPrototypeOf(e)===vo;function xo(e,t,n,r=!1){let i={},a=yo();e.propsDefaults=Object.create(null),Co(e,t,i,a);for(let t in e.propsOptions[0])t in i||(i[t]=void 0);e.props=n?r?i:Qt(i):e.type.props?i:a,e.attrs=a}function So(e,t,n,r){let{props:i,attrs:a,vnode:{patchFlag:o}}=e,s=A(i),[c]=e.propsOptions,l=!1;if((r||o>0)&&!(o&16)){if(o&8){let n=e.vnode.dynamicProps;for(let r=0;r<n.length;r++){let o=n[r];if(co(e.emitsOptions,o))continue;let u=t[o];if(c){if(f(a,o))u!==a[o]&&(a[o]=u,l=!0);else{let t=E(o);i[t]=wo(c,s,t,u,e,!1)}}else u!==a[o]&&(a[o]=u,l=!0)}}}else{Co(e,t,i,a)&&(l=!0);let r;for(let a in s)(!t||!f(t,a)&&((r=oe(a))===a||!f(t,r)))&&(c?n&&(n[a]!==void 0||n[r]!==void 0)&&(i[a]=wo(c,s,a,void 0,e,!0)):delete i[a]);if(a!==s)for(let e in a)(!t||!f(t,e))&&(delete a[e],l=!0)}l&&mt(e.attrs,`set`,``)}function Co(e,t,n,i){let[a,o]=e.propsOptions,s=!1,c;if(t)for(let r in t){if(ne(r))continue;let l=t[r],u;a&&f(a,u=E(r))?!o||!o.includes(u)?n[u]=l:(c||={})[u]=l:co(e.emitsOptions,r)||(!(r in i)||l!==i[r])&&(i[r]=l,s=!0)}if(o){let t=A(n),i=c||r;for(let r=0;r<o.length;r++){let s=o[r];n[s]=wo(a,t,s,i[s],e,!f(i,s))}}return s}function wo(e,t,n,r,i,a){let o=e[n];if(o!=null){let e=f(o,`default`);if(e&&r===void 0){let e=o.default;if(o.type!==Function&&!o.skipFactory&&v(e)){let{propsDefaults:a}=i;if(n in a)r=a[n];else{let o=Rs(i);r=a[n]=e.call(null,t),o()}}else r=e;i.ce&&i.ce._setProp(n,r)}o[0]&&(a&&!e?r=!1:o[1]&&(r===``||r===oe(n))&&(r=!0))}return r}var To=new WeakMap;function Eo(e,t,n=!1){let a=n?To:t.propsCache,o=a.get(e);if(o)return o;let s=e.props,c={},u=[],d=!1;if(!v(e)){let r=e=>{d=!0;let[n,r]=Eo(e,t,!0);l(c,n),r&&u.push(...r)};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}if(!s&&!d)return x(e)&&a.set(e,i),i;if(p(s))for(let e=0;e<s.length;e++){let t=E(s[e]);Do(t)&&(c[t]=r)}else if(s)for(let e in s){let t=E(e);if(Do(t)){let n=s[e],r=c[t]=p(n)||v(n)?{type:n}:l({},n),i=r.type,a=!1,o=!0;if(p(i))for(let e=0;e<i.length;++e){let t=i[e],n=v(t)&&t.name;if(n===`Boolean`){a=!0;break}n===`String`&&(o=!1)}else a=v(i)&&i.name===`Boolean`;r[0]=a,r[1]=o,(a||f(r,`default`))&&u.push(t)}}let m=[c,u];return x(e)&&a.set(e,m),m}function Do(e){return e[0]!==`$`&&!ne(e)}var Oo=e=>e===`_`||e===`_ctx`||e===`$stable`,ko=e=>p(e)?e.map(Es):[Es(e)],Ao=(e,t,n)=>{if(t._n)return t;let r=P((...e)=>ko(t(...e)),n);return r._c=!1,r},jo=(e,t,n)=>{let r=e._ctx;for(let n in e){if(Oo(n))continue;let i=e[n];if(v(i))t[n]=Ao(n,i,r);else if(i!=null){let e=ko(i);t[n]=()=>e}}},Mo=(e,t)=>{let n=ko(t);e.slots.default=()=>n},No=(e,t,n)=>{for(let r in t)(n||!Oo(r))&&(e[r]=t[r])},Po=(e,t,n)=>{let r=e.slots=yo();if(e.vnode.shapeFlag&32){let e=t._;e?(No(r,t,n),n&&ue(r,`_`,e,!0)):jo(t,r)}else t&&Mo(e,t)},Fo=(e,t,n)=>{let{vnode:i,slots:a}=e,o=!0,s=r;if(i.shapeFlag&32){let e=t._;e?n&&e===1?o=!1:No(a,t,n):(o=!t.$stable,jo(t,a)),s=t}else t&&(Mo(e,t),s={default:1});if(o)for(let e in a)!Oo(e)&&s[e]==null&&delete a[e]},Io=is;function Lo(e){return zo(e)}function Ro(e){return zo(e,vi)}function zo(e,t){let n=me();n.__VUE__=!0;let{insert:o,remove:s,patchProp:c,createElement:l,createText:u,createComment:d,setText:f,setElementText:p,parentNode:m,nextSibling:h,setScopeId:g=a,insertStaticContent:_}=e,v=(e,t,n,r=null,i=null,a=null,o=void 0,s=null,c=!!t.dynamicChildren)=>{if(e===t)return;e&&!_s(e,t)&&(r=O(e),ge(e,i,a,!0),e=null),t.patchFlag===-2&&(c=!1,t.dynamicChildren=null);let{type:l,ref:u,shapeFlag:d}=t;switch(l){case ss:y(e,t,n,r);break;case cs:b(e,t,n,r);break;case ls:e??x(t,n,r,o);break;case L:ae(e,t,n,r,i,a,o,s,c);break;default:d&1?w(e,t,n,r,i,a,o,s,c):d&6?oe(e,t,n,r,i,a,o,s,c):(d&64||d&128)&&l.process(e,t,n,r,i,a,o,s,c,Ce)}u!=null&&i?ui(u,e&&e.ref,a,t||e,!t):u==null&&e&&e.ref!=null&&ui(e.ref,null,a,e,!0)},y=(e,t,n,r)=>{if(e==null)o(t.el=u(t.children),n,r);else{let n=t.el=e.el;t.children!==e.children&&f(n,t.children)}},b=(e,t,n,r)=>{e==null?o(t.el=d(t.children||``),n,r):t.el=e.el},x=(e,t,n,r)=>{[e.el,e.anchor]=_(e.children,t,n,r,e.el,e.anchor)},S=({el:e,anchor:t},n,r)=>{let i;for(;e&&e!==t;)i=h(e),o(e,n,r),e=i;o(t,n,r)},C=({el:e,anchor:t})=>{let n;for(;e&&e!==t;)n=h(e),s(e),e=n;s(t)},w=(e,t,n,r,i,a,o,s,c)=>{if(t.type===`svg`?o=`svg`:t.type===`math`&&(o=`mathml`),e==null)ee(t,n,r,i,a,o,s,c);else{let n=e.el&&e.el._isVueCE?e.el:null;try{n&&n._beginPatch(),re(e,t,i,a,o,s,c)}finally{n&&n._endPatch()}}},ee=(e,t,n,r,i,a,s,u)=>{let d,f,{props:m,shapeFlag:h,transition:g,dirs:_}=e;if(d=e.el=l(e.type,a,m&&m.is,m),h&8?p(d,e.children):h&16&&T(e.children,d,null,r,i,Bo(e,a),s,u),_&&_r(e,null,r,`created`),te(d,e,e.scopeId,s,r),m){for(let e in m)e!==`value`&&!ne(e)&&c(d,e,null,m[e],a,r);`value`in m&&c(d,`value`,null,m.value,a),(f=m.onVnodeBeforeMount)&&As(f,r,e)}_&&_r(e,null,r,`beforeMount`);let v=Ho(i,g);v&&g.beforeEnter(d),o(d,t,n),((f=m&&m.onVnodeMounted)||v||_)&&Io(()=>{try{f&&As(f,r,e),v&&g.enter(d),_&&_r(e,null,r,`mounted`)}finally{}},i)},te=(e,t,n,r,i)=>{if(n&&g(e,n),r)for(let t=0;t<r.length;t++)g(e,r[t]);if(i){let n=i.subTree;if(t===n||Jo(n.type)&&(n.ssContent===t||n.ssFallback===t)){let t=i.vnode;te(e,t,t.scopeId,t.slotScopeIds,i.parent)}}},T=(e,t,n,r,i,a,o,s,c=0)=>{for(let l=c;l<e.length;l++){let c=e[l]=s?Ds(e[l]):Es(e[l]);v(null,c,t,n,r,i,a,o,s)}},re=(e,t,n,i,a,o,s)=>{let l=t.el=e.el,{patchFlag:u,dynamicChildren:d,dirs:f}=t;u|=e.patchFlag&16;let m=e.props||r,h=t.props||r,g;if(n&&Vo(n,!1),(g=h.onVnodeBeforeUpdate)&&As(g,n,t,e),f&&_r(t,e,n,`beforeUpdate`),n&&Vo(n,!0),d&&(!e.dynamicChildren||e.dynamicChildren.length!==d.length)&&(u=0,s=!1,d=null),(m.innerHTML&&h.innerHTML==null||m.textContent&&h.textContent==null)&&p(l,``),d?ie(e.dynamicChildren,d,l,n,i,Bo(t,a),o):s||de(e,t,l,null,n,i,Bo(t,a),o,!1),u>0){if(u&16)E(l,m,h,n,a);else if(u&2&&m.class!==h.class&&c(l,`class`,null,h.class,a),u&4&&c(l,`style`,m.style,h.style,a),u&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let r=e[t],i=m[r],o=h[r];(o!==i||r===`value`)&&c(l,r,i,o,a,n)}}u&1&&e.children!==t.children&&p(l,t.children)}else!s&&d==null&&E(l,m,h,n,a);((g=h.onVnodeUpdated)||f)&&Io(()=>{g&&As(g,n,t,e),f&&_r(t,e,n,`updated`)},i)},ie=(e,t,n,r,i,a,o)=>{for(let s=0;s<t.length;s++){let c=e[s],l=t[s],u=c.el&&(c.type===L||!_s(c,l)||c.shapeFlag&198)?m(c.el):n;v(c,l,u,null,r,i,a,o,!0)}},E=(e,t,n,i,a)=>{if(t!==n){if(t!==r)for(let r in t)!ne(r)&&!(r in n)&&c(e,r,t[r],null,a,i);for(let r in n){if(ne(r))continue;let o=n[r],s=t[r];o!==s&&r!==`value`&&c(e,r,s,o,a,i)}`value`in n&&c(e,`value`,t.value,n.value,a)}},ae=(e,t,n,r,i,a,s,c,l)=>{let d=t.el=e?e.el:u(``),f=t.anchor=e?e.anchor:u(``),{patchFlag:p,dynamicChildren:m,slotScopeIds:h}=t;h&&(c=c?c.concat(h):h),e==null?(o(d,n,r),o(f,n,r),T(t.children||[],n,f,i,a,s,c,l)):p>0&&p&64&&m&&e.dynamicChildren&&e.dynamicChildren.length===m.length?(ie(e.dynamicChildren,m,n,i,a,s,c),(t.key!=null||i&&t===i.subTree)&&Uo(e,t,!0)):de(e,t,n,f,i,a,s,c,l)},oe=(e,t,n,r,i,a,o,s,c)=>{t.slotScopeIds=s,e==null?t.shapeFlag&512?i.ctx.activate(t,n,r,o,c):se(t,n,r,i,a,o,c):ce(e,t,c)},se=(e,t,n,r,i,a,o)=>{let s=e.component=Ns(e,r,i);if(zi(e)&&(s.ctx.renderer=Ce),Hs(s,!1,o),s.asyncDep){if(i&&i.registerDep(s,D,o),!e.el){let r=s.subTree=H(cs);b(null,r,t,n),e.placeholder=r.el}}else D(s,e,t,n,i,a,o)},ce=(e,t,n)=>{let r=t.component=e.component;if(mo(e,t,n)){if(r.asyncDep&&!r.asyncResolved){ue(r,t,n);return}r.next=t,r.update()}else t.el=e.el,r.vnode=t},D=(e,t,n,r,i,a,o)=>{let s=()=>{if(e.isMounted){let{next:t,bu:n,u:r,parent:s,vnode:c}=e;{let n=Go(e);if(n){t&&(t.el=c.el,ue(e,t,o)),n.asyncDep.then(()=>{Io(()=>{e.isUnmounted||l()},i)});return}}let u=t,d;Vo(e,!1),t?(t.el=c.el,ue(e,t,o)):t=c,n&&le(n),(d=t.props&&t.props.onVnodeBeforeUpdate)&&As(d,s,t,c),Vo(e,!0);let f=lo(e),p=e.subTree;e.subTree=f,v(p,f,m(p.el),O(p),e,i,a),t.el=f.el,u===null&&_o(e,f.el),r&&Io(r,i),(d=t.props&&t.props.onVnodeUpdated)&&Io(()=>As(d,s,t,c),i)}else{let o,{el:s,props:c}=t,{bm:l,m:u,parent:d,root:f,type:p}=e,m=Ii(t);if(Vo(e,!1),l&&le(l),!m&&(o=c&&c.onVnodeBeforeMount)&&As(o,d,t),Vo(e,!0),s&&Te){let t=()=>{e.subTree=lo(e),Te(s,e.subTree,e,i,null)};m&&p.__asyncHydrate?p.__asyncHydrate(s,e,t):t()}else{f.ce&&f.ce._hasShadowRoot()&&f.ce._injectChildStyle(p,e.parent?e.parent.type:void 0);let o=e.subTree=lo(e);v(null,o,n,r,e,i,a),t.el=o.el}if(u&&Io(u,i),!m&&(o=c&&c.onVnodeMounted)){let e=t;Io(()=>As(o,d,e),i)}(t.shapeFlag&256||d&&Ii(d.vnode)&&d.vnode.shapeFlag&256)&&e.a&&Io(e.a,i),e.isMounted=!0,t=n=r=null}};e.scope.on();let c=e.effect=new ze(s);e.scope.off();let l=e.update=c.run.bind(c),u=e.job=c.runIfDirty.bind(c);u.i=e,u.id=e.uid,c.scheduler=()=>er(u),Vo(e,!0),l()},ue=(e,t,n)=>{t.component=e;let r=e.vnode.props;e.vnode=t,e.next=null,So(e,t.props,r,n),Fo(e,t.children,n),nt(),rr(e),rt()},de=(e,t,n,r,i,a,o,s,c=!1)=>{let l=e&&e.children,u=e?e.shapeFlag:0,d=t.children,{patchFlag:f,shapeFlag:m}=t;if(f>0){if(f&128){pe(l,d,n,r,i,a,o,s,c);return}if(f&256){fe(l,d,n,r,i,a,o,s,c);return}}m&8?(u&16&&be(l,i,a),d!==l&&p(n,d)):u&16?m&16?pe(l,d,n,r,i,a,o,s,c):be(l,i,a,!0):(u&8&&p(n,``),m&16&&T(d,n,r,i,a,o,s,c))},fe=(e,t,n,r,a,o,s,c,l)=>{e||=i,t||=i;let u=e.length,d=t.length,f=Math.min(u,d),p;for(p=0;p<f;p++){let r=t[p]=l?Ds(t[p]):Es(t[p]);v(e[p],r,n,null,a,o,s,c,l)}u>d?be(e,a,o,!0,!1,f):T(t,n,r,a,o,s,c,l,f)},pe=(e,t,n,r,a,o,s,c,l)=>{let u=0,d=t.length,f=e.length-1,p=d-1;for(;u<=f&&u<=p;){let r=e[u],i=t[u]=l?Ds(t[u]):Es(t[u]);if(_s(r,i))v(r,i,n,null,a,o,s,c,l);else break;u++}for(;u<=f&&u<=p;){let r=e[f],i=t[p]=l?Ds(t[p]):Es(t[p]);if(_s(r,i))v(r,i,n,null,a,o,s,c,l);else break;f--,p--}if(u>f){if(u<=p){let e=p+1,i=e<d?t[e].el:r;for(;u<=p;)v(null,t[u]=l?Ds(t[u]):Es(t[u]),n,i,a,o,s,c,l),u++}}else if(u>p)for(;u<=f;)ge(e[u],a,o,!0),u++;else{let m=u,h=u,g=new Map;for(u=h;u<=p;u++){let e=t[u]=l?Ds(t[u]):Es(t[u]);e.key!=null&&g.set(e.key,u)}let _,y=0,b=p-h+1,x=!1,S=0,C=Array(b);for(u=0;u<b;u++)C[u]=0;for(u=m;u<=f;u++){let r=e[u];if(y>=b){ge(r,a,o,!0);continue}let i;if(r.key!=null)i=g.get(r.key);else for(_=h;_<=p;_++)if(C[_-h]===0&&_s(r,t[_])){i=_;break}i===void 0?ge(r,a,o,!0):(C[i-h]=u+1,i>=S?S=i:x=!0,v(r,t[i],n,null,a,o,s,c,l),y++)}let w=x?Wo(C):i;for(_=w.length-1,u=b-1;u>=0;u--){let e=h+u,i=t[e],f=t[e+1],p=e+1<d?f.el||qo(f):r;C[u]===0?v(null,i,n,p,a,o,s,c,l):x&&(_<0||u!==w[_]?he(i,n,p,2):_--)}}},he=(e,t,n,r,i=null)=>{let{el:a,type:c,transition:l,children:u,shapeFlag:d}=e;if(d&6){he(e.component.subTree,t,n,r);return}if(d&128){e.suspense.move(t,n,r);return}if(d&64){c.move(e,t,n,Ce);return}if(c===L){o(a,t,n);for(let e=0;e<u.length;e++)he(u[e],t,n,r);o(e.anchor,t,n);return}if(c===ls){S(e,t,n);return}if(r!==2&&d&1&&l){if(r===0)l.persisted&&!a[Wr]?o(a,t,n):(l.beforeEnter(a),o(a,t,n),Io(()=>l.enter(a),i));else{let{leave:r,delayLeave:i,afterLeave:c}=l,u=()=>{e.ctx.isUnmounted?s(a):o(a,t,n)},d=()=>{let e=a._isLeaving||!!a[Wr];a._isLeaving&&a[Wr](!0),l.persisted&&!e?u():r(a,()=>{u(),c&&c()})};i?i(a,u,d):d()}}else o(a,t,n)},ge=(e,t,n,r=!1,i=!1)=>{let{type:a,props:o,ref:s,children:c,dynamicChildren:l,shapeFlag:u,patchFlag:d,dirs:f,cacheIndex:p,memo:m}=e;if(d===-2&&(i=!1),s!=null&&(nt(),ui(s,null,n,e,!0),rt()),p!=null&&(t.renderCache[p]=void 0),u&256){t.ctx.deactivate(e);return}let h=u&1&&f,g=!Ii(e),_;if(g&&(_=o&&o.onVnodeBeforeUnmount)&&As(_,t,e),u&6)ye(e.component,n,r);else{if(u&128){e.suspense.unmount(n,r);return}h&&_r(e,null,t,`beforeUnmount`),u&64?e.type.remove(e,t,n,Ce,r):l&&!l.hasOnce&&(a!==L||d>0&&d&64)?be(l,t,n,!1,!0):(a===L&&d&384||!i&&u&16)&&be(c,t,n),r&&_e(e)}let v=m!=null&&p==null;(g&&(_=o&&o.onVnodeUnmounted)||h||v)&&Io(()=>{_&&As(_,t,e),h&&_r(e,null,t,`unmounted`),v&&(e.el=null)},n)},_e=e=>{let{type:t,el:n,anchor:r,transition:i}=e;if(t===L){ve(n,r);return}if(t===ls){C(e);return}let a=()=>{s(n),i&&!i.persisted&&i.afterLeave&&i.afterLeave()};if(e.shapeFlag&1&&i&&!i.persisted){let{leave:t,delayLeave:r}=i,o=()=>t(n,a);r?r(e.el,a,o):o()}else a()},ve=(e,t)=>{let n;for(;e!==t;)n=h(e),s(e),e=n;s(t)},ye=(e,t,n)=>{let{bum:r,scope:i,job:a,subTree:o,um:s,m:c,a:l}=e;Ko(c),Ko(l),r&&le(r),i.stop(),a&&(a.flags|=8,ge(o,e,t,n)),s&&Io(s,t),Io(()=>{e.isUnmounted=!0},t)},be=(e,t,n,r=!1,i=!1,a=0)=>{for(let o=a;o<e.length;o++)ge(e[o],t,n,r,i)},O=e=>{if(e.shapeFlag&6)return O(e.component.subTree);if(e.shapeFlag&128)return e.suspense.next();let t=h(e.anchor||e.el),n=t&&t[jr];return n?h(n):t},xe=!1,Se=(e,t,n)=>{let r;e==null?t._vnode&&(ge(t._vnode,null,null,!0),r=t._vnode.component):v(t._vnode||null,e,t,null,null,null,n),t._vnode=e,xe||=(xe=!0,rr(r),ir(),!1)},Ce={p:v,um:ge,m:he,r:_e,mt:se,mc:T,pc:de,pbc:ie,n:O,o:e},we,Te;return t&&([we,Te]=t(Ce)),{render:Se,hydrate:we,createApp:to(Se,we)}}function Bo({type:e,props:t},n){return n===`svg`&&e===`foreignObject`||n===`mathml`&&e===`annotation-xml`&&t&&t.encoding&&t.encoding.includes(`html`)?void 0:n}function Vo({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function Ho(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function Uo(e,t,n=!1){let r=e.children,i=t.children;if(p(r)&&p(i))for(let e=0;e<r.length;e++){let t=r[e],a=i[e];a.shapeFlag&1&&!a.dynamicChildren&&((a.patchFlag<=0||a.patchFlag===32)&&(a=i[e]=Ds(i[e]),a.el=t.el),!n&&a.patchFlag!==-2&&Uo(t,a)),a.type===ss&&(a.patchFlag===-1&&(a=i[e]=Ds(a)),a.el=t.el),a.type===cs&&!a.el&&(a.el=t.el)}}function Wo(e){let t=e.slice(),n=[0],r,i,a,o,s,c=e.length;for(r=0;r<c;r++){let c=e[r];if(c!==0){if(i=n[n.length-1],e[i]<c){t[r]=i,n.push(r);continue}for(a=0,o=n.length-1;a<o;)s=a+o>>1,e[n[s]]<c?a=s+1:o=s;c<e[n[a]]&&(a>0&&(t[r]=n[a-1]),n[a]=r)}}for(a=n.length,o=n[a-1];a-->0;)n[a]=o,o=t[o];return n}function Go(e){let t=e.subTree.component;if(t)return t.asyncDep&&!t.asyncResolved?t:Go(t)}function Ko(e){if(e)for(let t=0;t<e.length;t++)e[t].flags|=8}function qo(e){if(e.placeholder)return e.placeholder;let t=e.component;return t?qo(t.subTree):null}var Jo=e=>e.__isSuspense,Yo=0,Xo={name:`Suspense`,__isSuspense:!0,process(e,t,n,r,i,a,o,s,c,l){if(e==null)Qo(t,n,r,i,a,o,s,c,l);else{if(a&&a.deps>0&&!e.suspense.isInFallback){t.suspense=e.suspense,t.suspense.vnode=t,t.el=e.el;return}$o(e,t,n,r,i,o,s,c,l)}},hydrate:ts,normalize:ns};function Zo(e,t){let n=e.props&&e.props[t];v(n)&&n()}function Qo(e,t,n,r,i,a,o,s,c){let{p:l,o:{createElement:u}}=c,d=u(`div`),f=e.suspense=es(e,i,r,t,d,n,a,o,s,c);l(null,f.pendingBranch=e.ssContent,d,null,r,f,a,o),f.deps>0?(Zo(e,`onPending`),Zo(e,`onFallback`),l(null,e.ssFallback,t,n,r,null,a,o),as(f,e.ssFallback)):f.resolve(!1,!0)}function $o(e,t,n,r,i,a,o,s,{p:c,um:l,o:{createElement:u}}){let d=t.suspense=e.suspense;d.vnode=t,t.el=e.el;let f=t.ssContent,p=t.ssFallback,{activeBranch:m,pendingBranch:h,isInFallback:g,isHydrating:_}=d;if(h)d.pendingBranch=f,_s(h,f)?(c(h,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0?d.resolve():g&&(_||(c(m,p,n,r,i,null,a,o,s),as(d,p)))):(d.pendingId=Yo++,_?(d.isHydrating=!1,d.activeBranch=h):l(h,i,d),d.deps=0,d.effects.length=0,d.hiddenContainer=u(`div`),g?(c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0?d.resolve():(c(m,p,n,r,i,null,a,o,s),as(d,p))):m&&_s(m,f)?(c(m,f,n,r,i,d,a,o,s),d.resolve(!0)):(c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0&&d.resolve()));else if(m&&_s(m,f))c(m,f,n,r,i,d,a,o,s),as(d,f);else if(Zo(t,`onPending`),d.pendingBranch=f,d.pendingId=f.shapeFlag&512?f.component.suspenseId:Yo++,c(null,f,d.hiddenContainer,null,i,d,a,o,s),d.deps<=0)d.resolve();else{let{timeout:e,pendingId:t}=d;e>0?setTimeout(()=>{d.pendingId===t&&d.fallback(p)},e):e===0&&d.fallback(p)}}function es(e,t,n,r,i,a,o,s,c,l,u=!1){let{p:d,m:f,um:p,n:m,o:{parentNode:h,remove:g}}=l,_,v=os(e);v&&t&&t.pendingBranch&&(_=t.pendingId,t.deps++);let y=e.props?fe(e.props.timeout):void 0,b=a,x={vnode:e,parent:t,parentComponent:n,namespace:o,container:r,hiddenContainer:i,deps:0,pendingId:Yo++,timeout:typeof y==`number`?y:-1,activeBranch:null,isFallbackMountPending:!1,pendingBranch:null,isInFallback:!u,isHydrating:u,isUnmounted:!1,effects:[],resolve(e=!1,n=!1){let{vnode:r,activeBranch:i,pendingBranch:o,pendingId:s,effects:c,parentComponent:l,container:u,isInFallback:d}=x,g=!1;if(x.isHydrating)x.isHydrating=!1;else if(!e){g=i&&o.transition&&o.transition.mode===`out-in`;let e=!1;g&&(i.transition.afterLeave=()=>{s===x.pendingId&&(f(o,u,a===b&&!e?m(i):a,0),nr(c),d&&r.ssFallback&&(r.ssFallback.el=null))}),i&&!x.isFallbackMountPending&&(h(i.el)===u&&(a=m(i),e=!0),p(i,l,x,!0),!g&&d&&r.ssFallback&&Io(()=>r.ssFallback.el=null,x)),g||f(o,u,a,0)}x.isFallbackMountPending=!1,as(x,o),x.pendingBranch=null,x.isInFallback=!1;let y=x.parent,S=!1;for(;y;){if(y.pendingBranch){for(let e=0;e<c.length;e++)y.effects.push(c[e]);S=!0;break}y=y.parent}!S&&!g&&nr(c),x.effects=[],v&&t&&t.pendingBranch&&_===t.pendingId&&(t.deps--,t.deps===0&&!n&&t.resolve()),Zo(r,`onResolve`)},fallback(e){if(!x.pendingBranch)return;let{vnode:t,activeBranch:n,parentComponent:r,container:i,namespace:a}=x;Zo(t,`onFallback`);let o=m(n),l=()=>{x.isFallbackMountPending=!1,x.isInFallback&&(d(null,e,i,o,r,null,a,s,c),as(x,e))},u=e.transition&&e.transition.mode===`out-in`;u&&(x.isFallbackMountPending=!0,n.transition.afterLeave=l),x.isInFallback=!0,p(n,r,null,!0),u||l()},move(e,t,n){x.activeBranch&&f(x.activeBranch,e,t,n),x.container=e},next(){return x.activeBranch&&m(x.activeBranch)},registerDep(e,t,n){let r=!!x.pendingBranch;r&&x.deps++;let i=e.vnode.el;e.asyncDep.catch(t=>{Un(t,e,0)}).then(a=>{if(e.isUnmounted||x.isUnmounted||x.pendingId!==e.suspenseId)return;zs(),e.asyncResolved=!0;let{vnode:s}=e;Ws(e,a,!1),i&&(s.el=i);let c=!i&&e.subTree.el;t(e,s,h(i||e.subTree.el),i?null:m(e.subTree),x,o,n),c&&(s.placeholder=null,g(c)),_o(e,s.el),r&&--x.deps===0&&x.resolve()})},unmount(e,t){x.isUnmounted=!0,x.activeBranch&&p(x.activeBranch,n,e,t),x.pendingBranch&&p(x.pendingBranch,n,e,t)}};return x}function ts(e,t,n,r,i,a,o,s,c){let l=t.suspense=es(t,r,n,e.parentNode,document.createElement(`div`),null,i,a,o,s,!0),u=c(e,l.pendingBranch=t.ssContent,n,l,a,o);return l.deps===0&&l.resolve(!1,!0),u}function ns(e){let{shapeFlag:t,children:n}=e,r=t&32;e.ssContent=rs(r?n.default:n),e.ssFallback=r?rs(n.fallback):H(cs)}function rs(e){let t;if(v(e)){let n=ps&&e._c;n&&(e._d=!1,R()),e=e(),n&&(e._d=!0,t=ds,fs())}return p(e)&&(e=uo(e)),e=Es(e),t&&!e.dynamicChildren&&(e.dynamicChildren=t.filter(t=>t!==e)),e}function is(e,t){t&&t.pendingBranch?p(e)?t.effects.push(...e):t.effects.push(e):nr(e)}function as(e,t){e.activeBranch=t;let{vnode:n,parentComponent:r}=e,i=t.el;for(;!i&&t.component;)t=t.component.subTree,i=t.el;n.el=i,r&&r.subTree===n&&(r.vnode.el=i,_o(r,i))}function os(e){let t=e.props&&e.props.suspensible;return t!=null&&t!==!1}var L=Symbol.for(`v-fgt`),ss=Symbol.for(`v-txt`),cs=Symbol.for(`v-cmt`),ls=Symbol.for(`v-stc`),us=[],ds=null;function R(e=!1){us.push(ds=e?null:[])}function fs(){us.pop(),ds=us[us.length-1]||null}var ps=1;function ms(e,t=!1){ps+=e,e<0&&ds&&t&&(ds.hasOnce=!0)}function hs(e){return e.dynamicChildren=ps>0?ds||i:null,fs(),ps>0&&ds&&ds.push(e),e}function z(e,t,n,r,i,a){return hs(V(e,t,n,r,i,a,!0))}function B(e,t,n,r,i){return hs(H(e,t,n,r,i,!0))}function gs(e){return e?e.__v_isVNode===!0:!1}function _s(e,t){return e.type===t.type&&e.key===t.key}function vs(e){}var ys=({key:e})=>e??null,bs=({ref:e,ref_key:t,ref_for:n})=>(typeof e==`number`&&(e=``+e),e==null?null:y(e)||j(e)||v(e)?{i:ur,r:e,k:t,f:!!n}:e);function V(e,t=null,n=null,r=0,i=null,a=e===L?0:1,o=!1,s=!1){let c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&ys(t),ref:t&&bs(t),scopeId:dr,slotScopeIds:null,children:n,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetStart:null,targetAnchor:null,staticCount:0,shapeFlag:a,patchFlag:r,dynamicProps:i,dynamicChildren:null,appContext:null,ctx:ur};return s?(Os(c,n),a&128&&e.normalize(c)):n&&(c.shapeFlag|=y(n)?8:16),ps>0&&!o&&ds&&(c.patchFlag>0||a&6)&&c.patchFlag!==32&&ds.push(c),c}var H=xs;function xs(e,t=null,n=null,r=0,i=null,a=!1){if((!e||e===la)&&(e=cs),gs(e)){let r=Cs(e,t,!0);return n&&Os(r,n),ps>0&&!a&&ds&&(r.shapeFlag&6?ds[ds.indexOf(e)]=r:ds.push(r)),r.patchFlag=-2,r}if(ec(e)&&(e=e.__vccOpts),t){t=Ss(t);let{class:e,style:n}=t;e&&!y(e)&&(t.class=O(e)),x(n)&&(on(n)&&!p(n)&&(n=l({},n)),t.style=ge(n))}let o=y(e)?1:Jo(e)?128:Mr(e)?64:x(e)?4:v(e)?2:0;return V(e,t,n,r,i,o,a,!0)}function Ss(e){return e?on(e)||bo(e)?l({},e):e:null}function Cs(e,t,n=!1,r=!1){let{props:i,ref:a,patchFlag:o,children:s,transition:c}=e,l=t?ks(i||{},t):i,u={__v_isVNode:!0,__v_skip:!0,type:e.type,props:l,key:l&&ys(l),ref:t&&t.ref?n&&a?p(a)?a.concat(bs(t)):[a,bs(t)]:bs(t):a,scopeId:e.scopeId,slotScopeIds:e.slotScopeIds,children:s,target:e.target,targetStart:e.targetStart,targetAnchor:e.targetAnchor,staticCount:e.staticCount,shapeFlag:e.shapeFlag,patchFlag:t&&e.type!==L?o===-1?16:o|16:o,dynamicProps:e.dynamicProps,dynamicChildren:e.dynamicChildren,appContext:e.appContext,dirs:e.dirs,transition:c,component:e.component,suspense:e.suspense,ssContent:e.ssContent&&Cs(e.ssContent),ssFallback:e.ssFallback&&Cs(e.ssFallback),placeholder:e.placeholder,el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce};return c&&r&&ri(u,c.clone(u)),u}function U(e=` `,t=0){return H(ss,null,e,t)}function ws(e,t){let n=H(ls,null,e);return n.staticCount=t,n}function Ts(e=``,t=!1){return t?(R(),B(cs,null,e)):H(cs,null,e)}function Es(e){return e==null||typeof e==`boolean`?H(cs):p(e)?H(L,null,e.slice()):gs(e)?Ds(e):H(ss,null,String(e))}function Ds(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:Cs(e)}function Os(e,t){let n=0,{shapeFlag:r}=e;if(t==null)t=null;else if(p(t))n=16;else if(typeof t==`object`){if(r&65){let n=t.default;n&&(n._c&&(n._d=!1),Os(e,n()),n._c&&(n._d=!0));return}{n=32;let r=t._;!r&&!bo(t)?t._ctx=ur:r===3&&ur&&(ur.slots._===1?t._=1:(t._=2,e.patchFlag|=1024))}}else if(v(t)){if(r&65){Os(e,{default:t});return}t={default:t,_ctx:ur},n=32}else t=String(t),r&64?(n=16,t=[U(t)]):n=8;e.children=t,e.shapeFlag|=n}function ks(...e){let t={};for(let n=0;n<e.length;n++){let r=e[n];for(let e in r)if(e===`class`)t.class!==r.class&&(t.class=O([t.class,r.class]));else if(e===`style`)t.style=ge([t.style,r.style]);else if(s(e)){let n=t[e],i=r[e];i&&n!==i&&!(p(n)&&n.includes(i))?t[e]=n?[].concat(n,i):i:i==null&&n==null&&!c(e)&&(t[e]=i)}else e!==``&&(t[e]=r[e])}return t}function As(e,t,n,r=null){Hn(e,t,7,[n,r])}var js=$a(),Ms=0;function Ns(e,t,n){let i=e.type,a=(t?t.appContext:e.appContext)||js,o={uid:Ms++,vnode:e,type:i,parent:t,appContext:a,root:null,next:null,subTree:null,effect:null,update:null,job:null,scope:new Ne(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:t?t.provides:Object.create(a.provides),ids:t?t.ids:[``,0,0],accessCache:null,renderCache:[],components:null,directives:null,propsOptions:Eo(i,a),emitsOptions:so(i,a),emit:null,emitted:null,propsDefaults:r,inheritAttrs:i.inheritAttrs,ctx:r,data:r,props:r,attrs:r,slots:r,refs:r,setupState:r,setupContext:null,suspense:n,suspenseId:n?n.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return o.ctx={_:o},o.root=t?t.root:o,o.emit=ao.bind(null,o),e.ce&&e.ce(o),o}var Ps=null,Fs=()=>Ps||ur,Is,Ls;{let e=me(),t=(t,n)=>{let r;return(r=e[t])||(r=e[t]=[]),r.push(n),e=>{r.length>1?r.forEach(t=>t(e)):r[0](e)}};Is=t(`__VUE_INSTANCE_SETTERS__`,e=>Ps=e),Ls=t(`__VUE_SSR_SETTERS__`,e=>Vs=e)}var Rs=e=>{let t=Ps;return Is(e),e.scope.on(),()=>{e.scope.off(),Is(t)}},zs=()=>{Ps&&Ps.scope.off(),Is(null)};function Bs(e){return e.vnode.shapeFlag&4}var Vs=!1;function Hs(e,t=!1,n=!1){t&&Ls(t);let{props:r,children:i}=e.vnode,a=Bs(e);xo(e,r,a,t),Po(e,i,n||t);let o=a?Us(e,t):void 0;return t&&Ls(!1),o}function Us(e,t){let n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,xa);let{setup:r}=n;if(r){nt();let n=e.setupContext=r.length>1?Zs(e):null,i=Rs(e),a=Vn(r,e,0,[e.props,n]),o=S(a);if(rt(),i(),(o||e.sp)&&!Ii(e)&&oi(e),o){if(a.then(zs,zs),t)return a.then(n=>{Ls(!0);try{Ws(e,n,t)}finally{Ls(!1)}}).catch(t=>{Un(t,e,0)});e.asyncDep=a}else Ws(e,a,t)}else Ys(e,t)}function Ws(e,t,n){v(t)?e.type.__ssrInlineRender?e.ssrRender=t:e.render=t:x(t)&&(e.setupState=gn(t)),Ys(e,n)}var Gs,Ks;function qs(e){Gs=e,Ks=e=>{e.render._rc&&(e.withProxy=new Proxy(e.ctx,Sa))}}var Js=()=>!Gs;function Ys(e,t,n){let r=e.type;if(!e.render){if(!t&&Gs&&!r.render){let t=r.template||Ua(e).template;if(t){let{isCustomElement:n,compilerOptions:i}=e.appContext.config,{delimiters:a,compilerOptions:o}=r,s=l(l({isCustomElement:n,delimiters:a},i),o);r.render=Gs(t,s)}}e.render=r.render||a,Ks&&Ks(e)}{let t=Rs(e);nt();try{za(e)}finally{rt(),t()}}}var Xs={get(e,t){return pt(e,`get`,``),e[t]}};function Zs(e){return{attrs:new Proxy(e.attrs,Xs),slots:e.slots,emit:e.emit,expose:t=>{e.exposed=t||{}}}}function Qs(e){return e.exposed?e.exposeProxy||=new Proxy(gn(sn(e.exposed)),{get(t,n){if(n in t)return t[n];if(n in ya)return ya[n](e)},has(e,t){return t in e||t in ya}}):e.proxy}function $s(e,t=!0){return v(e)?e.displayName||e.name:e.name||t&&e.__name}function ec(e){return v(e)&&`__vccOpts`in e}var W=(e,t)=>Tn(e,t,Vs);function G(e,t,n){try{ms(-1);let r=arguments.length;return r===2?x(t)&&!p(t)?gs(t)?H(e,null,[t]):H(e,t):H(e,null,t):(r>3?n=Array.prototype.slice.call(arguments,2):r===3&&gs(n)&&(n=[n]),H(e,t,n))}finally{ms(1)}}function tc(){}function nc(e,t,n,r){let i=n[r];if(i&&rc(i,e))return i;let a=t();return a.memo=e.slice(),a.cacheIndex=r,n[r]=a}function rc(e,t){let n=e.memo;if(n.length!=t.length)return!1;for(let e=0;e<n.length;e++)if(D(n[e],t[e]))return!1;return ps>0&&ds&&ds.push(e),!0}var ic=`3.5.41`,ac=a,oc=Bn,sc=sr,cc=lr,lc={createComponentInstance:Ns,setupComponent:Hs,renderComponentRoot:lo,setCurrentRenderingInstance:fr,isVNode:gs,normalizeVNode:Es,getComponentPublicInstance:Qs,ensureValidVNode:ga,pushWarningContext:In,popWarningContext:Ln},uc=void 0,dc=typeof window<`u`&&window.trustedTypes;if(dc)try{uc=dc.createPolicy(`vue`,{createHTML:e=>e})}catch{}var fc=uc?e=>uc.createHTML(e):e=>e,pc=`http://www.w3.org/2000/svg`,mc=`http://www.w3.org/1998/Math/MathML`,hc=typeof document<`u`?document:null,gc=hc&&hc.createElement(`template`),_c={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{let t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,r)=>{let i=t===`svg`?hc.createElementNS(pc,e):t===`mathml`?hc.createElementNS(mc,e):n?hc.createElement(e,{is:n}):hc.createElement(e);return e===`select`&&r&&r.multiple!=null&&i.setAttribute(`multiple`,r.multiple),i},createText:e=>hc.createTextNode(e),createComment:e=>hc.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>hc.querySelector(e),setScopeId(e,t){e.setAttribute(t,``)},insertStaticContent(e,t,n,r,i,a){let o=n?n.previousSibling:t.lastChild;if(i&&(i===a||i.nextSibling))for(;t.insertBefore(i.cloneNode(!0),n),!(i===a||!(i=i.nextSibling)););else{gc.innerHTML=fc(r===`svg`?`<svg>${e}</svg>`:r===`mathml`?`<math>${e}</math>`:e);let i=gc.content;if(r===`svg`||r===`mathml`){let e=i.firstChild;for(;e.firstChild;)i.appendChild(e.firstChild);i.removeChild(e)}t.insertBefore(i,n)}return[o?o.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},vc=`transition`,yc=`animation`,bc=Symbol(`_vtc`),xc={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Sc=l({},Jr,xc),Cc=(e=>(e.displayName=`Transition`,e.props=Sc,e))((e,{slots:t})=>G(Qr,Ec(e),t)),wc=(e,t=[])=>{p(e)?e.forEach(e=>e(...t)):e&&e(...t)},Tc=e=>e?p(e)?e.some(e=>e.length>1):e.length>1:!1;function Ec(e){let t={};for(let n in e)n in xc||(t[n]=e[n]);if(e.css===!1)return t;let{name:n=`v`,type:r,duration:i,enterFromClass:a=`${n}-enter-from`,enterActiveClass:o=`${n}-enter-active`,enterToClass:s=`${n}-enter-to`,appearFromClass:c=a,appearActiveClass:u=o,appearToClass:d=s,leaveFromClass:f=`${n}-leave-from`,leaveActiveClass:p=`${n}-leave-active`,leaveToClass:m=`${n}-leave-to`}=e,h=Dc(i),g=h&&h[0],_=h&&h[1],{onBeforeEnter:v,onEnter:y,onEnterCancelled:b,onLeave:x,onLeaveCancelled:S,onBeforeAppear:C=v,onAppear:w=y,onAppearCancelled:ee=b}=t,te=(e,t,n,r)=>{e._enterCancelled=r,Ac(e,t?d:s),Ac(e,t?u:o),n&&n()},T=(e,t)=>{e._isLeaving=!1,Ac(e,f),Ac(e,m),Ac(e,p),t&&t()},ne=e=>(t,n)=>{let i=e?w:y,o=()=>te(t,e,n);wc(i,[t,o]),jc(()=>{Ac(t,e?c:a),kc(t,e?d:s),Tc(i)||Nc(t,r,g,o)})};return l(t,{onBeforeEnter(e){wc(v,[e]),kc(e,a),kc(e,o)},onBeforeAppear(e){wc(C,[e]),kc(e,c),kc(e,u)},onEnter:ne(!1),onAppear:ne(!0),onLeave(e,t){e._isLeaving=!0;let n=()=>T(e,t);kc(e,f),e._enterCancelled?(kc(e,p),Lc(e)):(Lc(e),kc(e,p)),jc(()=>{e._isLeaving&&(Ac(e,f),kc(e,m),Tc(x)||Nc(e,r,_,n))}),wc(x,[e,n])},onEnterCancelled(e){te(e,!1,void 0,!0),wc(b,[e])},onAppearCancelled(e){te(e,!0,void 0,!0),wc(ee,[e])},onLeaveCancelled(e){T(e),wc(S,[e])}})}function Dc(e){if(e==null)return null;if(x(e))return[Oc(e.enter),Oc(e.leave)];{let t=Oc(e);return[t,t]}}function Oc(e){return fe(e)}function kc(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.add(t)),(e[bc]||(e[bc]=new Set)).add(t)}function Ac(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.remove(t));let n=e[bc];n&&(n.delete(t),n.size||(e[bc]=void 0))}function jc(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}var Mc=0;function Nc(e,t,n,r){let i=e._endId=++Mc,a=()=>{i===e._endId&&r()};if(n!=null)return setTimeout(a,n);let{type:o,timeout:s,propCount:c}=Pc(e,t);if(!o)return r();let l=o+`end`,u=0,d=()=>{e.removeEventListener(l,f),a()},f=t=>{t.target===e&&++u>=c&&d()};setTimeout(()=>{u<c&&d()},s+1),e.addEventListener(l,f)}function Pc(e,t){let n=window.getComputedStyle(e),r=e=>(n[e]||``).split(`, `),i=r(`${vc}Delay`),a=r(`${vc}Duration`),o=Fc(i,a),s=r(`${yc}Delay`),c=r(`${yc}Duration`),l=Fc(s,c),u=null,d=0,f=0;t===vc?o>0&&(u=vc,d=o,f=a.length):t===yc?l>0&&(u=yc,d=l,f=c.length):(d=Math.max(o,l),u=d>0?o>l?vc:yc:null,f=u?u===vc?a.length:c.length:0);let p=u===vc&&/\b(?:transform|all)(?:,|$)/.test(r(`${vc}Property`).toString());return{type:u,timeout:d,propCount:f,hasTransform:p}}function Fc(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max(...t.map((t,n)=>Ic(t)+Ic(e[n])))}function Ic(e){return e===`auto`?0:Number(e.slice(0,-1).replace(`,`,`.`))*1e3}function Lc(e){return(e?e.ownerDocument:document).body.offsetHeight}function Rc(e,t,n){let r=e[bc];r&&(t=(t?[t,...r]:[...r]).join(` `)),t==null?e.removeAttribute(`class`):n?e.setAttribute(`class`,t):e.className=t}var zc=Symbol(`_vod`),Bc=Symbol(`_vsh`),Vc={name:`show`,beforeMount(e,{value:t},{transition:n}){e[zc]=e.style.display===`none`?``:e.style.display,n&&t?n.beforeEnter(e):Hc(e,t)},mounted(e,{value:t},{transition:n}){n&&t&&n.enter(e)},updated(e,{value:t,oldValue:n},{transition:r}){!t!=!n&&(r?t?(r.beforeEnter(e),Hc(e,!0),r.enter(e)):r.leave(e,()=>{Hc(e,!1)}):Hc(e,t))},beforeUnmount(e,{value:t}){Hc(e,t)}};function Hc(e,t){e.style.display=t?e[zc]:`none`,e[Bc]=!t}function Uc(){Vc.getSSRProps=({value:e})=>{if(!e)return{style:{display:`none`}}}}var Wc=Symbol(``);function Gc(e){let t=Fs();if(!t)return;let n=t.ut=(n=e(t.proxy))=>{Array.from(document.querySelectorAll(`[data-v-owner="${t.uid}"]`)).forEach(e=>qc(e,n))},r=()=>{let r=e(t.proxy);t.ce?qc(t.ce,r):Kc(t.subTree,r),n(r)};Qi(()=>{nr(r)}),Zi(()=>{Er(r,a,{flush:`post`});let e=new MutationObserver(r);e.observe(t.subTree.el.parentNode,{childList:!0}),ta(()=>e.disconnect())})}function Kc(e,t){if(e.shapeFlag&128){let n=e.suspense;e=n.activeBranch,n.pendingBranch&&!n.isHydrating&&n.effects.push(()=>{Kc(n.activeBranch,t)})}for(;e.component;)e=e.component.subTree;if(e.shapeFlag&1&&e.el)qc(e.el,t);else if(e.type===L)e.children.forEach(e=>Kc(e,t));else if(e.type===ls){let{el:n,anchor:r}=e;for(;n&&(qc(n,t),n!==r);)n=n.nextSibling}}function qc(e,t){if(e.nodeType===1){let n=e.style,r=``;for(let e in t){let i=je(t[e]);n.setProperty(`--${e}`,i),r+=`--${e}: ${i};`}n[Wc]=r}}var Jc=/(?:^|;)\s*display\s*:/;function Yc(e,t,n){let r=e.style,i=y(n),a=!1;if(n&&!i){if(t){if(y(t))for(let e of t.split(`;`)){let t=e.slice(0,e.indexOf(`:`)).trim();n[t]??Zc(r,t,``)}else for(let e in t)n[e]??Zc(r,e,``)}for(let i in n){i===`display`&&(a=!0);let o=n[i];o==null?Zc(r,i,``):tl(e,i,!y(t)&&t?t[i]:void 0,o)||Zc(r,i,o)}}else if(i){if(t!==n){let e=r[Wc];e&&(n+=`;`+e),r.cssText=n,a=Jc.test(n)}}else t&&e.removeAttribute(`style`);zc in e&&(e[zc]=a?r.display:``,e[Bc]&&(r.display=`none`))}var Xc=/\s*!important$/;function Zc(e,t,n){if(p(n))n.forEach(n=>Zc(e,t,n));else if(n??=``,t.startsWith(`--`))e.setProperty(t,n);else{let r=el(e,t);Xc.test(n)?e.setProperty(oe(r),n.replace(Xc,``),`important`):e[r]=n}}var Qc=[`Webkit`,`Moz`,`ms`],$c={};function el(e,t){let n=$c[t];if(n)return n;let r=E(t);if(r!==`filter`&&r in e)return $c[t]=r;r=se(r);for(let n=0;n<Qc.length;n++){let i=Qc[n]+r;if(i in e)return $c[t]=i}return t}function tl(e,t,n,r){return e.tagName===`TEXTAREA`&&(t===`width`||t===`height`)&&y(r)&&n===r}var nl=`http://www.w3.org/1999/xlink`;function rl(e,t,n,r,i,a=Ce(t)){r&&t.startsWith(`xlink:`)?n==null?e.removeAttributeNS(nl,t.slice(6,t.length)):e.setAttributeNS(nl,t,n):n==null||a&&!we(n)?e.removeAttribute(t):e.setAttribute(t,a?``:b(n)?String(n):n)}function il(e,t,n,r,i){if(t===`innerHTML`||t===`textContent`){n!=null&&(e[t]=t===`innerHTML`?fc(n):n);return}let a=e.tagName;if(t===`value`&&a!==`PROGRESS`&&!a.includes(`-`)){let r=a===`OPTION`?e.getAttribute(`value`)||``:e.value,i=n==null?e.type===`checkbox`?`on`:``:String(n);(r!==i||!(`_value`in e))&&(e.value=i),n??e.removeAttribute(t),e._value=n;return}let o=!1;if(n===``||n==null){let r=typeof e[t];r===`boolean`?n=we(n):n==null&&r===`string`?(n=``,o=!0):r===`number`&&(n=0,o=!0)}try{e[t]=n}catch{}o&&e.removeAttribute(i||t)}function al(e,t,n,r){e.addEventListener(t,n,r)}function ol(e,t,n,r){e.removeEventListener(t,n,r)}var sl=Symbol(`_vei`);function cl(e,t,n,r,i=null){let a=e[sl]||(e[sl]={}),o=a[t];if(r&&o)o.value=r;else{let[n,s]=dl(t);r?al(e,n,a[t]=hl(r,i),s):o&&(ol(e,n,o,s),a[t]=void 0)}}var ll=/(Once|Passive|Capture)$/,ul=/^on:?(?:Once|Passive|Capture)$/;function dl(e){let t,n;for(;(n=e.match(ll))&&!ul.test(e);)t||={},e=e.slice(0,e.length-n[1].length),t[n[1].toLowerCase()]=!0;return[e[2]===`:`?e.slice(3):oe(e.slice(2)),t]}var fl=0,pl=Promise.resolve(),ml=()=>fl||=(pl.then(()=>fl=0),Date.now());function hl(e,t){let n=e=>{if(!e._vts)e._vts=Date.now();else if(e._vts<=n.attached)return;let r=n.value;if(p(r)){let n=e.stopImmediatePropagation;e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0};let i=r.slice(),a=[e];for(let n=0;n<i.length&&!e._stopped;n++){let e=i[n];e&&Hn(e,t,5,a)}}else Hn(r,t,5,[e])};return n.value=e,n.attached=ml(),n}var gl=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,_l=(e,t,n,r,i,a)=>{let o=i===`svg`;t===`class`?Rc(e,r,o):t===`style`?Yc(e,n,r):s(t)?c(t)||cl(e,t,n,r,a):(t[0]===`.`?(t=t.slice(1),!0):t[0]===`^`?(t=t.slice(1),!1):vl(e,t,r,o))?(il(e,t,r),!e.tagName.includes(`-`)&&(t===`value`||t===`checked`||t===`selected`)&&rl(e,t,r,o,a,t!==`value`)):e._isVueCE&&(yl(e,t)||e._def.__asyncLoader&&(/[A-Z]/.test(t)||!y(r)))?il(e,E(t),r,a,t):(t===`true-value`?e._trueValue=r:t===`false-value`&&(e._falseValue=r),rl(e,t,r,o))};function vl(e,t,n,r){if(r)return!!(t===`innerHTML`||t===`textContent`||t in e&&gl(t)&&v(n));if(t===`spellcheck`||t===`draggable`||t===`translate`||t===`autocorrect`||t===`sandbox`&&e.tagName===`IFRAME`||t===`form`||t===`list`&&e.tagName===`INPUT`||t===`type`&&e.tagName===`TEXTAREA`)return!1;if(t===`width`||t===`height`){let t=e.tagName;if(t===`IMG`||t===`VIDEO`||t===`CANVAS`||t===`SOURCE`)return!1}return gl(t)&&y(n)?!1:t in e}function yl(e,t){let n=e._def.props;if(!n)return!1;let r=E(t);return Array.isArray(n)?n.some(e=>E(e)===r):Object.keys(n).some(e=>E(e)===r)}var bl={};function xl(e,t,n){let r=F(e,t);te(r)&&(r=l({},r,t));class i extends wl{constructor(e){super(r,e,n)}}return i.def=r,i}var Sl=((e,t)=>xl(e,t,hu)),Cl=typeof HTMLElement<`u`?HTMLElement:class{},wl=class e extends Cl{constructor(e,t={},n=mu){super(),this._def=e,this._props=t,this._createApp=n,this._isVueCE=!0,this._instance=null,this._app=null,this._nonce=this._def.nonce,this._connected=!1,this._resolved=!1,this._patching=!1,this._dirty=!1,this._numberProps=null,this._styleChildren=new WeakSet,this._styleAnchors=new WeakMap,this._ob=null,this.shadowRoot&&n!==mu?this._root=this.shadowRoot:e.shadowRoot===!1?this._root=this:(this.attachShadow(l({},e.shadowRootOptions,{mode:`open`})),this._root=this.shadowRoot)}connectedCallback(){if(!this.isConnected)return;!this.shadowRoot&&!this._resolved&&this._parseSlots(),this._connected=!0;let t=this;for(;t&&=t.assignedSlot||t.parentNode||t.host;)if(t instanceof e){this._parent=t;break}this._instance||(this._resolved?this._mount(this._def):t&&t._pendingResolve?this._pendingResolve=t._pendingResolve.then(()=>{if(this._pendingResolve=void 0,this.isConnected)return this._resolveDef()}):this._resolveDef())}_setParent(e=this._parent){e&&(this._instance.parent=e._instance,this._inheritParentContext(e))}_inheritParentContext(e=this._parent){e&&this._app&&Object.setPrototypeOf(this._app._context.provides,e._instance.provides)}disconnectedCallback(){this._connected=!1,Qn(()=>{this._connected||(this._ob&&=(this._ob.disconnect(),null),this._app&&this._app.unmount(),this._instance&&(this._instance.ce=void 0),this._app=this._instance=null,this._teleportTargets&&=(this._teleportTargets.clear(),void 0))})}_processMutations(e){for(let t of e)this._setAttr(t.attributeName)}_resolveDef(){if(this._pendingResolve)return this._pendingResolve;for(let e=0;e<this.attributes.length;e++)this._setAttr(this.attributes[e].name);this._ob=new MutationObserver(this._processMutations.bind(this)),this._ob.observe(this,{attributes:!0});let e=(e,t=!1)=>{this._resolved=!0,this._pendingResolve=void 0;let{props:n,styles:r}=e,i;if(n&&!p(n))for(let e in n){let t=n[e];(t===Number||t&&t.type===Number)&&(e in this._props&&(this._props[e]=fe(this._props[e])),(i||=Object.create(null))[E(e)]=!0)}this._numberProps=i,this._resolveProps(e),this.shadowRoot&&this._applyStyles(r),this._mount(e)},t=this._def.__asyncLoader;if(t)return this._pendingResolve=t().then(t=>{t.configureApp=this._def.configureApp,e(this._def=t,!0)}),this._pendingResolve;e(this._def)}_mount(e){this._app=this._createApp(e),this._inheritParentContext(),e.configureApp&&e.configureApp(this._app),this._app._ceVNode=this._createVNode(),this._app.mount(this._root);let t=this._instance&&this._instance.exposed;if(t)for(let e in t)f(this,e)||Object.defineProperty(this,e,{get:()=>N(t[e])})}_resolveProps(e){let{props:t}=e,n=p(t)?t:Object.keys(t||{});for(let e of Object.keys(this))e[0]!==`_`&&n.includes(e)&&this._setProp(e,this[e]);for(let e of n.map(E))Object.defineProperty(this,e,{get(){return this._getProp(e)},set(t){this._setProp(e,t,!0,!this._patching)}})}_setAttr(e){if(e.startsWith(`data-v-`))return;let t=this.hasAttribute(e),n=t?this.getAttribute(e):bl,r=E(e);t&&this._numberProps&&this._numberProps[r]&&(n=fe(n)),this._setProp(r,n,!1,!0)}_getProp(e){return this._props[e]}_setProp(e,t,n=!0,r=!1){if(t!==this._props[e]&&(this._dirty=!0,t===bl?delete this._props[e]:(this._props[e]=t,e===`key`&&this._app&&(this._app._ceVNode.key=t)),r&&this._instance&&this._update(),n)){let n=this._ob;n&&(this._processMutations(n.takeRecords()),n.disconnect()),t===!0?this.setAttribute(oe(e),``):typeof t==`string`||typeof t==`number`?this.setAttribute(oe(e),t+``):t||this.removeAttribute(oe(e)),n&&n.observe(this,{attributes:!0})}}_update(){let e=this._createVNode();this._app&&(e.appContext=this._app._context),fu(e,this._root)}_createVNode(){let e={};this.shadowRoot||(e.onVnodeMounted=e.onVnodeUpdated=this._renderSlots.bind(this));let t=H(this._def,l(e,this._props));return this._instance||(t.ce=e=>{this._instance=e,e.ce=this,e.isCE=!0;let t=(e,t)=>{this.dispatchEvent(new CustomEvent(e,te(t[0])?l({detail:t},t[0]):{detail:t}))};e.emit=(e,...n)=>{t(e,n),oe(e)!==e&&t(oe(e),n)},this._setParent()}),t}_applyStyles(e,t,n){if(!e)return;if(t){if(t===this._def||this._styleChildren.has(t))return;this._styleChildren.add(t)}let r=this._nonce,i=this.shadowRoot,a=n?this._getStyleAnchor(n)||this._getStyleAnchor(this._def):this._getRootStyleInsertionAnchor(i),o=null;for(let s=e.length-1;s>=0;s--){let c=document.createElement(`style`);r&&c.setAttribute(`nonce`,r),c.textContent=e[s],i.insertBefore(c,o||a),o=c,s===0&&(n||this._styleAnchors.set(this._def,c),t&&this._styleAnchors.set(t,c))}}_getStyleAnchor(e){if(!e)return null;let t=this._styleAnchors.get(e);return t&&t.parentNode===this.shadowRoot?t:(t&&this._styleAnchors.delete(e),null)}_getRootStyleInsertionAnchor(e){for(let t=0;t<e.childNodes.length;t++){let n=e.childNodes[t];if(!(n instanceof HTMLStyleElement))return n}return null}_parseSlots(){let e=this._slots={},t;for(;t=this.firstChild;){let n=t.nodeType===1&&t.getAttribute(`slot`)||`default`;(e[n]||(e[n]=[])).push(t),this.removeChild(t)}}_renderSlots(){let e=this._getSlots(),t=this._instance.type.__scopeId;for(let n=0;n<e.length;n++){let r=e[n],i=r.getAttribute(`name`)||`default`,a=this._slots[i],o=r.parentNode;if(a)for(let e of a){if(t&&e.nodeType===1){let n=t+`-s`,r=document.createTreeWalker(e,1);e.setAttribute(n,``);let i;for(;i=r.nextNode();)i.setAttribute(n,``)}o.insertBefore(e,r)}else for(;r.firstChild;)o.insertBefore(r.firstChild,r);o.removeChild(r)}}_getSlots(){let e=[this];this._teleportTargets&&e.push(...this._teleportTargets);let t=new Set;for(let n of e){let e=n.querySelectorAll(`slot`);for(let n=0;n<e.length;n++)t.add(e[n])}return Array.from(t)}_injectChildStyle(e,t){this._applyStyles(e.styles,e,t)}_beginPatch(){this._patching=!0,this._dirty=!1}_endPatch(){this._patching=!1,this._dirty&&this._instance&&this._update()}_hasShadowRoot(){return this._def.shadowRoot!==!1}_removeChildStyle(e){}};function Tl(e){let t=Fs();return t&&t.ce||null}function El(){let e=Tl();return e&&e.shadowRoot}function Dl(e=`$style`){{let t=Fs();if(!t)return r;let n=t.type.__cssModules;return n&&n[e]||r}}var Ol=new WeakMap,kl=new WeakMap,Al=Symbol(`_moveCb`),jl=Symbol(`_enterCb`),Ml=(e=>(delete e.props.mode,e))({name:`TransitionGroup`,props:l({},Sc,{tag:String,moveClass:String}),setup(e,{slots:t}){let n=Fs(),r=Kr(),i,a;return $i(()=>{if(!i.length)return;let t=e.moveClass||`${e.name||`v`}-move`;if(!Ll(i[0].el,n.vnode.el,t)){i=[];return}i.forEach(Nl),i.forEach(Pl);let r=i.filter(Fl);Lc(n.vnode.el),r.forEach(e=>{let n=e.el,r=n.style;kc(n,t),r.transform=r.webkitTransform=r.transitionDuration=``;let i=n[Al]=e=>{e&&e.target!==n||(!e||e.propertyName.endsWith(`transform`))&&(n.removeEventListener(`transitionend`,i),n[Al]=null,Ac(n,t))};n.addEventListener(`transitionend`,i)}),i=[]}),()=>{let o=A(e),s=Ec(o),c=o.tag||L;if(i=[],a)for(let e=0;e<a.length;e++){let t=a[e];t.el&&t.el instanceof Element&&!t.el[Bc]&&(i.push(t),ri(t,ei(t,s,r,n)),Ol.set(t,Il(t.el)))}a=t.default?ii(t.default()):[];for(let e=0;e<a.length;e++){let t=a[e];t.key!=null&&ri(t,ei(t,s,r,n))}return H(c,null,a)}}});function Nl(e){let t=e.el;t[Al]&&t[Al](),t[jl]&&t[jl]()}function Pl(e){kl.set(e,Il(e.el))}function Fl(e){let t=Ol.get(e),n=kl.get(e),r=t.left-n.left,i=t.top-n.top;if(r||i){let t=e.el,n=t.style,a=t.getBoundingClientRect(),o=1,s=1;return t.offsetWidth&&(o=a.width/t.offsetWidth),t.offsetHeight&&(s=a.height/t.offsetHeight),(!Number.isFinite(o)||o===0)&&(o=1),(!Number.isFinite(s)||s===0)&&(s=1),Math.abs(o-1)<.01&&(o=1),Math.abs(s-1)<.01&&(s=1),n.transform=n.webkitTransform=`translate(${r/o}px,${i/s}px)`,n.transitionDuration=`0s`,e}}function Il(e){let t=e.getBoundingClientRect();return{left:t.left,top:t.top}}function Ll(e,t,n){let r=e.cloneNode(),i=e[bc];i&&i.forEach(e=>{e.split(/\s+/).forEach(e=>e&&r.classList.remove(e))}),n.split(/\s+/).forEach(e=>e&&r.classList.add(e)),r.style.display=`none`;let a=t.nodeType===1?t:t.parentNode;a.appendChild(r);let{hasTransform:o}=Pc(r);return a.removeChild(r),o}var Rl=e=>{let t=e.props[`onUpdate:modelValue`]||!1;return p(t)?e=>le(t,e):t};function zl(e){e.target.composing=!0}function Bl(e){let t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event(`input`)))}var Vl=Symbol(`_assign`),Hl=Symbol(`_initialValue`);function Ul(e,t,n){return t&&(e=e.trim()),n&&(e=de(e)),e}var Wl={created(e,{modifiers:{lazy:t,trim:n,number:r}},i){e.parentNode&&(e.type===`text`?e[Hl]=e.defaultValue.replace(/[\r\n]/g,``):e.type===`textarea`&&(e[Hl]=e.defaultValue.replace(/\r\n?/g,`
`))),e[Vl]=Rl(i);let a=r||i.props&&i.props.type===`number`;al(e,t?`change`:`input`,t=>{t.target.composing||e[Vl](Ul(e.value,n,a))}),(n||a)&&al(e,`change`,()=>{e.value=Ul(e.value,n,a)}),t||(al(e,`compositionstart`,zl),al(e,`compositionend`,Bl),al(e,`change`,Bl))},mounted(e,{value:t,modifiers:{trim:n,number:r}}){let i=t??``,a=e[Hl];delete e[Hl],a!==void 0&&(e.type===`text`||e.type===`textarea`)&&e.value!==a?e[Vl](Ul(e.value,n,r)):e.value=i},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:r,trim:i,number:a}},o){if(e[Vl]=Rl(o),e.composing)return;let s=(a||e.type===`number`)&&!/^0\d/.test(e.value)?de(e.value):e.value,c=t??``;if(s===c)return;let l=e.getRootNode();(l instanceof Document||l instanceof ShadowRoot)&&l.activeElement===e&&e.type!==`range`&&(r&&t===n||i&&e.value.trim()===c)||(e.value=c)}},Gl={deep:!0,created(e,t,n){e[Vl]=Rl(n),al(e,`change`,()=>{let t=e._modelValue,n=Xl(e),r=e.checked,i=e[Vl];if(p(t)){let e=De(t,n),a=e!==-1;if(r&&!a)i(t.concat(n));else if(!r&&a){let n=[...t];n.splice(e,1),i(n)}}else if(h(t)){let e=new Set(t);r?e.add(n):e.delete(n),i(e)}else i(Zl(e,r))})},mounted:Kl,beforeUpdate(e,t,n){e[Vl]=Rl(n),Kl(e,t,n)}};function Kl(e,{value:t,oldValue:n},r){e._modelValue=t;let i;if(p(t))i=De(t,r.props.value)>-1;else if(h(t))i=t.has(r.props.value);else{if(t===n)return;i=Ee(t,Zl(e,!0))}e.checked!==i&&(e.checked=i)}var ql={created(e,{value:t},n){e.checked=Ee(t,n.props.value),e[Vl]=Rl(n),al(e,`change`,()=>{e[Vl](Xl(e))})},beforeUpdate(e,{value:t,oldValue:n},r){e[Vl]=Rl(r),t!==n&&(e.checked=Ee(t,r.props.value))}},Jl={deep:!0,created(e,{value:t,modifiers:{number:n}},r){e._modelValue=t,al(e,`change`,()=>{let t=Array.prototype.filter.call(e.options,e=>e.selected).map(e=>n?de(Xl(e)):Xl(e));e[Vl](e.multiple?h(e._modelValue)?new Set(t):t:t[0]),e._assigning=!0,Qn(()=>{e._assigning=!1})}),e[Vl]=Rl(r)},mounted(e,{value:t}){Yl(e,t)},beforeUpdate(e,{value:t},n){e._modelValue=t,e[Vl]=Rl(n)},updated(e,{value:t}){e._assigning||Yl(e,t)}};function Yl(e,t){let n=e.multiple,r=p(t);if(!(n&&!r&&!h(t))){for(let i=0,a=e.options.length;i<a;i++){let a=e.options[i],o=Xl(a);if(n){if(r){let e=typeof o;a.selected=e===`string`||e===`number`?t.some(e=>String(e)===String(o)):De(t,o)>-1}else a.selected=t.has(o)}else if(Ee(Xl(a),t)){e.selectedIndex!==i&&(e.selectedIndex=i);return}}!n&&e.selectedIndex!==-1&&(e.selectedIndex=-1)}}function Xl(e){return`_value`in e?e._value:e.value}function Zl(e,t){let n=t?`_trueValue`:`_falseValue`;return n in e?e[n]:t}var Ql={created(e,t,n){eu(e,t,n,null,`created`)},mounted(e,t,n){eu(e,t,n,null,`mounted`)},beforeUpdate(e,t,n,r){eu(e,t,n,r,`beforeUpdate`)},updated(e,t,n,r){eu(e,t,n,r,`updated`)}};function $l(e,t){switch(e){case`SELECT`:return Jl;case`TEXTAREA`:return Wl;default:switch(t){case`checkbox`:return Gl;case`radio`:return ql;default:return Wl}}}function eu(e,t,n,r,i){let a=$l(e.tagName,n.props&&n.props.type)[i];a&&a(e,t,n,r)}function tu(){Wl.getSSRProps=({value:e})=>({value:e}),ql.getSSRProps=({value:e},t)=>{if(t.props&&Ee(t.props.value,e))return{checked:!0}},Gl.getSSRProps=({value:e},t)=>{if(p(e)){if(t.props&&De(e,t.props.value)>-1)return{checked:!0}}else if(h(e)){if(t.props&&e.has(t.props.value))return{checked:!0}}else if(e)return{checked:!0}},Ql.getSSRProps=(e,t)=>{if(typeof t.type!=`string`)return;let n=$l(t.type.toUpperCase(),t.props&&t.props.type);if(n.getSSRProps)return n.getSSRProps(e,t)}}var nu=[`ctrl`,`shift`,`alt`,`meta`],ru={stop:e=>e.stopPropagation(),prevent:e=>e.preventDefault(),self:e=>e.target!==e.currentTarget,ctrl:e=>!e.ctrlKey,shift:e=>!e.shiftKey,alt:e=>!e.altKey,meta:e=>!e.metaKey,left:e=>`button`in e&&e.button!==0,middle:e=>`button`in e&&e.button!==1,right:e=>`button`in e&&e.button!==2,exact:(e,t)=>nu.some(n=>e[`${n}Key`]&&!t.includes(n))},iu=(e,t)=>{if(!e)return e;let n=e._withMods||={},r=t.join(`.`);return n[r]||(n[r]=((n,...r)=>{for(let e=0;e<t.length;e++){let r=ru[t[e]];if(r&&r(n,t))return}return e(n,...r)}))},au={esc:`escape`,space:` `,up:`arrow-up`,left:`arrow-left`,right:`arrow-right`,down:`arrow-down`,delete:`backspace`},ou=(e,t)=>{let n=e._withKeys||={},r=t.join(`.`);return n[r]||(n[r]=(n=>{if(!(`key`in n))return;let r=oe(n.key);if(t.some(e=>e===r||au[e]===r))return e(n)}))},su=l({patchProp:_l},_c),cu,lu=!1;function uu(){return cu||=Lo(su)}function du(){return cu=lu?cu:Ro(su),lu=!0,cu}var fu=((...e)=>{uu().render(...e)}),pu=((...e)=>{du().hydrate(...e)}),mu=((...e)=>{let t=uu().createApp(...e),{mount:n}=t;return t.mount=e=>{let r=_u(e);if(!r)return;let i=t._component;!v(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent=``);let a=n(r,!1,gu(r));return r instanceof Element&&(r.removeAttribute(`v-cloak`),r.setAttribute(`data-v-app`,``)),a},t}),hu=((...e)=>{let t=du().createApp(...e),{mount:n}=t;return t.mount=e=>{let t=_u(e);if(t)return n(t,!0,gu(t))},t});function gu(e){if(e instanceof SVGElement)return`svg`;if(typeof MathMLElement==`function`&&e instanceof MathMLElement)return`mathml`}function _u(e){return y(e)?document.querySelector(e):e}var vu=!1,yu=()=>{vu||(vu=!0,tu(),Uc())},bu=t({BaseTransition:()=>Qr,BaseTransitionPropsValidators:()=>Jr,Comment:()=>cs,DeprecationTypes:()=>null,EffectScope:()=>Ne,ErrorCodes:()=>zn,ErrorTypeStrings:()=>oc,Fragment:()=>L,KeepAlive:()=>Bi,ReactiveEffect:()=>ze,Static:()=>ls,Suspense:()=>Xo,Teleport:()=>Vr,Text:()=>ss,TrackOpTypes:()=>En,Transition:()=>Cc,TransitionGroup:()=>Ml,TriggerOpTypes:()=>Dn,VueElement:()=>wl,assertNumber:()=>Rn,callWithAsyncErrorHandling:()=>Hn,callWithErrorHandling:()=>Vn,camelize:()=>E,capitalize:()=>se,cloneVNode:()=>Cs,compatUtils:()=>null,compile:()=>xu,computed:()=>W,createApp:()=>mu,createBlock:()=>B,createCommentVNode:()=>Ts,createElementBlock:()=>z,createElementVNode:()=>V,createHydrationRenderer:()=>Ro,createPropsRestProxy:()=>Ia,createRenderer:()=>Lo,createSSRApp:()=>hu,createSlots:()=>ha,createStaticVNode:()=>ws,createTextVNode:()=>U,createVNode:()=>H,customRef:()=>vn,defineAsyncComponent:()=>Li,defineComponent:()=>F,defineCustomElement:()=>xl,defineEmits:()=>wa,defineExpose:()=>Ta,defineModel:()=>Oa,defineOptions:()=>Ea,defineProps:()=>Ca,defineSSRCustomElement:()=>Sl,defineSlots:()=>Da,devtools:()=>sc,effect:()=>Qe,effectScope:()=>Pe,getCurrentInstance:()=>Fs,getCurrentScope:()=>Fe,getCurrentWatcher:()=>jn,getTransitionRawChildren:()=>ii,guardReactiveProps:()=>Ss,h:()=>G,handleError:()=>Un,hasInjectionContext:()=>br,hydrate:()=>pu,hydrateOnIdle:()=>Ai,hydrateOnInteraction:()=>Pi,hydrateOnMediaQuery:()=>Ni,hydrateOnVisible:()=>Mi,initCustomFormatter:()=>tc,initDirectivesForSSR:()=>yu,inject:()=>yr,isMemoSame:()=>rc,isProxy:()=>on,isReactive:()=>nn,isReadonly:()=>rn,isRef:()=>j,isRuntimeOnly:()=>Js,isShallow:()=>an,isVNode:()=>gs,markRaw:()=>sn,mergeDefaults:()=>Pa,mergeModels:()=>Fa,mergeProps:()=>ks,nextTick:()=>Qn,nodeOps:()=>_c,normalizeClass:()=>O,normalizeProps:()=>xe,normalizeStyle:()=>ge,onActivated:()=>Hi,onBeforeMount:()=>Xi,onBeforeUnmount:()=>ea,onBeforeUpdate:()=>Qi,onDeactivated:()=>Ui,onErrorCaptured:()=>aa,onMounted:()=>Zi,onRenderTracked:()=>ia,onRenderTriggered:()=>ra,onScopeDispose:()=>Ie,onServerPrefetch:()=>na,onUnmounted:()=>ta,onUpdated:()=>$i,onWatcherCleanup:()=>Mn,openBlock:()=>R,patchProp:()=>_l,popScopeId:()=>mr,provide:()=>vr,proxyRefs:()=>gn,pushScopeId:()=>pr,queuePostFlushCb:()=>nr,reactive:()=>Zt,readonly:()=>$t,ref:()=>M,registerRuntimeCompiler:()=>qs,render:()=>fu,renderList:()=>ma,renderSlot:()=>I,resolveComponent:()=>ca,resolveDirective:()=>da,resolveDynamicComponent:()=>ua,resolveFilter:()=>null,resolveTransitionHooks:()=>ei,setBlockTracking:()=>ms,setDevtoolsHook:()=>cc,setTransitionHooks:()=>ri,shallowReactive:()=>Qt,shallowReadonly:()=>en,shallowRef:()=>un,ssrContextKey:()=>xr,ssrUtils:()=>lc,stop:()=>$e,toDisplayString:()=>k,toHandlerKey:()=>ce,toHandlers:()=>_a,toRaw:()=>A,toRef:()=>Sn,toRefs:()=>yn,toValue:()=>mn,transformVNodeArgs:()=>vs,triggerRef:()=>pn,unref:()=>N,useAttrs:()=>ja,useCssModule:()=>Dl,useCssVars:()=>Gc,useHost:()=>Tl,useId:()=>ai,useModel:()=>ro,useSSRContext:()=>Sr,useShadowRoot:()=>El,useSlots:()=>Aa,useTemplateRef:()=>si,useTransitionState:()=>Kr,vModelCheckbox:()=>Gl,vModelDynamic:()=>Ql,vModelRadio:()=>ql,vModelSelect:()=>Jl,vModelText:()=>Wl,vShow:()=>Vc,version:()=>ic,warn:()=>ac,watch:()=>Er,watchEffect:()=>Cr,watchPostEffect:()=>wr,watchSyncEffect:()=>Tr,withAsyncContext:()=>La,withCtx:()=>P,withDefaults:()=>ka,withDirectives:()=>gr,withKeys:()=>ou,withMemo:()=>nc,withModifiers:()=>iu,withScopeId:()=>hr}),xu=()=>{};function Su(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function Cu(e){if(Array.isArray(e))return e}function wu(e){if(Array.isArray(e))return Su(e)}function Tu(e,t){if(!(e instanceof t))throw TypeError(`Cannot call a class as a function`)}function Eu(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,`value`in r&&(r.writable=!0),Object.defineProperty(e,Lu(r.key),r)}}function Du(e,t,n){return t&&Eu(e.prototype,t),n&&Eu(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function Ou(e,t){var n=typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(!n){if(Array.isArray(e)||(n=zu(e))||t&&e&&typeof e.length==`number`){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw TypeError(`Invalid attempt to iterate non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||n.return==null||n.return()}finally{if(s)throw a}}}}function K(e,t,n){return(t=Lu(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function ku(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function Au(e,t){var n=e==null?null:typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(n!=null){var r,i,a,o,s=[],c=!0,l=!1;try{if(a=(n=n.call(e)).next,t===0){if(Object(n)!==n)return;c=!1}else for(;!(c=(r=a.call(n)).done)&&(s.push(r.value),s.length!==t);c=!0);}catch(e){l=!0,i=e}finally{try{if(!c&&n.return!=null&&(o=n.return(),Object(o)!==o))return}finally{if(l)throw i}}return s}}function ju(){throw TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Mu(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Nu(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function q(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Nu(Object(n),!0).forEach(function(t){K(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Nu(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function Pu(e,t){return Cu(e)||Au(e,t)||zu(e,t)||ju()}function Fu(e){return wu(e)||ku(e)||zu(e)||Mu()}function Iu(e,t){if(typeof e!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(typeof r!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function Lu(e){var t=Iu(e,`string`);return typeof t==`symbol`?t:t+``}function Ru(e){"@babel/helpers - typeof";return Ru=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},Ru(e)}function zu(e,t){if(e){if(typeof e==`string`)return Su(e,t);var n={}.toString.call(e).slice(8,-1);return n===`Object`&&e.constructor&&(n=e.constructor.name),n===`Map`||n===`Set`?Array.from(e):n===`Arguments`||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?Su(e,t):void 0}}var Bu=function(){},Vu={},Hu={},Uu=null,Wu={mark:Bu,measure:Bu};try{typeof window<`u`&&(Vu=window),typeof document<`u`&&(Hu=document),typeof MutationObserver<`u`&&(Uu=MutationObserver),typeof performance<`u`&&(Wu=performance)}catch{}var Gu=(Vu.navigator||{}).userAgent,Ku=Gu===void 0?``:Gu,qu=Vu,Ju=Hu,Yu=Uu,Xu=Wu;qu.document;var Zu=!!Ju.documentElement&&!!Ju.head&&typeof Ju.addEventListener==`function`&&typeof Ju.createElement==`function`,Qu=~Ku.indexOf(`MSIE`)||~Ku.indexOf(`Trident/`),$u,ed=/fa(k|kd|s|r|l|t|d|dr|dl|dt|b|slr|slpr|wsb|tl|ns|nds|es|gt|jr|jfr|jdr|usb|ufsb|udsb|cr|ss|sr|sl|st|sds|sdr|sdl|sdt|sldr|slpdr|pr|ms|vs)?[\-\ ]/,td=/Font ?Awesome ?([567 ]*)(Solid|Regular|Light|Thin|Duotone|Brands|Free|Pro|Sharp Duotone|Sharp|Kit|Notdog Duo|Notdog|Chisel|Etch|Graphite|Thumbprint|Jelly Fill|Jelly Duo|Jelly|Utility|Utility Fill|Utility Duo|Slab Press|Slab|Slab Duo|Slab Press Duo|Pixel|Mosaic|Vellum|Whiteboard)?.*/i,nd={classic:{fa:`solid`,fas:`solid`,"fa-solid":`solid`,far:`regular`,"fa-regular":`regular`,fal:`light`,"fa-light":`light`,fat:`thin`,"fa-thin":`thin`,fab:`brands`,"fa-brands":`brands`},duotone:{fa:`solid`,fad:`solid`,"fa-solid":`solid`,"fa-duotone":`solid`,fadr:`regular`,"fa-regular":`regular`,fadl:`light`,"fa-light":`light`,fadt:`thin`,"fa-thin":`thin`},sharp:{fa:`solid`,fass:`solid`,"fa-solid":`solid`,fasr:`regular`,"fa-regular":`regular`,fasl:`light`,"fa-light":`light`,fast:`thin`,"fa-thin":`thin`},"sharp-duotone":{fa:`solid`,fasds:`solid`,"fa-solid":`solid`,fasdr:`regular`,"fa-regular":`regular`,fasdl:`light`,"fa-light":`light`,fasdt:`thin`,"fa-thin":`thin`},slab:{"fa-regular":`regular`,faslr:`regular`},"slab-press":{"fa-regular":`regular`,faslpr:`regular`},"slab-duo":{"fa-regular":`regular`,fasldr:`regular`},"slab-press-duo":{"fa-regular":`regular`,faslpdr:`regular`},thumbprint:{"fa-light":`light`,fatl:`light`},vellum:{"fa-solid":`solid`,favs:`solid`},pixel:{"fa-regular":`regular`,fapr:`regular`},mosaic:{"fa-solid":`solid`,fams:`solid`},whiteboard:{"fa-semibold":`semibold`,fawsb:`semibold`},notdog:{"fa-solid":`solid`,fans:`solid`},"notdog-duo":{"fa-solid":`solid`,fands:`solid`},etch:{"fa-solid":`solid`,faes:`solid`},graphite:{"fa-thin":`thin`,fagt:`thin`},jelly:{"fa-regular":`regular`,fajr:`regular`},"jelly-fill":{"fa-regular":`regular`,fajfr:`regular`},"jelly-duo":{"fa-regular":`regular`,fajdr:`regular`},chisel:{"fa-regular":`regular`,facr:`regular`},utility:{"fa-semibold":`semibold`,fausb:`semibold`},"utility-duo":{"fa-semibold":`semibold`,faudsb:`semibold`},"utility-fill":{"fa-semibold":`semibold`,faufsb:`semibold`}},rd={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},id=[`fa-classic`,`fa-duotone`,`fa-sharp`,`fa-sharp-duotone`,`fa-thumbprint`,`fa-whiteboard`,`fa-notdog`,`fa-notdog-duo`,`fa-chisel`,`fa-etch`,`fa-graphite`,`fa-jelly`,`fa-jelly-fill`,`fa-jelly-duo`,`fa-slab`,`fa-slab-press`,`fa-slab-press-duo`,`fa-slab-duo`,`fa-mosaic`,`fa-pixel`,`fa-vellum`,`fa-utility`,`fa-utility-duo`,`fa-utility-fill`],ad=`classic`,od=`duotone`,sd=`sharp`,cd=`sharp-duotone`,ld=`chisel`,ud=`etch`,dd=`graphite`,fd=`jelly`,pd=`jelly-duo`,md=`jelly-fill`,hd=`mosaic`,gd=`notdog`,_d=`notdog-duo`,vd=`pixel`,yd=`slab`,bd=`slab-duo`,xd=`slab-press`,Sd=`slab-press-duo`,Cd=`thumbprint`,wd=`utility`,Td=`utility-duo`,Ed=`utility-fill`,Dd=`vellum`,Od=`whiteboard`,kd=`Classic`,Ad=`Duotone`,jd=`Sharp`,Md=`Sharp Duotone`,Nd=`Chisel`,Pd=`Etch`,Fd=`Graphite`,Id=`Jelly`,Ld=`Jelly Duo`,Rd=`Jelly Fill`,zd=`Mosaic`,Bd=`Notdog`,Vd=`Notdog Duo`,Hd=`Pixel`,Ud=`Slab`,Wd=`Slab Duo`,Gd=`Slab Press`,Kd=`Slab Press Duo`,qd=`Thumbprint`,Jd=`Utility`,Yd=`Utility Duo`,Xd=`Utility Fill`,Zd=`Vellum`,Qd=`Whiteboard`,$d=[ad,od,sd,cd,ld,ud,dd,fd,pd,md,hd,gd,_d,vd,yd,bd,xd,Sd,Cd,wd,Td,Ed,Dd,Od];$u={},K(K(K(K(K(K(K(K(K(K($u,ad,kd),od,Ad),sd,jd),cd,Md),ld,Nd),ud,Pd),dd,Fd),fd,Id),pd,Ld),md,Rd),K(K(K(K(K(K(K(K(K(K($u,hd,zd),gd,Bd),_d,Vd),vd,Hd),yd,Ud),bd,Wd),xd,Gd),Sd,Kd),Cd,qd),wd,Jd),K(K(K(K($u,Td,Yd),Ed,Xd),Dd,Zd),Od,Qd);var ef={classic:{900:`fas`,400:`far`,normal:`far`,300:`fal`,100:`fat`},duotone:{900:`fad`,400:`fadr`,300:`fadl`,100:`fadt`},sharp:{900:`fass`,400:`fasr`,300:`fasl`,100:`fast`},"sharp-duotone":{900:`fasds`,400:`fasdr`,300:`fasdl`,100:`fasdt`},slab:{400:`faslr`},"slab-press":{400:`faslpr`},"slab-duo":{400:`fasldr`},"slab-press-duo":{400:`faslpdr`},vellum:{900:`favs`},mosaic:{900:`fams`},pixel:{400:`fapr`},whiteboard:{600:`fawsb`},thumbprint:{300:`fatl`},notdog:{900:`fans`},"notdog-duo":{900:`fands`},etch:{900:`faes`},graphite:{100:`fagt`},chisel:{400:`facr`},jelly:{400:`fajr`},"jelly-fill":{400:`fajfr`},"jelly-duo":{400:`fajdr`},utility:{600:`fausb`},"utility-duo":{600:`faudsb`},"utility-fill":{600:`faufsb`}},tf={"Font Awesome 7 Free":{900:`fas`,400:`far`},"Font Awesome 7 Pro":{900:`fas`,400:`far`,normal:`far`,300:`fal`,100:`fat`},"Font Awesome 7 Brands":{400:`fab`,normal:`fab`},"Font Awesome 7 Duotone":{900:`fad`,400:`fadr`,normal:`fadr`,300:`fadl`,100:`fadt`},"Font Awesome 7 Sharp":{900:`fass`,400:`fasr`,normal:`fasr`,300:`fasl`,100:`fast`},"Font Awesome 7 Sharp Duotone":{900:`fasds`,400:`fasdr`,normal:`fasdr`,300:`fasdl`,100:`fasdt`},"Font Awesome 7 Jelly":{400:`fajr`,normal:`fajr`},"Font Awesome 7 Jelly Fill":{400:`fajfr`,normal:`fajfr`},"Font Awesome 7 Jelly Duo":{400:`fajdr`,normal:`fajdr`},"Font Awesome 7 Slab":{400:`faslr`,normal:`faslr`},"Font Awesome 7 Slab Press":{400:`faslpr`,normal:`faslpr`},"Font Awesome 7 Slab Duo":{400:`fasldr`,normal:`fasldr`},"Font Awesome 7 Slab Press Duo":{400:`faslpdr`,normal:`faslpdr`},"Font Awesome 7 Pixel":{400:`fapr`,normal:`fapr`},"Font Awesome 7 Mosaic":{900:`fams`,normal:`fams`},"Font Awesome 7 Vellum":{900:`favs`,normal:`favs`},"Font Awesome 7 Thumbprint":{300:`fatl`,normal:`fatl`},"Font Awesome 7 Notdog":{900:`fans`,normal:`fans`},"Font Awesome 7 Notdog Duo":{900:`fands`,normal:`fands`},"Font Awesome 7 Etch":{900:`faes`,normal:`faes`},"Font Awesome 7 Graphite":{100:`fagt`,normal:`fagt`},"Font Awesome 7 Chisel":{400:`facr`,normal:`facr`},"Font Awesome 7 Whiteboard":{600:`fawsb`,normal:`fawsb`},"Font Awesome 7 Utility":{600:`fausb`,normal:`fausb`},"Font Awesome 7 Utility Duo":{600:`faudsb`,normal:`faudsb`},"Font Awesome 7 Utility Fill":{600:`faufsb`,normal:`faufsb`}},nf=new Map([[`classic`,{defaultShortPrefixId:`fas`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`,`brands`],futureStyleIds:[],defaultFontWeight:900}],[`duotone`,{defaultShortPrefixId:`fad`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`sharp`,{defaultShortPrefixId:`fass`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`sharp-duotone`,{defaultShortPrefixId:`fasds`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`chisel`,{defaultShortPrefixId:`facr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`etch`,{defaultShortPrefixId:`faes`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`graphite`,{defaultShortPrefixId:`fagt`,defaultStyleId:`thin`,styleIds:[`thin`],futureStyleIds:[],defaultFontWeight:100}],[`jelly`,{defaultShortPrefixId:`fajr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`jelly-duo`,{defaultShortPrefixId:`fajdr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`jelly-fill`,{defaultShortPrefixId:`fajfr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`mosaic`,{defaultShortPrefixId:`fams`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`notdog`,{defaultShortPrefixId:`fans`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`notdog-duo`,{defaultShortPrefixId:`fands`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`pixel`,{defaultShortPrefixId:`fapr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab`,{defaultShortPrefixId:`faslr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-duo`,{defaultShortPrefixId:`fasldr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-press`,{defaultShortPrefixId:`faslpr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-press-duo`,{defaultShortPrefixId:`faslpdr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`thumbprint`,{defaultShortPrefixId:`fatl`,defaultStyleId:`light`,styleIds:[`light`],futureStyleIds:[],defaultFontWeight:300}],[`utility`,{defaultShortPrefixId:`fausb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`utility-duo`,{defaultShortPrefixId:`faudsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`utility-fill`,{defaultShortPrefixId:`faufsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`vellum`,{defaultShortPrefixId:`favs`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`whiteboard`,{defaultShortPrefixId:`fawsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}]]),rf={chisel:{regular:`facr`},classic:{brands:`fab`,light:`fal`,regular:`far`,solid:`fas`,thin:`fat`},duotone:{light:`fadl`,regular:`fadr`,solid:`fad`,thin:`fadt`},etch:{solid:`faes`},graphite:{thin:`fagt`},jelly:{regular:`fajr`},"jelly-duo":{regular:`fajdr`},"jelly-fill":{regular:`fajfr`},mosaic:{solid:`fams`},notdog:{solid:`fans`},"notdog-duo":{solid:`fands`},pixel:{regular:`fapr`},sharp:{light:`fasl`,regular:`fasr`,solid:`fass`,thin:`fast`},"sharp-duotone":{light:`fasdl`,regular:`fasdr`,solid:`fasds`,thin:`fasdt`},slab:{regular:`faslr`},"slab-duo":{regular:`fasldr`},"slab-press":{regular:`faslpr`},"slab-press-duo":{regular:`faslpdr`},thumbprint:{light:`fatl`},utility:{semibold:`fausb`},"utility-duo":{semibold:`faudsb`},"utility-fill":{semibold:`faufsb`},vellum:{solid:`favs`},whiteboard:{semibold:`fawsb`}},af=[`fak`,`fa-kit`,`fakd`,`fa-kit-duotone`],of={kit:{fak:`kit`,"fa-kit":`kit`},"kit-duotone":{fakd:`kit-duotone`,"fa-kit-duotone":`kit-duotone`}},sf=[`kit`];K(K({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var cf={kit:{"fa-kit":`fak`},"kit-duotone":{"fa-kit-duotone":`fakd`}},lf={"Font Awesome Kit":{400:`fak`,normal:`fak`},"Font Awesome Kit Duotone":{400:`fakd`,normal:`fakd`}},uf={kit:{fak:`fa-kit`},"kit-duotone":{fakd:`fa-kit-duotone`}},df={kit:{kit:`fak`},"kit-duotone":{"kit-duotone":`fakd`}},ff,pf={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},mf=[`fa-classic`,`fa-duotone`,`fa-sharp`,`fa-sharp-duotone`,`fa-thumbprint`,`fa-whiteboard`,`fa-notdog`,`fa-notdog-duo`,`fa-chisel`,`fa-etch`,`fa-graphite`,`fa-jelly`,`fa-jelly-fill`,`fa-jelly-duo`,`fa-slab`,`fa-slab-press`,`fa-slab-press-duo`,`fa-slab-duo`,`fa-mosaic`,`fa-pixel`,`fa-vellum`,`fa-utility`,`fa-utility-duo`,`fa-utility-fill`];ff={},K(K(K(K(K(K(K(K(K(K(ff,`classic`,`Classic`),`duotone`,`Duotone`),`sharp`,`Sharp`),`sharp-duotone`,`Sharp Duotone`),`chisel`,`Chisel`),`etch`,`Etch`),`graphite`,`Graphite`),`jelly`,`Jelly`),`jelly-duo`,`Jelly Duo`),`jelly-fill`,`Jelly Fill`),K(K(K(K(K(K(K(K(K(K(ff,`mosaic`,`Mosaic`),`notdog`,`Notdog`),`notdog-duo`,`Notdog Duo`),`pixel`,`Pixel`),`slab`,`Slab`),`slab-duo`,`Slab Duo`),`slab-press`,`Slab Press`),`slab-press-duo`,`Slab Press Duo`),`thumbprint`,`Thumbprint`),`utility`,`Utility`),K(K(K(K(ff,`utility-duo`,`Utility Duo`),`utility-fill`,`Utility Fill`),`vellum`,`Vellum`),`whiteboard`,`Whiteboard`),K(K({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var hf={classic:{"fa-brands":`fab`,"fa-duotone":`fad`,"fa-light":`fal`,"fa-regular":`far`,"fa-solid":`fas`,"fa-thin":`fat`},duotone:{"fa-regular":`fadr`,"fa-light":`fadl`,"fa-thin":`fadt`},sharp:{"fa-solid":`fass`,"fa-regular":`fasr`,"fa-light":`fasl`,"fa-thin":`fast`},"sharp-duotone":{"fa-solid":`fasds`,"fa-regular":`fasdr`,"fa-light":`fasdl`,"fa-thin":`fasdt`},slab:{"fa-regular":`faslr`},"slab-press":{"fa-regular":`faslpr`},"slab-duo":{"fa-regular":`fasldr`},"slab-press-duo":{"fa-regular":`faslpdr`},pixel:{"fa-regular":`fapr`},mosaic:{"fa-solid":`fams`},vellum:{"fa-solid":`favs`},whiteboard:{"fa-semibold":`fawsb`},thumbprint:{"fa-light":`fatl`},notdog:{"fa-solid":`fans`},"notdog-duo":{"fa-solid":`fands`},etch:{"fa-solid":`faes`},graphite:{"fa-thin":`fagt`},jelly:{"fa-regular":`fajr`},"jelly-fill":{"fa-regular":`fajfr`},"jelly-duo":{"fa-regular":`fajdr`},chisel:{"fa-regular":`facr`},utility:{"fa-semibold":`fausb`},"utility-duo":{"fa-semibold":`faudsb`},"utility-fill":{"fa-semibold":`faufsb`}},gf={classic:[`fas`,`far`,`fal`,`fat`,`fad`],duotone:[`fadr`,`fadl`,`fadt`],sharp:[`fass`,`fasr`,`fasl`,`fast`],"sharp-duotone":[`fasds`,`fasdr`,`fasdl`,`fasdt`],slab:[`faslr`],"slab-press":[`faslpr`],"slab-duo":[`fasldr`],"slab-press-duo":[`faslpdr`],pixel:[`fapr`],mosaic:[`fams`],vellum:[`favs`],whiteboard:[`fawsb`],thumbprint:[`fatl`],notdog:[`fans`],"notdog-duo":[`fands`],etch:[`faes`],graphite:[`fagt`],jelly:[`fajr`],"jelly-fill":[`fajfr`],"jelly-duo":[`fajdr`],chisel:[`facr`],utility:[`fausb`],"utility-duo":[`faudsb`],"utility-fill":[`faufsb`]},_f={classic:{fab:`fa-brands`,fad:`fa-duotone`,fal:`fa-light`,far:`fa-regular`,fas:`fa-solid`,fat:`fa-thin`},duotone:{fadr:`fa-regular`,fadl:`fa-light`,fadt:`fa-thin`},sharp:{fass:`fa-solid`,fasr:`fa-regular`,fasl:`fa-light`,fast:`fa-thin`},"sharp-duotone":{fasds:`fa-solid`,fasdr:`fa-regular`,fasdl:`fa-light`,fasdt:`fa-thin`},slab:{faslr:`fa-regular`},"slab-press":{faslpr:`fa-regular`},"slab-duo":{fasldr:`fa-regular`},"slab-press-duo":{faslpdr:`fa-regular`},pixel:{fapr:`fa-regular`},mosaic:{fams:`fa-solid`},vellum:{favs:`fa-solid`},whiteboard:{fawsb:`fa-semibold`},thumbprint:{fatl:`fa-light`},notdog:{fans:`fa-solid`},"notdog-duo":{fands:`fa-solid`},etch:{faes:`fa-solid`},graphite:{fagt:`fa-thin`},jelly:{fajr:`fa-regular`},"jelly-fill":{fajfr:`fa-regular`},"jelly-duo":{fajdr:`fa-regular`},chisel:{facr:`fa-regular`},utility:{fausb:`fa-semibold`},"utility-duo":{faudsb:`fa-semibold`},"utility-fill":{faufsb:`fa-semibold`}},vf=`fa.fas.far.fal.fat.fad.fadr.fadl.fadt.fab.fass.fasr.fasl.fast.fasds.fasdr.fasdl.fasdt.faslr.faslpr.fasldr.faslpdr.fapr.fams.favs.fawsb.fatl.fans.fands.faes.fagt.fajr.fajfr.fajdr.facr.fausb.faudsb.faufsb`.split(`.`).concat(mf,[`fa-solid`,`fa-regular`,`fa-light`,`fa-thin`,`fa-duotone`,`fa-brands`,`fa-semibold`]),yf=[`solid`,`regular`,`light`,`thin`,`duotone`,`brands`,`semibold`],bf=[1,2,3,4,5,6,7,8,9,10],xf=bf.concat([11,12,13,14,15,16,17,18,19,20]),Sf=[].concat(Fu(Object.keys(gf)),yf,[`aw`,`fw`,`pull-left`,`pull-right`],[`2xs`,`xs`,`sm`,`lg`,`xl`,`2xl`,`beat`,`beat-fade`,`border`,`bounce`,`buzz`,`canvas-square`,`canvas-roomy`,`fade`,`flip-360`,`flip-both`,`flip-horizontal`,`flip-vertical`,`flip`,`float`,`inverse`,`jello`,`layers`,`layers-bottom-left`,`layers-bottom-right`,`layers-counter`,`layers-text`,`layers-top-left`,`layers-top-right`,`li`,`pull-end`,`pull-start`,`pulse`,`rotate-180`,`rotate-270`,`rotate-90`,`rotate-by`,`shake`,`spin-pulse`,`spin-reverse`,`spin`,`spin-snap`,`spin-snap-4`,`spin-snap-8`,`stack-1x`,`stack-2x`,`stack`,`swing`,`ul`,`wag`,`width-auto`,`width-fixed`,pf.GROUP,pf.SWAP_OPACITY,pf.PRIMARY,pf.SECONDARY],bf.map(function(e){return`${e}x`}),xf.map(function(e){return`w-${e}`})),Cf={"Font Awesome 5 Free":{900:`fas`,400:`far`},"Font Awesome 5 Pro":{900:`fas`,400:`far`,normal:`far`,300:`fal`},"Font Awesome 5 Brands":{400:`fab`,normal:`fab`},"Font Awesome 5 Duotone":{900:`fad`}},wf=`___FONT_AWESOME___`,Tf=16,Ef=`fa`,Df=`svg-inline--fa`,Of=`data-fa-i2svg`,kf=`data-fa-pseudo-element`,Af=`data-fa-pseudo-element-pending`,jf=`data-prefix`,Mf=`data-icon`,Nf=`fontawesome-i2svg`,Pf=`async`,Ff=[`HTML`,`HEAD`,`STYLE`,`SCRIPT`],If=[`::before`,`::after`,`:before`,`:after`],Lf=function(){try{return!0}catch{return!1}}();function Rf(e){return new Proxy(e,{get:function(e,t){return t in e?e[t]:e[ad]}})}var zf=q({},nd);zf[ad]=q(q(q(q({},{"fa-duotone":`duotone`}),nd[ad]),of.kit),of[`kit-duotone`]);var Bf=Rf(zf),Vf=q({},rf);Vf[ad]=q(q(q(q({},{duotone:`fad`}),Vf[ad]),df.kit),df[`kit-duotone`]);var Hf=Rf(Vf),Uf=q({},_f);Uf[ad]=q(q({},Uf[ad]),uf.kit);var Wf=Rf(Uf),Gf=q({},hf);Gf[ad]=q(q({},Gf[ad]),cf.kit),Rf(Gf);var Kf=ed,qf=`fa-layers-text`,Jf=td;Rf(q({},ef));var Yf=[`class`,`data-prefix`,`data-icon`,`data-fa-transform`,`data-fa-mask`],Xf=rd,Zf=[].concat(Fu(sf),Fu(Sf)),Qf=qu.FontAwesomeConfig||{};function $f(e){var t=Ju.querySelector(`script[`+e+`]`);if(t)return t.getAttribute(e)}function ep(e){return e===``?!0:e===`false`?!1:e===`true`||e}Ju&&typeof Ju.querySelector==`function`&&[[`data-family-prefix`,`familyPrefix`],[`data-css-prefix`,`cssPrefix`],[`data-family-default`,`familyDefault`],[`data-style-default`,`styleDefault`],[`data-replacement-class`,`replacementClass`],[`data-auto-replace-svg`,`autoReplaceSvg`],[`data-auto-add-css`,`autoAddCss`],[`data-search-pseudo-elements`,`searchPseudoElements`],[`data-search-pseudo-elements-warnings`,`searchPseudoElementsWarnings`],[`data-search-pseudo-elements-full-scan`,`searchPseudoElementsFullScan`],[`data-observe-mutations`,`observeMutations`],[`data-mutate-approach`,`mutateApproach`],[`data-keep-original-source`,`keepOriginalSource`],[`data-measure-performance`,`measurePerformance`],[`data-show-missing-icons`,`showMissingIcons`]].forEach(function(e){var t=Pu(e,2),n=t[0],r=t[1],i=ep($f(n));i!=null&&(Qf[r]=i)});var tp={styleDefault:`solid`,familyDefault:ad,cssPrefix:Ef,replacementClass:Df,autoReplaceSvg:!0,autoAddCss:!0,searchPseudoElements:!1,searchPseudoElementsWarnings:!0,searchPseudoElementsFullScan:!1,observeMutations:!0,mutateApproach:`async`,keepOriginalSource:!0,measurePerformance:!1,showMissingIcons:!0};Qf.familyPrefix&&(Qf.cssPrefix=Qf.familyPrefix);var np=q(q({},tp),Qf);np.autoReplaceSvg||(np.observeMutations=!1);var J={};Object.keys(tp).forEach(function(e){Object.defineProperty(J,e,{enumerable:!0,set:function(t){np[e]=t,rp.forEach(function(e){return e(J)})},get:function(){return np[e]}})}),Object.defineProperty(J,"familyPrefix",{enumerable:!0,set:function(e){np.cssPrefix=e,rp.forEach(function(e){return e(J)})},get:function(){return np.cssPrefix}}),qu.FontAwesomeConfig=J;var rp=[];function ip(e){return rp.push(e),function(){rp.splice(rp.indexOf(e),1)}}var ap=Tf,op={size:16,x:0,y:0,rotate:0,flipX:!1,flipY:!1};function sp(e){if(!(!e||!Zu)){var t=Ju.createElement(`style`);t.setAttribute(`type`,`text/css`),t.innerHTML=e;for(var n=Ju.head.childNodes,r=null,i=n.length-1;i>-1;i--){var a=n[i],o=(a.tagName||``).toUpperCase();[`STYLE`,`LINK`].indexOf(o)>-1&&(r=a)}return Ju.head.insertBefore(t,r),e}}var cp=`0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`;function lp(){for(var e=12,t=``;e-->0;)t+=cp[Math.random()*62|0];return t}function up(e){for(var t=[],n=(e||[]).length>>>0;n--;)t[n]=e[n];return t}function dp(e){return e.classList?up(e.classList):(e.getAttribute(`class`)||``).split(` `).filter(function(e){return e})}function fp(e){return`${e}`.replace(/&/g,`&amp;`).replace(/"/g,`&quot;`).replace(/'/g,`&#39;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`)}function pp(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}="${fp(e[n])}" `},``).trim()}function mp(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}: ${e[n].trim()};`},``)}function hp(e){return e.size!==op.size||e.x!==op.x||e.y!==op.y||e.rotate!==op.rotate||e.flipX||e.flipY}function gp(e){var t=e.transform,n=e.containerWidth,r=e.iconWidth;return{outer:{transform:`translate(${n/2} 256)`},inner:{transform:`${`translate(${t.x*32}, ${t.y*32}) `} ${`scale(${t.size/16*(t.flipX?-1:1)}, ${t.size/16*(t.flipY?-1:1)}) `} ${`rotate(${t.rotate} 0 0)`}`},path:{transform:`translate(${r/2*-1} -256)`}}}function _p(e){var t=e.transform,n=e.width,r=n===void 0?Tf:n,i=e.height,a=i===void 0?Tf:i,o=e.startCentered,s=o!==void 0&&o,c=``;return c+=s&&Qu?`translate(${t.x/ap-r/2}em, ${t.y/ap-a/2}em) `:s?`translate(calc(-50% + ${t.x/ap}em), calc(-50% + ${t.y/ap}em)) `:`translate(${t.x/ap}em, ${t.y/ap}em) `,c+=`scale(${t.size/ap*(t.flipX?-1:1)}, ${t.size/ap*(t.flipY?-1:1)}) `,c+=`rotate(${t.rotate}deg) `,c}var vp=`:root, :host {
  --fa-font-solid: normal 900 1em/1 'Font Awesome 7 Free';
  --fa-font-regular: normal 400 1em/1 'Font Awesome 7 Free';
  --fa-font-light: normal 300 1em/1 'Font Awesome 7 Pro';
  --fa-font-thin: normal 100 1em/1 'Font Awesome 7 Pro';
  --fa-font-duotone: normal 900 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-regular: normal 400 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-light: normal 300 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-thin: normal 100 1em/1 'Font Awesome 7 Duotone';
  --fa-font-brands: normal 400 1em/1 'Font Awesome 7 Brands';
  --fa-font-sharp-solid: normal 900 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-regular: normal 400 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-light: normal 300 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-thin: normal 100 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-duotone-solid: normal 900 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-regular: normal 400 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-light: normal 300 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-thin: normal 100 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-slab-regular: normal 400 1em/1 'Font Awesome 7 Slab';
  --fa-font-slab-press-regular: normal 400 1em/1 'Font Awesome 7 Slab Press';
  --fa-font-slab-duo-regular: normal 400 1em/1 'Font Awesome 7 Slab Duo';
  --fa-font-slab-press-duo-regular: normal 400 1em/1 'Font Awesome 7 Slab Press Duo';
  --fa-font-pixel-regular: normal 400 1em/1 'Font Awesome 7 Pixel';
  --fa-font-mosaic-solid: normal 900 1em/1 'Font Awesome 7 Mosaic';
  --fa-font-vellum-solid: normal 900 1em/1 'Font Awesome 7 Vellum';
  --fa-font-whiteboard-semibold: normal 600 1em/1 'Font Awesome 7 Whiteboard';
  --fa-font-thumbprint-light: normal 300 1em/1 'Font Awesome 7 Thumbprint';
  --fa-font-notdog-solid: normal 900 1em/1 'Font Awesome 7 Notdog';
  --fa-font-notdog-duo-solid: normal 900 1em/1 'Font Awesome 7 Notdog Duo';
  --fa-font-etch-solid: normal 900 1em/1 'Font Awesome 7 Etch';
  --fa-font-graphite-thin: normal 100 1em/1 'Font Awesome 7 Graphite';
  --fa-font-jelly-regular: normal 400 1em/1 'Font Awesome 7 Jelly';
  --fa-font-jelly-fill-regular: normal 400 1em/1 'Font Awesome 7 Jelly Fill';
  --fa-font-jelly-duo-regular: normal 400 1em/1 'Font Awesome 7 Jelly Duo';
  --fa-font-chisel-regular: normal 400 1em/1 'Font Awesome 7 Chisel';
  --fa-font-utility-semibold: normal 600 1em/1 'Font Awesome 7 Utility';
  --fa-font-utility-duo-semibold: normal 600 1em/1 'Font Awesome 7 Utility Duo';
  --fa-font-utility-fill-semibold: normal 600 1em/1 'Font Awesome 7 Utility Fill';
}

.svg-inline--fa {
  box-sizing: content-box;
  display: var(--fa-display, inline-block);
  height: 1em;
  overflow: visible;
  vertical-align: -0.125em;
  width: var(--fa-width, 1.25em);
}
.svg-inline--fa.fa-2xs {
  vertical-align: 0.1em;
}
.svg-inline--fa.fa-xs {
  vertical-align: 0em;
}
.svg-inline--fa.fa-sm {
  vertical-align: -0.0714285714em;
}
.svg-inline--fa.fa-lg {
  vertical-align: -0.2em;
}
.svg-inline--fa.fa-xl {
  vertical-align: -0.25em;
}
.svg-inline--fa.fa-2xl {
  vertical-align: -0.3125em;
}
.svg-inline--fa.fa-pull-left,
.svg-inline--fa .fa-pull-start {
  float: inline-start;
  margin-inline-end: var(--fa-pull-margin, 0.3em);
}
.svg-inline--fa.fa-pull-right,
.svg-inline--fa .fa-pull-end {
  float: inline-end;
  margin-inline-start: var(--fa-pull-margin, 0.3em);
}
.svg-inline--fa.fa-li {
  width: var(--fa-li-width, 2em);
  inset-inline-start: calc(-1 * var(--fa-li-width, 2em));
  inset-block-start: 0.25em; /* syncing vertical alignment with Web Font rendering */
}

.fa-layers-counter, .fa-layers-text {
  display: inline-block;
  position: absolute;
  text-align: center;
}

.fa-layers {
  display: inline-block;
  height: 1em;
  position: relative;
  text-align: center;
  vertical-align: -0.125em;
  width: var(--fa-width, 1.25em);
}
.fa-layers .svg-inline--fa {
  inset: 0;
  margin: auto;
  position: absolute;
  transform-origin: center center;
}

.fa-layers-text {
  left: 50%;
  top: 50%;
  transform: translate(-50%, -50%);
  transform-origin: center center;
}

.fa-layers-counter {
  background-color: var(--fa-counter-background-color, #ff253a);
  border-radius: var(--fa-counter-border-radius, 1em);
  box-sizing: border-box;
  color: var(--fa-inverse, #fff);
  line-height: var(--fa-counter-line-height, 1);
  max-width: var(--fa-counter-max-width, 5em);
  min-width: var(--fa-counter-min-width, 1.5em);
  overflow: hidden;
  padding: var(--fa-counter-padding, 0.25em 0.5em);
  right: var(--fa-right, 0);
  text-overflow: ellipsis;
  top: var(--fa-top, 0);
  transform: scale(var(--fa-counter-scale, 0.25));
  transform-origin: top right;
}

.fa-layers-bottom-right {
  bottom: var(--fa-bottom, 0);
  right: var(--fa-right, 0);
  top: auto;
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: bottom right;
}

.fa-layers-bottom-left {
  bottom: var(--fa-bottom, 0);
  left: var(--fa-left, 0);
  right: auto;
  top: auto;
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: bottom left;
}

.fa-layers-top-right {
  top: var(--fa-top, 0);
  right: var(--fa-right, 0);
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: top right;
}

.fa-layers-top-left {
  left: var(--fa-left, 0);
  right: auto;
  top: var(--fa-top, 0);
  transform: scale(var(--fa-layers-scale, 0.25));
  transform-origin: top left;
}

.fa-1x {
  font-size: 1em;
}

.fa-2x {
  font-size: 2em;
}

.fa-3x {
  font-size: 3em;
}

.fa-4x {
  font-size: 4em;
}

.fa-5x {
  font-size: 5em;
}

.fa-6x {
  font-size: 6em;
}

.fa-7x {
  font-size: 7em;
}

.fa-8x {
  font-size: 8em;
}

.fa-9x {
  font-size: 9em;
}

.fa-10x {
  font-size: 10em;
}

.fa-2xs {
  font-size: calc(10 / 16 * 1em); /* converts a 10px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 10 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 10 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-xs {
  font-size: calc(12 / 16 * 1em); /* converts a 12px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 12 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 12 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-sm {
  font-size: calc(14 / 16 * 1em); /* converts a 14px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 14 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 14 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-lg {
  font-size: calc(20 / 16 * 1em); /* converts a 20px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 20 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 20 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-xl {
  font-size: calc(24 / 16 * 1em); /* converts a 24px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 24 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 24 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-2xl {
  font-size: calc(32 / 16 * 1em); /* converts a 32px size into an em-based value that's relative to the scale's 16px base */
  line-height: calc(1 / 32 * 1em); /* sets the line-height of the icon back to that of it's parent */
  vertical-align: calc((6 / 32 - 0.375) * 1em); /* vertically centers the icon taking into account the surrounding text's descender */
}

.fa-width-auto {
  --fa-width: auto;
}

.fa-fw,
.fa-width-fixed {
  --fa-width: 1.25em;
}

.fa-canvas-square {
  padding-block: 0.125em;
  margin-block-end: -0.125em;
}

.fa-canvas-roomy {
  padding-block: 0.25em;
  padding-inline: 0.125em;
  margin-block-end: -0.25em;
  box-sizing: content-box;
}

.fa-ul {
  list-style-type: none;
  margin-inline-start: var(--fa-li-margin, 2.5em);
  padding-inline-start: 0;
}
.fa-ul > li {
  position: relative;
}

.fa-li {
  inset-inline-start: calc(-1 * var(--fa-li-width, 2em));
  position: absolute;
  text-align: center;
  width: var(--fa-li-width, 2em);
  line-height: inherit;
}

/* Heads Up: Bordered Icons will not be supported in the future!
  - This feature will be deprecated in the next major release of Font Awesome (v8)!
  - You may continue to use it in this version *v7), but it will not be supported in Font Awesome v8.
*/
/* Notes:
* --@{v.$css-prefix}-border-width = 1/16 by default (to render as ~1px based on a 16px default font-size)
* --@{v.$css-prefix}-border-padding =
  ** 3/16 for vertical padding (to give ~2px of vertical whitespace around an icon considering it's vertical alignment)
  ** 4/16 for horizontal padding (to give ~4px of horizontal whitespace around an icon)
*/
.fa-border {
  border-color: var(--fa-border-color, #eee);
  border-radius: var(--fa-border-radius, 0.1em);
  border-style: var(--fa-border-style, solid);
  border-width: var(--fa-border-width, 0.0625em);
  box-sizing: var(--fa-border-box-sizing, content-box);
  padding: var(--fa-border-padding, 0.1875em 0.25em);
}

.fa-pull-left,
.fa-pull-start {
  float: inline-start;
  margin-inline-end: var(--fa-pull-margin, 0.3em);
}

.fa-pull-right,
.fa-pull-end {
  float: inline-end;
  margin-inline-start: var(--fa-pull-margin, 0.3em);
}

.fa-beat {
  animation-name: fa-beat;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-bounce {
  animation-name: fa-bounce;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, cubic-bezier(0.28, 0.84, 0.42, 1));
}

.fa-fade {
  animation-name: fa-fade;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-beat-fade {
  animation-name: fa-beat-fade;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-flip {
  animation-name: fa-flip;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1.5s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-flip-360 {
  animation-name: fa-flip-360;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-shake {
  animation-name: fa-shake;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.75s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
}

.fa-spin {
  animation-name: fa-spin;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 2s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-reverse {
  --fa-animation-direction: reverse;
}

.fa-pulse,
.fa-spin-pulse {
  animation-name: fa-spin;
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, steps(8));
}

.fa-spin-snap {
  animation-name: fa-spin-snap;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 3s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-snap-4 {
  animation-name: fa-spin-snap-4;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 2.4s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-spin-snap-8 {
  animation-name: fa-spin-snap-8;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 4s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-buzz {
  animation-name: fa-buzz;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.6s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, linear);
}

.fa-wag {
  animation-name: fa-wag;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.9s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
  transform-origin: bottom center;
}

.fa-float {
  animation-name: fa-float;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 3s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-in-out);
  will-change: transform;
}

.fa-swing {
  animation-name: fa-swing;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 1.2s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
  transform-origin: top center;
}

.fa-jello {
  animation-name: fa-jello;
  animation-delay: var(--fa-animation-delay, 0s);
  animation-direction: var(--fa-animation-direction, normal);
  animation-duration: var(--fa-animation-duration, 0.9s);
  animation-iteration-count: var(--fa-animation-iteration-count, infinite);
  animation-timing-function: var(--fa-animation-timing, ease-out);
}

@media (prefers-reduced-motion: reduce) {
  .fa-beat,
  .fa-bounce,
  .fa-fade,
  .fa-beat-fade,
  .fa-flip,
  .fa-flip-360,
  .fa-pulse,
  .fa-shake,
  .fa-spin,
  .fa-spin-pulse,
  .fa-buzz,
  .fa-float,
  .fa-jello,
  .fa-spin-snap,
  .fa-spin-snap-4,
  .fa-spin-snap-8,
  .fa-swing,
  .fa-wag {
    animation: none !important;
    transition: none !important;
  }
}
@keyframes fa-beat {
  0% {
    transform: scale(1);
  }
  25% {
    transform: scale(calc(1.25 * var(--fa-beat-scale, 1.25)));
  }
  45% {
    transform: scale(calc(1.22 * var(--fa-beat-scale, 1.22)));
  }
  65% {
    transform: scale(calc(1.25 * var(--fa-beat-scale, 1.25)));
  }
  90% {
    transform: scale(1);
  }
}
@keyframes fa-bounce {
  0% {
    transform: scale(1, 1) translateY(0);
    animation-timing-function: var(--fa-animation-timing);
  }
  14% {
    transform: scale(var(--fa-bounce-start-scale-x, 1.06), var(--fa-bounce-start-scale-y, 0.94)) translateY(var(--fa-bounce-anticipation, 3px));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  32% {
    transform: scale(var(--fa-bounce-jump-scale-x, 0.94), var(--fa-bounce-jump-scale-y, 1.12)) translateY(calc(-1 * var(--fa-bounce-height, 0.5em)));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  52% {
    transform: scale(1, 1) translateY(calc(-1 * var(--fa-bounce-height, 0.5em) * 1.1));
    animation-timing-function: cubic-bezier(0.5, 0, 1, 0.5);
  }
  70% {
    transform: scale(var(--fa-bounce-land-scale-x, 1.06), var(--fa-bounce-land-scale-y, 0.92)) translateY(0);
    animation-timing-function: cubic-bezier(0.33, 0.33, 0.66, 1);
  }
  85% {
    transform: scale(0.98, 1.04) translateY(calc(-2px * var(--fa-bounce-rebound, 1)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: scale(1, 1) translateY(0);
  }
}
@keyframes fa-fade {
  0% {
    opacity: 1;
    transform: scale(1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  40% {
    opacity: var(--fa-fade-opacity, 0.4);
    transform: scale(0.98);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  100% {
    opacity: 1;
    transform: scale(1);
  }
}
@keyframes fa-beat-fade {
  0% {
    opacity: var(--fa-beat-fade-opacity, 0.4);
    transform: scale(1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  25% {
    opacity: calc(var(--fa-beat-fade-opacity, 0.4) + 0.4);
    transform: scale(var(--fa-beat-fade-scale, 1.28));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  45% {
    opacity: 1;
    transform: scale(var(--fa-beat-fade-scale, 1.25));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  65% {
    opacity: calc(var(--fa-beat-fade-opacity, 0.4) + 0.4);
    transform: scale(var(--fa-beat-fade-scale, 1.28));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  100% {
    opacity: var(--fa-beat-fade-opacity, 0.4);
    transform: scale(1);
  }
}
@keyframes fa-flip {
  0% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  8% {
    transform: perspective(2em) scale(var(--fa-flip-anticipation-scale, 0.95)) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  35% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.6));
    animation-timing-function: linear;
  }
  65% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.5));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  92% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * var(--fa-flip-overshoot, 1.04)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), var(--fa-flip-angle, -360deg));
  }
}
@keyframes fa-flip-360 {
  0% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.4, 1);
  }
  8% {
    transform: perspective(2em) scale(var(--fa-flip-anticipation-scale, 0.95)) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), 0deg);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  50% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * 0.6));
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  80% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), calc(var(--fa-flip-angle, -360deg) * var(--fa-flip-overshoot, 1.04)));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: perspective(2em) scale(1) rotate3d(var(--fa-flip-x, 0), var(--fa-flip-y, 1), var(--fa-flip-z, 0), var(--fa-flip-angle, -360deg));
  }
}
@keyframes fa-shake {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  8% {
    transform: rotate(35deg) translateX(1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  20% {
    transform: rotate(-22deg) translateX(-1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  35% {
    transform: rotate(15deg) translateX(1px);
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  50% {
    transform: rotate(-9deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  65% {
    transform: rotate(5deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  78% {
    transform: rotate(-3deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  90% {
    transform: rotate(1deg);
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-spin {
  0% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  12% {
    transform: rotate(60deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  16.67% {
    transform: rotate(60deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  28.67% {
    transform: rotate(120deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  33.33% {
    transform: rotate(120deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  45.33% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  62% {
    transform: rotate(240deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  66.67% {
    transform: rotate(240deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  78.67% {
    transform: rotate(300deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  83.33% {
    transform: rotate(300deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  95.33% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap-4 {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  15% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  25% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  40% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  65% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  75% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  90% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-spin-snap-8 {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  9% {
    transform: rotate(45deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  12.5% {
    transform: rotate(45deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  21.5% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  25% {
    transform: rotate(90deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  34% {
    transform: rotate(135deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  37.5% {
    transform: rotate(135deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  46.5% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  50% {
    transform: rotate(180deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  59% {
    transform: rotate(225deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  62.5% {
    transform: rotate(225deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  71.5% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  75% {
    transform: rotate(270deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  84% {
    transform: rotate(315deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  87.5% {
    transform: rotate(315deg);
    animation-timing-function: cubic-bezier(0, 0, 0.2, 1);
  }
  96.5% {
    transform: rotate(360deg);
    animation-timing-function: cubic-bezier(0.8, 0, 1, 1);
  }
  100% {
    transform: rotate(360deg);
  }
}
@keyframes fa-buzz {
  0% {
    transform: translateX(0) rotate(0deg);
    animation-timing-function: cubic-bezier(0.1, 0, 0.9, 1);
  }
  5% {
    transform: translateX(var(--fa-buzz-distance, 4px)) rotate(0.5deg);
  }
  10% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px))) rotate(-0.5deg);
  }
  15% {
    transform: translateX(var(--fa-buzz-distance, 4px)) rotate(0.3deg);
  }
  20% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px))) rotate(-0.3deg);
  }
  25% {
    transform: translateX(calc(var(--fa-buzz-distance, 4px) * 0.7)) rotate(0.2deg);
  }
  30% {
    transform: translateX(calc(-1 * var(--fa-buzz-distance, 4px) * 0.7)) rotate(-0.2deg);
  }
  35% {
    transform: translateX(calc(var(--fa-buzz-distance, 4px) * 0.4)) rotate(0.1deg);
  }
  40% {
    transform: translateX(0) rotate(0deg);
  }
  100% {
    transform: translateX(0) rotate(0deg);
  }
}
@keyframes fa-wag {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  12% {
    transform: rotate(var(--fa-wag-angle, 12deg));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  24% {
    transform: rotate(2deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  36% {
    transform: rotate(calc(var(--fa-wag-angle, 12deg) * 0.85));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  48% {
    transform: rotate(1deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.6, 1);
  }
  58% {
    transform: rotate(calc(var(--fa-wag-angle, 12deg) * 0.6));
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  68% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-float {
  0% {
    transform: translateY(0) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  15% {
    transform: translateY(calc(-0.4 * var(--fa-float-height, 6px))) translateX(var(--fa-float-drift, 1px)) rotate(var(--fa-float-tilt, 1deg)) scale(1, 1);
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  35% {
    transform: translateY(calc(-1 * var(--fa-float-height, 6px))) translateX(0) rotate(0deg) scale(var(--fa-float-stretch-x, 0.98), var(--fa-float-stretch-y, 1.03));
    animation-timing-function: cubic-bezier(0.5, 0, 0.5, 0);
  }
  50% {
    transform: translateY(calc(-0.92 * var(--fa-float-height, 6px))) translateX(calc(-0.5 * var(--fa-float-drift, 1px))) rotate(calc(-0.5 * var(--fa-float-tilt, 1deg))) scale(0.995, 1.01);
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 0.33);
  }
  70% {
    transform: translateY(calc(-0.3 * var(--fa-float-height, 6px))) translateX(calc(-1 * var(--fa-float-drift, 1px))) rotate(calc(-1 * var(--fa-float-tilt, 1deg))) scale(1, 1);
    animation-timing-function: cubic-bezier(0.33, 0.66, 0.66, 1);
  }
  90% {
    transform: translateY(calc(0.05 * var(--fa-float-height, 6px))) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
    animation-timing-function: cubic-bezier(0.33, 0, 0.66, 1);
  }
  100% {
    transform: translateY(0) translateX(0) rotate(0deg) scale(var(--fa-float-squash-x, 1.02), var(--fa-float-squash-y, 0.98));
  }
}
@keyframes fa-swing {
  0% {
    transform: rotate(0deg);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  8% {
    transform: rotate(var(--fa-swing-angle, 22deg));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  18% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.85));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  28% {
    transform: rotate(calc(var(--fa-swing-angle, 22deg) * 0.65));
    animation-timing-function: cubic-bezier(0.35, 0, 0.65, 1);
  }
  38% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.45));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  48% {
    transform: rotate(calc(var(--fa-swing-angle, 22deg) * 0.25));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  56% {
    transform: rotate(calc(-1 * var(--fa-swing-angle, 22deg) * 0.1));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  64% {
    transform: rotate(0deg);
  }
  100% {
    transform: rotate(0deg);
  }
}
@keyframes fa-jello {
  0% {
    transform: scale(1, 1);
    animation-timing-function: cubic-bezier(0.2, 0, 0.8, 1);
  }
  12% {
    transform: scale(var(--fa-jello-scale-x, 1.15), calc(2 - var(--fa-jello-scale-x, 1.15)));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  24% {
    transform: scale(calc(2 - var(--fa-jello-scale-y, 1.12)), var(--fa-jello-scale-y, 1.12));
    animation-timing-function: cubic-bezier(0.3, 0, 0.7, 1);
  }
  36% {
    transform: scale(calc(1 + (var(--fa-jello-scale-x, 1.15) - 1) * 0.5), calc(2 - (1 + (var(--fa-jello-scale-x, 1.15) - 1) * 0.5)));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  48% {
    transform: scale(calc(2 - (1 + (var(--fa-jello-scale-y, 1.12) - 1) * 0.3)), calc(1 + (var(--fa-jello-scale-y, 1.12) - 1) * 0.3));
    animation-timing-function: cubic-bezier(0.4, 0, 0.6, 1);
  }
  58% {
    transform: scale(1.02, 0.98);
    animation-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
  }
  68% {
    transform: scale(1, 1);
  }
  100% {
    transform: scale(1, 1);
  }
}
.fa-rotate-90 {
  transform: rotate(90deg);
}

.fa-rotate-180 {
  transform: rotate(180deg);
}

.fa-rotate-270 {
  transform: rotate(270deg);
}

.fa-flip-horizontal {
  transform: scale(-1, 1);
}

.fa-flip-vertical {
  transform: scale(1, -1);
}

.fa-flip-both,
.fa-flip-horizontal.fa-flip-vertical {
  transform: scale(-1, -1);
}

.fa-rotate-by {
  transform: rotate(var(--fa-rotate-angle, 0));
}

.svg-inline--fa .fa-primary {
  fill: var(--fa-primary-color, currentColor);
  opacity: var(--fa-primary-opacity, 1);
}

.svg-inline--fa .fa-secondary {
  fill: var(--fa-secondary-color, currentColor);
  opacity: var(--fa-secondary-opacity, 0.4);
}

.svg-inline--fa.fa-swap-opacity .fa-primary {
  opacity: var(--fa-secondary-opacity, 0.4);
}

.svg-inline--fa.fa-swap-opacity .fa-secondary {
  opacity: var(--fa-primary-opacity, 1);
}

.svg-inline--fa mask .fa-primary,
.svg-inline--fa mask .fa-secondary {
  fill: black;
}

.svg-inline--fa.fa-inverse {
  fill: var(--fa-inverse, #fff);
}

.fa-stack {
  display: inline-block;
  height: 2em;
  line-height: 2em;
  position: relative;
  vertical-align: middle;
  width: 2.5em;
}

.fa-inverse {
  color: var(--fa-inverse, #fff);
}

.svg-inline--fa.fa-stack-1x {
  --fa-width: 1.25em;
  height: 1em;
  width: var(--fa-width);
}
.svg-inline--fa.fa-stack-2x {
  --fa-width: 2.5em;
  height: 2em;
  width: var(--fa-width);
}

.fa-stack-1x,
.fa-stack-2x {
  inset: 0;
  margin: auto;
  position: absolute;
  z-index: var(--fa-stack-z-index, auto);
}`;function yp(){var e=Ef,t=Df,n=J.cssPrefix,r=J.replacementClass,i=vp;if(n!==e||r!==t){var a=RegExp(`\\.${e}\\-`,`g`),o=RegExp(`\\--${e}\\-`,`g`),s=RegExp(`\\.${t}`,`g`);i=i.replace(a,`.${n}-`).replace(o,`--${n}-`).replace(s,`.${r}`)}return i}var bp=!1;function xp(){J.autoAddCss&&!bp&&(sp(yp()),bp=!0)}var Sp={mixout:function(){return{dom:{css:yp,insertCss:xp}}},hooks:function(){return{beforeDOMElementCreation:function(){xp()},beforeI2svg:function(){xp()}}}},Cp=qu||{};Cp[wf]||(Cp[wf]={}),Cp[wf].styles||(Cp[wf].styles={}),Cp[wf].hooks||(Cp[wf].hooks={}),Cp[wf].shims||(Cp[wf].shims=[]);var wp=Cp[wf],Tp=[],Ep=function(){Ju.removeEventListener(`DOMContentLoaded`,Ep),Dp=1,Tp.map(function(e){return e()})},Dp=!1;Zu&&(Dp=(Ju.documentElement.doScroll?/^loaded|^c/:/^loaded|^i|^c/).test(Ju.readyState),Dp||Ju.addEventListener(`DOMContentLoaded`,Ep));function Op(e){Zu&&(Dp?setTimeout(e,0):Tp.push(e))}function kp(e){var t=e.tag,n=e.attributes,r=n===void 0?{}:n,i=e.children,a=i===void 0?[]:i;return typeof e==`string`?fp(e):`<${t} ${pp(r)}>${a.map(kp).join(``)}</${t}>`}function Ap(e,t,n){if(e&&e[t]&&e[t][n])return{prefix:t,iconName:n,icon:e[t][n]}}var jp=function(e,t){return function(n,r,i,a){return e.call(t,n,r,i,a)}},Mp=function(e,t,n,r){var i=Object.keys(e),a=i.length,o=r===void 0?t:jp(t,r),s,c,l;for(n===void 0?(s=1,l=e[i[0]]):(s=0,l=n);s<a;s++)c=i[s],l=o(l,e[c],c,e);return l};function Np(e){return Fu(e).length===1?e.codePointAt(0).toString(16):null}function Pp(e){return Object.keys(e).reduce(function(t,n){var r=e[n];return r.icon?t[r.iconName]=r.icon:t[n]=r,t},{})}function Fp(e,t){var n=(arguments.length>2&&arguments[2]!==void 0?arguments[2]:{}).skipHooks,r=n!==void 0&&n,i=Pp(t);typeof wp.hooks.addPack==`function`&&!r?wp.hooks.addPack(e,Pp(t)):wp.styles[e]=q(q({},wp.styles[e]||{}),i),e===`fas`&&Fp(`fa`,t)}var Ip=wp.styles,Lp=wp.shims,Rp=Object.keys(Wf),zp=Rp.reduce(function(e,t){return e[t]=Object.keys(Wf[t]),e},{}),Bp=null,Vp={},Hp={},Up={},Wp={},Gp={};function Kp(e){return~Zf.indexOf(e)}function qp(e,t){var n=t.split(`-`),r=n[0],i=n.slice(1).join(`-`);return r===e&&i!==``&&!Kp(i)?i:null}var Jp=function(){var e=function(e){return Mp(Ip,function(t,n,r){return t[r]=Mp(n,e,{}),t},{})};Vp=e(function(e,t,n){return t[3]&&(e[t[3]]=n),t[2]&&t[2].filter(function(e){return typeof e==`number`}).forEach(function(t){e[t.toString(16)]=n}),e}),Hp=e(function(e,t,n){return e[n]=n,t[2]&&t[2].filter(function(e){return typeof e==`string`}).forEach(function(t){e[t]=n}),e}),Gp=e(function(e,t,n){var r=t[2];return e[n]=n,r.forEach(function(t){e[t]=n}),e});var t=`far`in Ip||J.autoFetchSvg,n=Mp(Lp,function(e,n){var r=n[0],i=n[1],a=n[2];return i===`far`&&!t&&(i=`fas`),typeof r==`string`&&(e.names[r]={prefix:i,iconName:a}),typeof r==`number`&&(e.unicodes[r.toString(16)]={prefix:i,iconName:a}),e},{names:{},unicodes:{}});Up=n.names,Wp=n.unicodes,Bp=rm(J.styleDefault,{family:J.familyDefault})};ip(function(e){Bp=rm(e.styleDefault,{family:J.familyDefault})}),Jp();function Yp(e,t){return(Vp[e]||{})[t]}function Xp(e,t){return(Hp[e]||{})[t]}function Zp(e,t){return(Gp[e]||{})[t]}function Qp(e){return Up[e]||{prefix:null,iconName:null}}function $p(e){var t=Wp[e],n=Yp(`fas`,e);return t||(n?{prefix:`fas`,iconName:n}:null)||{prefix:null,iconName:null}}function em(){return Bp}var tm=function(){return{prefix:null,iconName:null,rest:[]}};function nm(e){var t=ad,n=Rp.reduce(function(e,t){return e[t]=`${J.cssPrefix}-${t}`,e},{});return $d.forEach(function(r){(e.includes(n[r])||e.some(function(e){return zp[r].includes(e)}))&&(t=r)}),t}function rm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).family,n=t===void 0?ad:t,r=Bf[n][e];if(n===od&&!e)return`fad`;var i=Hf[n][e]||Hf[n][r],a=e in wp.styles?e:null;return i||a||null}function im(e){var t=[],n=null;return e.forEach(function(e){var r=qp(J.cssPrefix,e);r?n=r:e&&t.push(e)}),{iconName:n,rest:t}}function am(e){return e.sort().filter(function(e,t,n){return n.indexOf(e)===t})}var om=vf.concat(af);function sm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).skipLookups,n=t!==void 0&&t,r=null,i=am(e.filter(function(e){return om.includes(e)})),a=am(e.filter(function(e){return!om.includes(e)})),o=Pu(i.filter(function(e){return r=e,!id.includes(e)}),1)[0],s=o===void 0?null:o,c=nm(i),l=q(q({},im(a)),{},{prefix:rm(s,{family:c})});return q(q(q({},l),dm({values:e,family:c,styles:Ip,config:J,canonical:l,givenPrefix:r})),cm(n,r,l))}function cm(e,t,n){var r=n.prefix,i=n.iconName;if(e||!r||!i)return{prefix:r,iconName:i};var a=t===`fa`?Qp(i):{},o=Zp(r,i);return i=a.iconName||o||i,r=a.prefix||r,r===`far`&&!Ip.far&&Ip.fas&&!J.autoFetchSvg&&(r=`fas`),{prefix:r,iconName:i}}var lm=$d.filter(function(e){return e!==ad||e!==od}),um=Object.keys(_f).filter(function(e){return e!==ad}).map(function(e){return Object.keys(_f[e])}).flat();function dm(e){var t=e.values,n=e.family,r=e.canonical,i=e.givenPrefix,a=i===void 0?``:i,o=e.styles,s=o===void 0?{}:o,c=e.config,l=c===void 0?{}:c,u=n===od,d=t.includes(`fa-duotone`)||t.includes(`fad`),f=l.familyDefault===`duotone`,p=r.prefix===`fad`||r.prefix===`fa-duotone`;return!u&&(d||f||p)&&(r.prefix=`fad`),(t.includes(`fa-brands`)||t.includes(`fab`))&&(r.prefix=`fab`),!r.prefix&&lm.includes(n)&&(Object.keys(s).find(function(e){return um.includes(e)})||l.autoFetchSvg)&&(r.prefix=nf.get(n).defaultShortPrefixId,r.iconName=Zp(r.prefix,r.iconName)||r.iconName),(r.prefix===`fa`||a===`fa`)&&(r.prefix=em()||`fas`),r}var fm=function(){function e(){Tu(this,e),this.definitions={}}return Du(e,[{key:`add`,value:function(){var e=this,t=[...arguments].reduce(this._pullDefinitions,{});Object.keys(t).forEach(function(n){e.definitions[n]=q(q({},e.definitions[n]||{}),t[n]),Fp(n,t[n]);var r=Wf[ad][n];r&&Fp(r,t[n]),Jp()})}},{key:`reset`,value:function(){this.definitions={}}},{key:`_pullDefinitions`,value:function(e,t){var n=t.prefix&&t.iconName&&t.icon?{0:t}:t;return Object.keys(n).map(function(t){var r=n[t],i=r.prefix,a=r.iconName,o=r.icon,s=o[2];e[i]||(e[i]={}),s.length>0&&s.forEach(function(t){typeof t==`string`&&(e[i][t]=o)}),e[i][a]=o}),e}}])}(),pm=[],mm={},hm={},gm=Object.keys(hm);function _m(e,t){var n=t.mixoutsTo;return pm=e,mm={},Object.keys(hm).forEach(function(e){gm.indexOf(e)===-1&&delete hm[e]}),pm.forEach(function(e){var t=e.mixout?e.mixout():{};if(Object.keys(t).forEach(function(e){typeof t[e]==`function`&&(n[e]=t[e]),Ru(t[e])===`object`&&Object.keys(t[e]).forEach(function(r){n[e]||(n[e]={}),n[e][r]=t[e][r]})}),e.hooks){var r=e.hooks();Object.keys(r).forEach(function(e){mm[e]||(mm[e]=[]),mm[e].push(r[e])})}e.provides&&e.provides(hm)}),n}function vm(e,t){var n=[...arguments].slice(2);return(mm[e]||[]).forEach(function(e){t=e.apply(null,[t].concat(n))}),t}function ym(e){var t=[...arguments].slice(1);(mm[e]||[]).forEach(function(e){e.apply(null,t)})}function bm(){var e=arguments[0],t=Array.prototype.slice.call(arguments,1);return hm[e]?hm[e].apply(null,t):void 0}function xm(e){e.prefix===`fa`&&(e.prefix=`fas`);var t=e.iconName,n=e.prefix||em();if(t)return t=Zp(n,t)||t,Ap(Sm.definitions,n,t)||Ap(wp.styles,n,t)}var Sm=new fm,Cm={noAuto:function(){J.autoReplaceSvg=!1,J.observeMutations=!1,ym(`noAuto`)},config:J,dom:{i2svg:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return Zu?(ym(`beforeI2svg`,e),bm(`pseudoElements2svg`,e),bm(`i2svg`,e)):Promise.reject(Error(`Operation requires a DOM of some kind.`))},watch:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},t=e.autoReplaceSvgRoot;J.autoReplaceSvg===!1&&(J.autoReplaceSvg=!0),J.observeMutations=!0,Op(function(){wm({autoReplaceSvgRoot:t}),ym(`watch`,e)})}},parse:{icon:function(e){if(e===null)return null;if(Ru(e)===`object`&&e.prefix&&e.iconName)return{prefix:e.prefix,iconName:Zp(e.prefix,e.iconName)||e.iconName};if(Array.isArray(e)&&e.length===2){var t=e[1].indexOf(`fa-`)===0?e[1].slice(3):e[1],n=rm(e[0]);return{prefix:n,iconName:Zp(n,t)||t}}if(typeof e==`string`&&(e.indexOf(`${J.cssPrefix}-`)>-1||e.match(Kf))){var r=sm(e.split(` `),{skipLookups:!0});return{prefix:r.prefix||em(),iconName:Zp(r.prefix,r.iconName)||r.iconName}}if(typeof e==`string`){var i=em();return{prefix:i,iconName:Zp(i,e)||e}}}},library:Sm,findIconDefinition:xm,toHtml:kp},wm=function(){var e=(arguments.length>0&&arguments[0]!==void 0?arguments[0]:{}).autoReplaceSvgRoot,t=e===void 0?Ju:e;(Object.keys(wp.styles).length>0||J.autoFetchSvg)&&Zu&&J.autoReplaceSvg&&Cm.dom.i2svg({node:t})};function Tm(e,t){return Object.defineProperty(e,"abstract",{get:t}),Object.defineProperty(e,"html",{get:function(){return e.abstract.map(function(e){return kp(e)})}}),Object.defineProperty(e,"node",{get:function(){if(Zu){var t=Ju.createElement(`div`);return t.innerHTML=e.html,t.children}}}),e}function Em(e){var t=e.children,n=e.main,r=e.mask,i=e.attributes,a=e.styles,o=e.transform;if(hp(o)&&n.found&&!r.found){var s={x:n.width/n.height/2,y:.5};i.style=mp(q(q({},a),{},{"transform-origin":`${s.x+o.x/16}em ${s.y+o.y/16}em`}))}return[{tag:`svg`,attributes:i,children:t}]}function Dm(e){var t=e.prefix,n=e.iconName,r=e.children,i=e.attributes,a=e.symbol,o=a===!0?`${t}-${J.cssPrefix}-${n}`:a;return[{tag:`svg`,attributes:{style:`display: none;`},children:[{tag:`symbol`,attributes:q(q({},i),{},{id:o}),children:r}]}]}function Om(e){return[`aria-label`,`aria-labelledby`,`title`,`role`].some(function(t){return t in e})}function km(e){var t=e.icons,n=t.main,r=t.mask,i=e.prefix,a=e.iconName,o=e.transform,s=e.symbol,c=e.maskId,l=e.extra,u=e.watchable,d=u!==void 0&&u,f=r.found?r:n,p=f.width,m=f.height,h=[J.replacementClass,a?`${J.cssPrefix}-${a}`:``].filter(function(e){return l.classes.indexOf(e)===-1}).filter(function(e){return e!==``||!!e}).concat(l.classes).join(` `),g={children:[],attributes:q(q({},l.attributes),{},{"data-prefix":i,"data-icon":a,class:h,role:l.attributes.role||`img`,viewBox:`0 0 ${p} ${m}`})};!Om(l.attributes)&&!l.attributes[`aria-hidden`]&&(g.attributes[`aria-hidden`]=`true`),d&&(g.attributes[Of]=``);var _=q(q({},g),{},{prefix:i,iconName:a,main:n,mask:r,maskId:c,transform:o,symbol:s,styles:q({},l.styles)}),v=r.found&&n.found?bm(`generateAbstractMask`,_)||{children:[],attributes:{}}:bm(`generateAbstractIcon`,_)||{children:[],attributes:{}},y=v.children,b=v.attributes;return _.children=y,_.attributes=b,s?Dm(_):Em(_)}function Am(e){var t=e.content,n=e.width,r=e.height,i=e.transform,a=e.extra,o=e.watchable,s=o!==void 0&&o,c=q(q({},a.attributes),{},{class:a.classes.join(` `)});s&&(c[Of]=``);var l=q({},a.styles);hp(i)&&(l.transform=_p({transform:i,startCentered:!0,width:n,height:r}),l[`-webkit-transform`]=l.transform);var u=mp(l);u.length>0&&(c.style=u);var d=[];return d.push({tag:`span`,attributes:c,children:[t]}),d}function jm(e){var t=e.content,n=e.extra,r=q(q({},n.attributes),{},{class:n.classes.join(` `)}),i=mp(n.styles);i.length>0&&(r.style=i);var a=[];return a.push({tag:`span`,attributes:r,children:[t]}),a}var Mm=wp.styles;function Nm(e){var t=e[0],n=e[1],r=Pu(e.slice(4),1)[0],i=null;return i=Array.isArray(r)?{tag:`g`,attributes:{class:`${J.cssPrefix}-${Xf.GROUP}`},children:[{tag:`path`,attributes:{class:`${J.cssPrefix}-${Xf.SECONDARY}`,fill:`currentColor`,d:r[0]}},{tag:`path`,attributes:{class:`${J.cssPrefix}-${Xf.PRIMARY}`,fill:`currentColor`,d:r[1]}}]}:{tag:`path`,attributes:{fill:`currentColor`,d:r}},{found:!0,width:t,height:n,icon:i}}var Pm={found:!1,width:512,height:512};function Fm(e,t){!Lf&&!J.showMissingIcons&&e&&console.error(`Icon with name "${e}" and prefix "${t}" is missing.`)}function Im(e,t){var n=t;return t===`fa`&&J.styleDefault!==null&&(t=em()),new Promise(function(r,i){if(n===`fa`){var a=Qp(e)||{};e=a.iconName||e,t=a.prefix||t}if(e&&t&&Mm[t]&&Mm[t][e]){var o=Mm[t][e];return r(Nm(o))}Fm(e,t),r(q(q({},Pm),{},{icon:J.showMissingIcons&&e&&bm(`missingIconAbstract`)||{}}))})}var Lm=function(){},Rm=J.measurePerformance&&Xu&&Xu.mark&&Xu.measure?Xu:{mark:Lm,measure:Lm},zm=`FA "7.3.1"`,Bm=function(e){return Rm.mark(`${zm} ${e} begins`),function(){return Vm(e)}},Vm=function(e){Rm.mark(`${zm} ${e} ends`),Rm.measure(`${zm} ${e}`,`${zm} ${e} begins`,`${zm} ${e} ends`)},Hm={begin:Bm,end:Vm},Um=function(){};function Wm(e){return typeof(e.getAttribute?e.getAttribute(Of):null)==`string`}function Gm(e){var t=e.getAttribute?e.getAttribute(jf):null,n=e.getAttribute?e.getAttribute(Mf):null;return t&&n}function Km(e){return e&&e.classList&&e.classList.contains&&e.classList.contains(J.replacementClass)}function qm(){return J.autoReplaceSvg===!0?Qm.replace:Qm[J.autoReplaceSvg]||Qm.replace}function Jm(e){return Ju.createElementNS(`http://www.w3.org/2000/svg`,e)}function Ym(e){return Ju.createElement(e)}function Xm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).ceFn,n=t===void 0?e.tag===`svg`?Jm:Ym:t;if(typeof e==`string`)return Ju.createTextNode(e);var r=n(e.tag);return Object.keys(e.attributes||[]).forEach(function(t){r.setAttribute(t,e.attributes[t])}),(e.children||[]).forEach(function(e){r.appendChild(Xm(e,{ceFn:n}))}),r}function Zm(e){var t=` ${e.outerHTML} `;return t=`${t}Font Awesome fontawesome.com `,t}var Qm={replace:function(e){var t=e[0];if(t.parentNode){if(e[1].forEach(function(e){t.parentNode.insertBefore(Xm(e),t)}),t.getAttribute(Of)===null&&J.keepOriginalSource){var n=Ju.createComment(Zm(t));t.parentNode.replaceChild(n,t)}else t.remove()}},nest:function(e){var t=e[0],n=e[1];if(~dp(t).indexOf(J.replacementClass))return Qm.replace(e);var r=RegExp(`${J.cssPrefix}-.*`);if(delete n[0].attributes.id,n[0].attributes.class){var i=n[0].attributes.class.split(` `).reduce(function(e,t){return t===J.replacementClass||t.match(r)?e.toSvg.push(t):e.toNode.push(t),e},{toNode:[],toSvg:[]});n[0].attributes.class=i.toSvg.join(` `),i.toNode.length===0?t.removeAttribute(`class`):t.setAttribute(`class`,i.toNode.join(` `))}var a=n.map(function(e){return kp(e)}).join(`
`);t.setAttribute(Of,``),t.innerHTML=a}};function $m(e){e()}function eh(e,t){var n=typeof t==`function`?t:Um;if(e.length===0)n();else{var r=$m;J.mutateApproach===Pf&&(r=qu.requestAnimationFrame||$m),r(function(){var t=qm(),r=Hm.begin(`mutate`);e.map(t),r(),n()})}}var th=!1;function nh(){th=!0}function rh(){th=!1}var ih=null;function ah(e){if(Yu&&J.observeMutations){var t=e.treeCallback,n=t===void 0?Um:t,r=e.nodeCallback,i=r===void 0?Um:r,a=e.pseudoElementsCallback,o=a===void 0?Um:a,s=e.observeMutationsRoot,c=s===void 0?Ju:s;ih=new Yu(function(e){if(!th){var t=em();up(e).forEach(function(e){if(e.type===`childList`&&e.addedNodes.length>0&&!Wm(e.addedNodes[0])&&(J.searchPseudoElements&&o(e.target),n(e.target)),e.type===`attributes`&&e.target.parentNode&&J.searchPseudoElements&&o([e.target],!0),e.type===`attributes`&&Wm(e.target)&&~Yf.indexOf(e.attributeName)){if(e.attributeName===`class`&&Gm(e.target)){var r=sm(dp(e.target)),a=r.prefix,s=r.iconName;e.target.setAttribute(jf,a||t),s&&e.target.setAttribute(Mf,s)}else Km(e.target)&&i(e.target)}})}}),Zu&&ih.observe(c,{childList:!0,attributes:!0,characterData:!0,subtree:!0})}}function oh(){ih&&ih.disconnect()}function sh(e){var t=e.getAttribute(`style`),n=[];return t&&(n=t.split(`;`).reduce(function(e,t){var n=t.split(`:`),r=n[0],i=n.slice(1);return r&&i.length>0&&(e[r]=i.join(`:`).trim()),e},{})),n}function ch(e){var t=e.getAttribute(`data-prefix`),n=e.getAttribute(`data-icon`),r=e.innerText===void 0?``:e.innerText.trim(),i=sm(dp(e));return i.prefix||=em(),t&&n&&(i.prefix=t,i.iconName=n),i.iconName&&i.prefix?i:(i.prefix&&r.length>0&&(i.iconName=Xp(i.prefix,e.innerText)||Yp(i.prefix,Np(e.innerText))),!i.iconName&&J.autoFetchSvg&&e.firstChild&&e.firstChild.nodeType===Node.TEXT_NODE&&(i.iconName=e.firstChild.data),i)}function lh(e){return up(e.attributes).reduce(function(e,t){return e.name!==`class`&&e.name!==`style`&&(e[t.name]=t.value),e},{})}function uh(){return{iconName:null,prefix:null,transform:op,symbol:!1,mask:{iconName:null,prefix:null,rest:[]},maskId:null,extra:{classes:[],styles:{},attributes:{}}}}function dh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{styleParser:!0},n=ch(e),r=n.iconName,i=n.prefix,a=n.rest,o=lh(e),s=vm(`parseNodeAttributes`,{},e);return q({iconName:r,prefix:i,transform:op,mask:{iconName:null,prefix:null,rest:[]},maskId:null,symbol:!1,extra:{classes:a,styles:t.styleParser?sh(e):[],attributes:o}},s)}var fh=wp.styles;function ph(e){var t=J.autoReplaceSvg===`nest`?dh(e,{styleParser:!1}):dh(e);return~t.extra.classes.indexOf(qf)?bm(`generateLayersText`,e,t):bm(`generateSvgReplacementMutation`,e,t)}function mh(){return[].concat(Fu(af),Fu(vf))}function hh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(!Zu)return Promise.resolve();var n=Ju.documentElement.classList,r=function(e){return n.add(`${Nf}-${e}`)},i=function(e){return n.remove(`${Nf}-${e}`)},a=J.autoFetchSvg?mh():id.concat(Object.keys(fh));a.includes(`fa`)||a.push(`fa`);var o=[`.${qf}:not([${Of}])`].concat(a.map(function(e){return`.${e}:not([${Of}])`})).join(`, `);if(o.length===0)return Promise.resolve();var s=[];try{s=up(e.querySelectorAll(o))}catch{}if(s.length>0)r(`pending`),i(`complete`);else return Promise.resolve();var c=Hm.begin(`onTree`),l=s.reduce(function(e,t){try{var n=ph(t);n&&e.push(n)}catch(e){Lf||e.name===`MissingIcon`&&console.error(e)}return e},[]);return new Promise(function(e,n){Promise.all(l).then(function(n){eh(n,function(){r(`active`),r(`complete`),i(`pending`),typeof t==`function`&&t(),c(),e()})}).catch(function(e){c(),n(e)})})}function gh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;ph(e).then(function(e){e&&eh([e],t)})}function _h(e){return function(t){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},r=(t||{}).icon?t:xm(t||{}),i=n.mask;return i&&=(i||{}).icon?i:xm(i||{}),e(r,q(q({},n),{},{mask:i}))}}var vh=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?op:n,i=t.symbol,a=i!==void 0&&i,o=t.mask,s=o===void 0?null:o,c=t.maskId,l=c===void 0?null:c,u=t.classes,d=u===void 0?[]:u,f=t.attributes,p=f===void 0?{}:f,m=t.styles,h=m===void 0?{}:m;if(e){var g=e.prefix,_=e.iconName,v=e.icon;return Tm(q({type:`icon`},e),function(){return ym(`beforeDOMElementCreation`,{iconDefinition:e,params:t}),km({icons:{main:Nm(v),mask:s?Nm(s.icon):{found:!1,width:null,height:null,icon:{}}},prefix:g,iconName:_,transform:q(q({},op),r),symbol:a,maskId:l,extra:{attributes:p,styles:h,classes:d}})})}},yh={mixout:function(){return{icon:_h(vh)}},hooks:function(){return{mutationObserverCallbacks:function(e){return e.treeCallback=hh,e.nodeCallback=gh,e}}},provides:function(e){e.i2svg=function(e){var t=e.node,n=t===void 0?Ju:t,r=e.callback;return hh(n,r===void 0?function(){}:r)},e.generateSvgReplacementMutation=function(e,t){var n=t.iconName,r=t.prefix,i=t.transform,a=t.symbol,o=t.mask,s=t.maskId,c=t.extra;return new Promise(function(t,l){Promise.all([Im(n,r),o.iconName?Im(o.iconName,o.prefix):Promise.resolve({found:!1,width:512,height:512,icon:{}})]).then(function(o){var l=Pu(o,2),u=l[0],d=l[1];t([e,km({icons:{main:u,mask:d},prefix:r,iconName:n,transform:i,symbol:a,maskId:s,extra:c,watchable:!0})])}).catch(l)})},e.generateAbstractIcon=function(e){var t=e.children,n=e.attributes,r=e.main,i=e.transform,a=e.styles,o=mp(a);o.length>0&&(n.style=o);var s;return hp(i)&&(s=bm(`generateAbstractTransformGrouping`,{main:r,transform:i,containerWidth:r.width,iconWidth:r.width})),t.push(s||r.icon),{children:t,attributes:n}}}},bh={mixout:function(){return{layer:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.classes,r=n===void 0?[]:n;return Tm({type:`layer`},function(){ym(`beforeDOMElementCreation`,{assembler:e,params:t});var n=[];return e(function(e){Array.isArray(e)?e.map(function(e){n=n.concat(e.abstract)}):n=n.concat(e.abstract)}),[{tag:`span`,attributes:{class:[`${J.cssPrefix}-layers`].concat(Fu(r)).join(` `)},children:n}]})}}}},xh={mixout:function(){return{counter:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.title,r=n===void 0?null:n,i=t.classes,a=i===void 0?[]:i,o=t.attributes,s=o===void 0?{}:o,c=t.styles,l=c===void 0?{}:c;return Tm({type:`counter`,content:e},function(){return ym(`beforeDOMElementCreation`,{content:e,params:t}),jm({content:e.toString(),title:r,extra:{attributes:s,styles:l,classes:[`${J.cssPrefix}-layers-counter`].concat(Fu(a))}})})}}}},Sh={mixout:function(){return{text:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?op:n,i=t.classes,a=i===void 0?[]:i,o=t.attributes,s=o===void 0?{}:o,c=t.styles,l=c===void 0?{}:c;return Tm({type:`text`,content:e},function(){return ym(`beforeDOMElementCreation`,{content:e,params:t}),Am({content:e,transform:q(q({},op),r),extra:{attributes:s,styles:l,classes:[`${J.cssPrefix}-layers-text`].concat(Fu(a))}})})}}},provides:function(e){e.generateLayersText=function(e,t){var n=t.transform,r=t.extra,i=null,a=null;if(Qu){var o=parseInt(getComputedStyle(e).fontSize,10),s=e.getBoundingClientRect();i=s.width/o,a=s.height/o}return Promise.resolve([e,Am({content:e.innerHTML,width:i,height:a,transform:n,extra:r,watchable:!0})])}}},Ch=RegExp(`"`,`ug`),wh=[1105920,1112319],Th=q(q(q(q({},{FontAwesome:{normal:`fas`,400:`fas`}}),tf),Cf),lf),Eh=Object.keys(Th).reduce(function(e,t){return e[t.toLowerCase()]=Th[t],e},{}),Dh=Object.keys(Eh).reduce(function(e,t){var n=Eh[t];return e[t]=n[900]||Fu(Object.entries(n))[0][1],e},{});function Oh(e){return Np(Fu(e.replace(Ch,``))[0]||``)}function kh(e){var t=e.getPropertyValue(`font-feature-settings`).includes(`ss01`),n=e.getPropertyValue(`content`).replace(Ch,``),r=n.codePointAt(0),i=r>=wh[0]&&r<=wh[1],a=n.length===2&&n[0]===n[1];return i||a||t}function Ah(e,t){var n=e.replace(/^['"]|['"]$/g,``).toLowerCase(),r=parseInt(t),i=isNaN(r)?`normal`:r;return(Eh[n]||{})[i]||Dh[n]}function jh(e,t){var n=`${Af}${t.replace(`:`,`-`)}`;return new Promise(function(r,i){if(e.getAttribute(n)!==null)return r();var a=up(e.children).filter(function(e){return e.getAttribute(kf)===t})[0],o=qu.getComputedStyle(e,t),s=o.getPropertyValue(`font-family`),c=s.match(Jf),l=o.getPropertyValue(`font-weight`),u=o.getPropertyValue(`content`);if(a&&!c)return e.removeChild(a),r();if(c&&u!==`none`&&u!==``){var d=o.getPropertyValue(`content`),f=Ah(s,l),p=Oh(d),m=c[0].startsWith(`FontAwesome`),h=kh(o),g=Yp(f,p),_=g;if(m){var v=$p(p);v.iconName&&v.prefix&&(g=v.iconName,f=v.prefix)}if(g&&!h&&(!a||a.getAttribute(jf)!==f||a.getAttribute(Mf)!==_)){e.setAttribute(n,_),a&&e.removeChild(a);var y=uh(),b=y.extra;b.attributes[kf]=t,Im(g,f).then(function(i){var a=km(q(q({},y),{},{icons:{main:i,mask:tm()},prefix:f,iconName:_,extra:b,watchable:!0})),o=Ju.createElementNS(`http://www.w3.org/2000/svg`,`svg`);t===`::before`?e.insertBefore(o,e.firstChild):e.appendChild(o),o.outerHTML=a.map(function(e){return kp(e)}).join(`
`),e.removeAttribute(n),r()}).catch(i)}else r()}else r()})}function Mh(e){return Promise.all([jh(e,`::before`),jh(e,`::after`)])}function Nh(e){return e.parentNode!==document.head&&!~Ff.indexOf(e.tagName.toUpperCase())&&!e.getAttribute(kf)&&(!e.parentNode||e.parentNode.tagName!==`svg`)}var Ph=function(e){return!!e&&If.some(function(t){return e.includes(t)})},Fh=function(e){if(!e)return[];var t=new Set,n=e.split(/,(?![^()]*\))/).map(function(e){return e.trim()});n=n.flatMap(function(e){return e.includes(`(`)?e:e.split(`,`).map(function(e){return e.trim()})});var r=Ou(n),i;try{for(r.s();!(i=r.n()).done;){var a=i.value;if(Ph(a)){var o=If.reduce(function(e,t){return e.replace(t,``)},a);o!==``&&o!==`*`&&t.add(o)}}}catch(e){r.e(e)}finally{r.f()}return t};function Ih(e){var t=arguments.length>1&&arguments[1]!==void 0&&arguments[1];if(Zu){var n;if(t)n=e;else if(J.searchPseudoElementsFullScan)n=e.querySelectorAll(`*`);else{var r=new Set,i=Ou(document.styleSheets),a;try{for(i.s();!(a=i.n()).done;){var o=a.value;try{var s=Ou(o.cssRules),c;try{for(s.s();!(c=s.n()).done;){var l=c.value,u=Ou(Fh(l.selectorText)),d;try{for(u.s();!(d=u.n()).done;){var f=d.value;r.add(f)}}catch(e){u.e(e)}finally{u.f()}}}catch(e){s.e(e)}finally{s.f()}}catch(e){J.searchPseudoElementsWarnings&&console.warn(`Font Awesome: cannot parse stylesheet: ${o.href} (${e.message})
If it declares any Font Awesome CSS pseudo-elements, they will not be rendered as SVG icons. Add crossorigin="anonymous" to the <link>, enable searchPseudoElementsFullScan for slower but more thorough DOM parsing, or suppress this warning by setting searchPseudoElementsWarnings to false.`)}}}catch(e){i.e(e)}finally{i.f()}if(!r.size)return;var p=Array.from(r).join(`, `);try{n=e.querySelectorAll(p)}catch{}}return new Promise(function(e,t){var r=up(n).filter(Nh).map(Mh),i=Hm.begin(`searchPseudoElements`);nh(),Promise.all(r).then(function(){i(),rh(),e()}).catch(function(){i(),rh(),t()})})}}var Lh={hooks:function(){return{mutationObserverCallbacks:function(e){return e.pseudoElementsCallback=Ih,e}}},provides:function(e){e.pseudoElements2svg=function(e){var t=e.node,n=t===void 0?Ju:t;J.searchPseudoElements&&Ih(n)}}},Rh=!1,zh={mixout:function(){return{dom:{unwatch:function(){nh(),Rh=!0}}}},hooks:function(){return{bootstrap:function(){ah(vm(`mutationObserverCallbacks`,{}))},noAuto:function(){oh()},watch:function(e){var t=e.observeMutationsRoot;Rh?rh():ah(vm(`mutationObserverCallbacks`,{observeMutationsRoot:t}))}}}},Bh=function(e){return e.toLowerCase().split(` `).reduce(function(e,t){var n=t.toLowerCase().split(`-`),r=n[0],i=n.slice(1).join(`-`);if(r&&i===`h`)return e.flipX=!0,e;if(r&&i===`v`)return e.flipY=!0,e;if(i=parseFloat(i),isNaN(i))return e;switch(r){case`grow`:e.size+=i;break;case`shrink`:e.size-=i;break;case`left`:e.x-=i;break;case`right`:e.x+=i;break;case`up`:e.y-=i;break;case`down`:e.y+=i;break;case`rotate`:e.rotate+=i}return e},{size:16,x:0,y:0,flipX:!1,flipY:!1,rotate:0})},Vh={mixout:function(){return{parse:{transform:function(e){return Bh(e)}}}},hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-transform`);return n&&(e.transform=Bh(n)),e}}},provides:function(e){e.generateAbstractTransformGrouping=function(e){var t=e.main,n=e.transform,r=e.containerWidth,i=e.iconWidth,a={outer:{transform:`translate(${r/2} 256)`},inner:{transform:`${`translate(${n.x*32}, ${n.y*32}) `} ${`scale(${n.size/16*(n.flipX?-1:1)}, ${n.size/16*(n.flipY?-1:1)}) `} ${`rotate(${n.rotate} 0 0)`}`},path:{transform:`translate(${i/2*-1} -256)`}};return{tag:`g`,attributes:q({},a.outer),children:[{tag:`g`,attributes:q({},a.inner),children:[{tag:t.icon.tag,children:t.icon.children,attributes:q(q({},t.icon.attributes),a.path)}]}]}}}},Hh={x:0,y:0,width:`100%`,height:`100%`};function Uh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return e.attributes&&(e.attributes.fill||t)&&(e.attributes.fill=`black`),e}function Wh(e){return e.tag===`g`?e.children:[e]}_m([Sp,yh,bh,xh,Sh,Lh,zh,Vh,{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-mask`),r=n?sm(n.split(` `).map(function(e){return e.trim()})):tm();return r.prefix||=em(),e.mask=r,e.maskId=t.getAttribute(`data-fa-mask-id`),e}}},provides:function(e){e.generateAbstractMask=function(e){var t=e.children,n=e.attributes,r=e.main,i=e.mask,a=e.maskId,o=e.transform,s=r.width,c=r.icon,l=i.width,u=i.icon,d=gp({transform:o,containerWidth:l,iconWidth:s}),f={tag:`rect`,attributes:q(q({},Hh),{},{fill:`white`})},p=c.children?{children:c.children.map(Uh)}:{},m={tag:`g`,attributes:q({},d.inner),children:[Uh(q({tag:c.tag,attributes:q(q({},c.attributes),d.path)},p))]},h={tag:`g`,attributes:q({},d.outer),children:[m]},g=`mask-${a||lp()}`,_=`clip-${a||lp()}`,v={tag:`mask`,attributes:q(q({},Hh),{},{id:g,maskUnits:`userSpaceOnUse`,maskContentUnits:`userSpaceOnUse`}),children:[f,h]},y={tag:`defs`,children:[{tag:`clipPath`,attributes:{id:_},children:Wh(u)},v]};return t.push(y,{tag:`rect`,attributes:q({fill:`currentColor`,"clip-path":`url(#${_})`,mask:`url(#${g})`},Hh)}),{children:t,attributes:n}}}},{provides:function(e){var t=!1;qu.matchMedia&&(t=qu.matchMedia(`(prefers-reduced-motion: reduce)`).matches),e.missingIconAbstract=function(){var e=[],n={fill:`currentColor`},r={attributeType:`XML`,repeatCount:`indefinite`,dur:`2s`};e.push({tag:`path`,attributes:q(q({},n),{},{d:`M156.5,447.7l-12.6,29.5c-18.7-9.5-35.9-21.2-51.5-34.9l22.7-22.7C127.6,430.5,141.5,440,156.5,447.7z M40.6,272H8.5 c1.4,21.2,5.4,41.7,11.7,61.1L50,321.2C45.1,305.5,41.8,289,40.6,272z M40.6,240c1.4-18.8,5.2-37,11.1-54.1l-29.5-12.6 C14.7,194.3,10,216.7,8.5,240H40.6z M64.3,156.5c7.8-14.9,17.2-28.8,28.1-41.5L69.7,92.3c-13.7,15.6-25.5,32.8-34.9,51.5 L64.3,156.5z M397,419.6c-13.9,12-29.4,22.3-46.1,30.4l11.9,29.8c20.7-9.9,39.8-22.6,56.9-37.6L397,419.6z M115,92.4 c13.9-12,29.4-22.3,46.1-30.4l-11.9-29.8c-20.7,9.9-39.8,22.6-56.8,37.6L115,92.4z M447.7,355.5c-7.8,14.9-17.2,28.8-28.1,41.5 l22.7,22.7c13.7-15.6,25.5-32.9,34.9-51.5L447.7,355.5z M471.4,272c-1.4,18.8-5.2,37-11.1,54.1l29.5,12.6 c7.5-21.1,12.2-43.5,13.6-66.8H471.4z M321.2,462c-15.7,5-32.2,8.2-49.2,9.4v32.1c21.2-1.4,41.7-5.4,61.1-11.7L321.2,462z M240,471.4c-18.8-1.4-37-5.2-54.1-11.1l-12.6,29.5c21.1,7.5,43.5,12.2,66.8,13.6V471.4z M462,190.8c5,15.7,8.2,32.2,9.4,49.2h32.1 c-1.4-21.2-5.4-41.7-11.7-61.1L462,190.8z M92.4,397c-12-13.9-22.3-29.4-30.4-46.1l-29.8,11.9c9.9,20.7,22.6,39.8,37.6,56.9 L92.4,397z M272,40.6c18.8,1.4,36.9,5.2,54.1,11.1l12.6-29.5C317.7,14.7,295.3,10,272,8.5V40.6z M190.8,50 c15.7-5,32.2-8.2,49.2-9.4V8.5c-21.2,1.4-41.7,5.4-61.1,11.7L190.8,50z M442.3,92.3L419.6,115c12,13.9,22.3,29.4,30.5,46.1 l29.8-11.9C470,128.5,457.3,109.4,442.3,92.3z M397,92.4l22.7-22.7c-15.6-13.7-32.8-25.5-51.5-34.9l-12.6,29.5 C370.4,72.1,384.4,81.5,397,92.4z`})});var i=q(q({},r),{},{attributeName:`opacity`}),a={tag:`circle`,attributes:q(q({},n),{},{cx:`256`,cy:`364`,r:`28`}),children:[]};return t||a.children.push({tag:`animate`,attributes:q(q({},r),{},{attributeName:`r`,values:`28;14;28;28;14;28;`})},{tag:`animate`,attributes:q(q({},i),{},{values:`1;0;1;1;0;1;`})}),e.push(a),e.push({tag:`path`,attributes:q(q({},n),{},{opacity:`1`,d:`M263.7,312h-16c-6.6,0-12-5.4-12-12c0-71,77.4-63.9,77.4-107.8c0-20-17.8-40.2-57.4-40.2c-29.1,0-44.3,9.6-59.2,28.7 c-3.9,5-11.1,6-16.2,2.4l-13.1-9.2c-5.6-3.9-6.9-11.8-2.6-17.2c21.2-27.2,46.4-44.7,91.2-44.7c52.3,0,97.4,29.8,97.4,80.2 c0,67.6-77.4,63.5-77.4,107.8C275.7,306.6,270.3,312,263.7,312z`}),children:t?[]:[{tag:`animate`,attributes:q(q({},i),{},{values:`1;0;0;0;0;1;`})}]}),t||e.push({tag:`path`,attributes:q(q({},n),{},{opacity:`0`,d:`M232.5,134.5l7,168c0.3,6.4,5.6,11.5,12,11.5h9c6.4,0,11.7-5.1,12-11.5l7-168c0.3-6.8-5.2-12.5-12-12.5h-23 C237.7,122,232.2,127.7,232.5,134.5z`}),children:[{tag:`animate`,attributes:q(q({},i),{},{values:`0;0;1;1;0;0;`})}]}),{tag:`g`,attributes:{class:`missing`},children:e}}}},{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-symbol`);return e.symbol=n===null?!1:n===``||n,e}}}}],{mixoutsTo:Cm}),Cm.noAuto,Cm.config,Cm.library,Cm.dom;var Gh=Cm.parse;Cm.findIconDefinition,Cm.toHtml;var Kh=Cm.icon;Cm.layer,Cm.text,Cm.counter;function qh(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function Jh(e){if(Array.isArray(e))return qh(e)}function Yh(e,t,n){return(t=ig(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function Xh(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function Zh(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Qh(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function $h(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Qh(Object(n),!0).forEach(function(t){Yh(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Qh(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function eg(e,t){if(e==null)return{};var n,r,i=tg(e,t);if(Object.getOwnPropertySymbols){var a=Object.getOwnPropertySymbols(e);for(r=0;r<a.length;r++)n=a[r],t.indexOf(n)===-1&&{}.propertyIsEnumerable.call(e,n)&&(i[n]=e[n])}return i}function tg(e,t){if(e==null)return{};var n={};for(var r in e)if({}.hasOwnProperty.call(e,r)){if(t.indexOf(r)!==-1)continue;n[r]=e[r]}return n}function ng(e){return Jh(e)||Xh(e)||og(e)||Zh()}function rg(e,t){if(typeof e!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(typeof r!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function ig(e){var t=rg(e,`string`);return typeof t==`symbol`?t:t+``}function ag(e){"@babel/helpers - typeof";return ag=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},ag(e)}function og(e,t){if(e){if(typeof e==`string`)return qh(e,t);var n={}.toString.call(e).slice(8,-1);return n===`Object`&&e.constructor&&(n=e.constructor.name),n===`Map`||n===`Set`?Array.from(e):n===`Arguments`||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?qh(e,t):void 0}}function sg(e,t){return Array.isArray(t)&&t.length>0||!Array.isArray(t)&&t?Yh({},e,t):{}}function cg(e){var t,n=(t={"fa-spin":e.spin,"fa-pulse":e.pulse,"fa-fw":e.fixedWidth,"fa-border":e.border,"fa-li":e.listItem,"fa-inverse":e.inverse,"fa-flip":e.flip===!0,"fa-flip-horizontal":e.flip===`horizontal`||e.flip===`both`,"fa-flip-vertical":e.flip===`vertical`||e.flip===`both`},Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(t,`fa-${e.size}`,e.size!==null),`fa-rotate-${e.rotation}`,e.rotation!==null),`fa-rotate-by`,e.rotateBy),`fa-pull-${e.pull}`,e.pull!==null),`fa-swap-opacity`,e.swapOpacity),`fa-bounce`,e.bounce),`fa-shake`,e.shake),`fa-beat`,e.beat),`fa-fade`,e.fade),`fa-beat-fade`,e.beatFade),Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(t,`fa-flash`,e.flash),`fa-spin-pulse`,e.spinPulse),`fa-spin-reverse`,e.spinReverse),`fa-width-auto`,e.widthAuto),`fa-canvas-square`,e.canvasSquare),`fa-canvas-roomy`,e.canvasRoomy),`fa-flip-360`,e.flip360),`fa-buzz`,e.buzz),`fa-float`,e.float),`fa-jello`,e.jello),Yh(Yh(Yh(Yh(Yh(t,`fa-spin-snap`,e.spinSnap),`fa-spin-snap-4`,e.spinSnap4),`fa-spin-snap-8`,e.spinSnap8),`fa-swing`,e.swing),`fa-wag`,e.wag));return Object.keys(n).map(function(e){return n[e]?e:null}).filter(function(e){return e})}var lg=typeof globalThis<`u`?globalThis:typeof window<`u`?window:typeof global<`u`?global:typeof self<`u`?self:{},ug={exports:{}};(function(e){(function(t){var n=function(e,t,r){if(!l(t)||d(t)||f(t)||p(t)||c(t))return t;var i,a=0,o=0;if(u(t))for(i=[],o=t.length;a<o;a++)i.push(n(e,t[a],r));else for(var s in i={},t)Object.prototype.hasOwnProperty.call(t,s)&&(i[e(s,r)]=n(e,t[s],r));return i},r=function(e,t){t||={};var n=t.separator||`_`,r=t.split||/(?=[A-Z])/;return e.split(r).join(n)},i=function(e){return m(e)?e:(e=e.replace(/[\-_\s]+(.)?/g,function(e,t){return t?t.toUpperCase():``}),e.substr(0,1).toLowerCase()+e.substr(1))},a=function(e){var t=i(e);return t.substr(0,1).toUpperCase()+t.substr(1)},o=function(e,t){return r(e,t).toLowerCase()},s=Object.prototype.toString,c=function(e){return typeof e==`function`},l=function(e){return e===Object(e)},u=function(e){return s.call(e)==`[object Array]`},d=function(e){return s.call(e)==`[object Date]`},f=function(e){return s.call(e)==`[object RegExp]`},p=function(e){return s.call(e)==`[object Boolean]`},m=function(e){return e-=0,e===e},h=function(e,t){var n=t&&`process`in t?t.process:t;return typeof n==`function`?function(t,r){return n(t,e,r)}:e},g={camelize:i,decamelize:o,pascalize:a,depascalize:o,camelizeKeys:function(e,t){return n(h(i,t),e)},decamelizeKeys:function(e,t){return n(h(o,t),e,t)},pascalizeKeys:function(e,t){return n(h(a,t),e)},depascalizeKeys:function(){return this.decamelizeKeys.apply(this,arguments)}};e.exports?e.exports=g:t.humps=g})(lg)})(ug);var dg=ug.exports,fg=[`gradientFill`],pg=[`class`,`style`],mg=[`type`,`stops`,`id`];function hg(e){return e.split(`;`).map(function(e){return e.trim()}).filter(function(e){return e}).reduce(function(e,t){var n=t.indexOf(`:`),r=dg.camelize(t.slice(0,n));return e[r]=t.slice(n+1).trim(),e},{})}function gg(e){return e.split(/\s+/).reduce(function(e,t){return e[t]=!0,e},{})}function _g(e,t){return G(`stop`,$h({key:`${t}-${e.offset}`,offset:e.offset,"stop-color":e.color},e.opacity!==void 0&&{"stop-opacity":e.opacity}))}function vg(e){if(typeof e==`string`)return e;var t=(e.children||[]).map(vg);return e.tag===`path`&&e.attributes&&`fill`in e.attributes?$h($h({},e),{},{attributes:$h($h({},e.attributes),{},{fill:void 0}),children:t}):$h($h({},e),{},{children:t})}function yg(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{};if(typeof e==`string`)return e;var r=t.gradientFill,i=r===void 0?null:r,a=eg(t,fg),o=i||`fill`in n?vg(e):e,s=(o.children||[]).map(function(e){return yg(e,{},{})}),c=Object.keys(o.attributes||{}).reduce(function(e,t){var n=o.attributes[t];switch(t){case`class`:e.class=gg(n);break;case`style`:e.style=hg(n);break;default:e.attrs[t]=n}return e},{attrs:{},class:{},style:{}});n.class;var l=n.style,u=l===void 0?{}:l,d=eg(n,pg);if(i&&i.id&&(i.type===`linear`||i.type===`radial`)){var f=i.type,p=i.stops,m=p===void 0?[]:p,h=i.id,g=eg(i,mg),_=G(f===`linear`?`linearGradient`:`radialGradient`,$h($h({},g),{},{id:h}),m.map(_g));return G(o.tag,$h($h($h($h({},a),{},{class:c.class,style:$h($h({},c.style),u)},c.attrs),d),{},{fill:`url(#${h})`}),[_].concat(ng(s)))}return G(e.tag,$h($h($h({},a),{},{class:c.class,style:$h($h({},c.style),u)},c.attrs),d),s)}var bg=!1;try{bg=!0}catch{}function xg(){if(!bg&&console&&typeof console.error==`function`){var e;(e=console).error.apply(e,arguments)}}function Sg(e){if(e&&ag(e)===`object`&&e.prefix&&e.iconName&&e.icon)return e;if(Gh.icon)return Gh.icon(e);if(e===null)return null;if(ag(e)===`object`&&e.prefix&&e.iconName)return e;if(Array.isArray(e)&&e.length===2)return{prefix:e[0],iconName:e[1]};if(typeof e==`string`)return{prefix:`fas`,iconName:e}}var Cg=F({name:`FontAwesomeIcon`,props:{border:{type:Boolean,default:!1},fixedWidth:{type:Boolean,default:!1},flip:{type:[Boolean,String],default:!1,validator:function(e){return[!0,!1,`horizontal`,`vertical`,`both`].indexOf(e)>-1}},icon:{type:[Object,Array,String],required:!0},mask:{type:[Object,Array,String],default:null},maskId:{type:String,default:null},listItem:{type:Boolean,default:!1},pull:{type:String,default:null,validator:function(e){return[`right`,`left`].indexOf(e)>-1}},pulse:{type:Boolean,default:!1},rotation:{type:[String,Number],default:null,validator:function(e){return[90,180,270].indexOf(Number.parseInt(e,10))>-1}},rotateBy:{type:Boolean,default:!1},swapOpacity:{type:Boolean,default:!1},size:{type:String,default:null,validator:function(e){return[`2xs`,`xs`,`sm`,`lg`,`xl`,`2xl`,`1x`,`2x`,`3x`,`4x`,`5x`,`6x`,`7x`,`8x`,`9x`,`10x`].indexOf(e)>-1}},spin:{type:Boolean,default:!1},transform:{type:[String,Object],default:null},symbol:{type:[Boolean,String],default:!1},title:{type:String,default:null},titleId:{type:String,default:null},inverse:{type:Boolean,default:!1},bounce:{type:Boolean,default:!1},shake:{type:Boolean,default:!1},beat:{type:Boolean,default:!1},fade:{type:Boolean,default:!1},beatFade:{type:Boolean,default:!1},flash:{type:Boolean,default:!1},spinPulse:{type:Boolean,default:!1},spinReverse:{type:Boolean,default:!1},widthAuto:{type:Boolean,default:!1},canvasSquare:{type:Boolean,default:!1},canvasRoomy:{type:Boolean,default:!1},gradientFill:{type:Object,default:null,validator:function(e){return typeof e.id!=`string`||!e.id?(console.warn(`FontAwesomeIcon: gradientFill.id must be a non-empty string`),!1):e.type!==`linear`&&e.type!==`radial`?(console.warn(`FontAwesomeIcon: gradientFill.type must be "linear" or "radial"`),!1):!0}},flip360:{type:Boolean,default:!1},buzz:{type:Boolean,default:!1},float:{type:Boolean,default:!1},jello:{type:Boolean,default:!1},spinSnap:{type:Boolean,default:!1},spinSnap4:{type:Boolean,default:!1},spinSnap8:{type:Boolean,default:!1},swing:{type:Boolean,default:!1},wag:{type:Boolean,default:!1}},setup:function(e,t){var n=t.attrs,r=W(function(){return Sg(e.icon)}),i=W(function(){return sg(`classes`,cg(e))}),a=W(function(){return sg(`transform`,typeof e.transform==`string`?Gh.transform(e.transform):e.transform)}),o=W(function(){return sg(`mask`,Sg(e.mask))}),s=W(function(){var t=$h($h($h($h({},i.value),a.value),o.value),{},{symbol:e.symbol,maskId:e.maskId});return t.title=e.title,t.titleId=e.titleId,Kh(r.value,t)});Er(s,function(e){if(!e)return xg(`Could not find one or more icon(s)`,r.value,o.value)},{immediate:!0}),e.gradientFill&&e.symbol&&xg(`gradientFill is not supported when symbol is true and will be ignored`);var c=W(function(){return s.value?yg(s.value.abstract[0],{gradientFill:e.symbol?null:e.gradientFill},n):null});return function(){return c.value}}}),wg=typeof window<`u`,Tg,Eg=e=>Tg=e,Dg=Symbol();function Og(e){return e&&typeof e==`object`&&Object.prototype.toString.call(e)===`[object Object]`&&typeof e.toJSON!=`function`}var kg=typeof window==`object`&&window.window===window?window:typeof self==`object`&&self.self===self?self:typeof global==`object`&&global.global===global?global:typeof globalThis==`object`?globalThis:{HTMLElement:null};function Ag(e,{autoBom:t=!1}={}){return t&&/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(e.type)?new Blob([`﻿`,e],{type:e.type}):e}function jg(e,t,n){let r=new XMLHttpRequest;r.open(`GET`,e),r.responseType=`blob`,r.onload=function(){Ig(r.response,t,n)},r.onerror=function(){console.error(`could not download file`)},r.send()}function Mg(e){let t=new XMLHttpRequest;t.open(`HEAD`,e,!1);try{t.send()}catch{}return t.status>=200&&t.status<=299}function Ng(e){try{e.dispatchEvent(new MouseEvent(`click`))}catch{let t=new MouseEvent(`click`,{bubbles:!0,cancelable:!0,view:window,detail:0,screenX:80,screenY:20,clientX:80,clientY:20,ctrlKey:!1,altKey:!1,shiftKey:!1,metaKey:!1,button:0,relatedTarget:null});e.dispatchEvent(t)}}var Pg=typeof navigator==`object`?navigator:{userAgent:``},Fg=/Macintosh/.test(Pg.userAgent)&&/AppleWebKit/.test(Pg.userAgent)&&!/Safari/.test(Pg.userAgent),Ig=wg?typeof HTMLAnchorElement<`u`&&`download`in HTMLAnchorElement.prototype&&!Fg?Lg:`msSaveOrOpenBlob`in Pg?Rg:zg:()=>{};function Lg(e,t=`download`,n){let r=document.createElement(`a`);r.download=t,r.rel=`noopener`,typeof e==`string`?(r.href=e,r.origin===location.origin?Ng(r):Mg(r.href)?jg(e,t,n):(r.target=`_blank`,Ng(r))):(r.href=URL.createObjectURL(e),setTimeout(function(){URL.revokeObjectURL(r.href)},4e4),setTimeout(function(){Ng(r)},0))}function Rg(e,t=`download`,n){if(typeof e==`string`){if(Mg(e))jg(e,t,n);else{let t=document.createElement(`a`);t.href=e,t.target=`_blank`,setTimeout(function(){Ng(t)})}}else navigator.msSaveOrOpenBlob(Ag(e,n),t)}function zg(e,t,n,r){if(r||=open(``,`_blank`),r&&(r.document.title=r.document.body.innerText=`downloading...`),typeof e==`string`)return jg(e,t,n);let i=e.type===`application/octet-stream`,a=/constructor/i.test(String(kg.HTMLElement))||`safari`in kg,o=/CriOS\/[\d]+/.test(navigator.userAgent);if((o||i&&a||Fg)&&typeof FileReader<`u`){let t=new FileReader;t.onloadend=function(){let e=t.result;if(typeof e!=`string`)throw r=null,Error(`Wrong reader.result type`);e=o?e:e.replace(/^data:[^;]*;/,`data:attachment/file;`),r?r.location.href=e:location.assign(e),r=null},t.readAsDataURL(e)}else{let t=URL.createObjectURL(e);r?r.location.assign(t):location.href=t,r=null,setTimeout(function(){URL.revokeObjectURL(t)},4e4)}}var{assign:Bg}=Object;function Vg(){let e=Pe(!0),t=e.run(()=>M({})),n=[],r=[],i=sn({install(e){Eg(i),i._a=e,e.provide(Dg,i),e.config.globalProperties.$pinia=i,r.forEach(e=>n.push(e)),r=[]},use(e){return this._a?n.push(e):r.push(e),this},_p:n,_a:null,_e:e,_s:new Map,state:t});return i}var Hg=()=>{};function Ug(e,t,n,r=Hg){e.add(t);let i=()=>{e.delete(t)&&r()};return!n&&Fe()&&Ie(i),i}function Wg(e,...t){e.forEach(e=>{e(...t)})}var Gg=e=>e(),Kg=Symbol(),qg=Symbol();function Jg(e,t){e instanceof Map&&t instanceof Map?t.forEach((t,n)=>e.set(n,t)):e instanceof Set&&t instanceof Set&&t.forEach(e.add,e);for(let n in t){if(!Object.hasOwn(t,n))continue;let r=t[n],i=e[n];e[n]=Og(i)&&Og(r)&&Object.hasOwn(e,n)&&!j(r)&&!nn(r)?Jg(i,r):r}return e}var Yg=Symbol();function Xg(e){return!e||typeof e!=`object`||!Object.hasOwn(e,Yg)}var{assign:Zg}=Object;function Qg(e){return!!(j(e)&&e.effect)}function $g(e,t,n,r){let{state:i,actions:a,getters:o}=t,s=n.state.value[e],c;function l(){return s||(n.state.value[e]=i?i():{}),Zg(yn(n.state.value[e]),a,Object.keys(o||{}).reduce((t,r)=>(t[r]=sn(W(()=>{Eg(n);let t=n._s.get(e);return o[r].call(t,t)})),t),{}))}return c=e_(e,l,t,n,r,!0),c}function e_(e,t,n={},r,i,a){let o,s=Zg({actions:{}},n),c={deep:!0},l,u,d=new Set,f=new Set,p,m=r.state.value[e];!a&&!m&&(r.state.value[e]={});let h;function g(t){let n;l=u=!1,typeof t==`function`?(t(r.state.value[e]),n={type:`patch function`,storeId:e,events:p}):(Jg(r.state.value[e],t),n={type:`patch object`,payload:t,storeId:e,events:p});let i=h=Symbol();Qn().then(()=>{h===i&&(l=!0)}),u=!0,Wg(d,n,r.state.value[e])}let _=a?function(){let{state:e}=n,t=e?e():{};this.$patch(e=>{Zg(e,t)})}:Hg;function v(){o.stop(),d.clear(),f.clear(),r._s.delete(e)}let y=(t,n=``)=>{if(Kg in t)return t[qg]=n,t;let i=function(){Eg(r);let n=Array.from(arguments),a=new Set,o=new Set;function s(e){a.add(e)}function c(e){o.add(e)}Wg(f,{args:n,name:i[qg],store:b,after:s,onError:c});let l;try{l=t.apply(this&&this.$id===e?this:b,n)}catch(e){throw Wg(o,e),e}return l instanceof Promise?l.then(e=>(Wg(a,e),e)).catch(e=>(Wg(o,e),Promise.reject(e))):(Wg(a,l),l)};return i[Kg]=!0,i[qg]=n,i},b=Zt({_p:r,$id:e,$onAction:Ug.bind(null,f),$patch:g,$reset:_,$subscribe(t,n={}){if(d.has(t))return Hg;let i=Ug(d,t,n.detached,()=>a()),a=o.run(()=>Er(()=>r.state.value[e],r=>{(n.flush===`sync`?u:l)&&t({storeId:e,type:`direct`,events:p},r)},Zg({},c,n)));return i},$dispose:v});r._s.set(e,b);let x=(r._a&&r._a.runWithContext||Gg)(()=>r._e.run(()=>(o=Pe()).run(()=>t({action:y}))));for(let t in x){let n=x[t];j(n)&&!Qg(n)||nn(n)?a||(m&&Xg(n)&&(j(n)?n.value=m[t]:((n instanceof Set||n instanceof Map)&&n.clear(),Jg(n,m[t]))),r.state.value[e][t]=n):typeof n==`function`&&(x[t]=y(n,t),s.actions[t]=n)}return Zg(b,x),Zg(A(b),x),Object.defineProperty(b,"$state",{get:()=>r.state.value[e],set:e=>{g(t=>{Zg(t,e)})}}),r._p.forEach(e=>{let t=o.run(()=>e({store:b,app:r._a,pinia:r,options:s}));Zg(b,t)}),m&&a&&n.hydrate&&n.hydrate(b.$state,m),l=!0,u=!0,b}function t_(e,t,n){let r,i=typeof t==`function`;r=i?n:t;function a(n,a){let o=br();return n||=o?yr(Dg,null):null,n&&Eg(n),n=Tg,n._s.has(e)||(i?e_(e,t,r,n):$g(e,r,n)),n._s.get(e)}return a.$id=e,a}var n_={prefix:`fab`,iconName:`github`,icon:[512,512,[],`f09b`,`M216.5 362.5c-66-8-112.5-55.5-112.5-117 0-25 9-52 24-70-6.5-16.5-5.5-51.5 2-66 20-2.5 47 8 63 22.5 19-6 39-9 63.5-9s44.5 3 62.5 8.5c15.5-14 43-24.5 63-22 7 13.5 8 48.5 1.5 65.5 16 19 24.5 44.5 24.5 70.5 0 61.5-46.5 108-113.5 116.5 17 11 28.5 35 28.5 62.5l0 52C323 491.5 335.5 500 350.5 494 441 459.5 512 369 512 257 512 115.5 397 0 255.5 0S0 115.5 0 257c0 111 70.5 203 165.5 237.5 13.5 5 26.5-4 26.5-17.5l0-40c-7 3-16 5-24 5-33 0-52.5-18-66.5-51.5-5.5-13.5-11.5-21.5-23-23-6-.5-8-3-8-6 0-6 10-10.5 20-10.5 14.5 0 27 9 40 27.5 10 14.5 20.5 21 33 21s20.5-4.5 32-16c8.5-8.5 15-16 21-21z`]},r_={prefix:`fas`,iconName:`magnifying-glass`,icon:[512,512,[128269,`search`],`f002`,`M416 208c0 45.9-14.9 88.3-40 122.7L502.6 457.4c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L330.7 376C296.3 401.1 253.9 416 208 416 93.1 416 0 322.9 0 208S93.1 0 208 0 416 93.1 416 208zM208 352a144 144 0 1 0 0-288 144 144 0 1 0 0 288z`]},i_={prefix:`fas`,iconName:`key`,icon:[512,512,[128273],`f084`,`M336 352c97.2 0 176-78.8 176-176S433.2 0 336 0 160 78.8 160 176c0 18.7 2.9 36.8 8.3 53.7L7 391c-4.5 4.5-7 10.6-7 17l0 80c0 13.3 10.7 24 24 24l80 0c13.3 0 24-10.7 24-24l0-40 40 0c13.3 0 24-10.7 24-24l0-40 40 0c6.4 0 12.5-2.5 17-7l33.3-33.3c16.9 5.4 35 8.3 53.7 8.3zM376 96a40 40 0 1 1 0 80 40 40 0 1 1 0-80z`]},a_={prefix:`fas`,iconName:`sort-up`,icon:[384,512,[`sort-asc`],`f0de`,`M32 224c-12.9 0-24.6-7.8-29.6-19.8S.2 178.5 9.4 169.4l160-160c12.5-12.5 32.8-12.5 45.3 0l160 160c9.2 9.2 11.9 22.9 6.9 34.9S364.9 224 352 224L32 224z`]},o_={prefix:`fas`,iconName:`eye`,icon:[576,512,[128065],`f06e`,`M288 32c-80.8 0-145.5 36.8-192.6 80.6-46.8 43.5-78.1 95.4-93 131.1-3.3 7.9-3.3 16.7 0 24.6 14.9 35.7 46.2 87.7 93 131.1 47.1 43.7 111.8 80.6 192.6 80.6s145.5-36.8 192.6-80.6c46.8-43.5 78.1-95.4 93-131.1 3.3-7.9 3.3-16.7 0-24.6-14.9-35.7-46.2-87.7-93-131.1-47.1-43.7-111.8-80.6-192.6-80.6zM144 256a144 144 0 1 1 288 0 144 144 0 1 1 -288 0zm144-64c0 35.3-28.7 64-64 64-11.5 0-22.3-3-31.7-8.4-1 10.9-.1 22.1 2.9 33.2 13.7 51.2 66.4 81.6 117.6 67.9s81.6-66.4 67.9-117.6c-12.2-45.7-55.5-74.8-101.1-70.8 5.3 9.3 8.4 20.1 8.4 31.7z`]},s_={prefix:`fas`,iconName:`chevron-up`,icon:[448,512,[],`f077`,`M201.4 105.4c12.5-12.5 32.8-12.5 45.3 0l192 192c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L224 173.3 54.6 342.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l192-192z`]},c_={prefix:`fas`,iconName:`circle-xmark`,icon:[512,512,[61532,`times-circle`,`xmark-circle`],`f057`,`M256 512a256 256 0 1 0 0-512 256 256 0 1 0 0 512zM167 167c9.4-9.4 24.6-9.4 33.9 0l55 55 55-55c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9l-55 55 55 55c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0l-55-55-55 55c-9.4 9.4-24.6 9.4-33.9 0s-9.4-24.6 0-33.9l55-55-55-55c-9.4-9.4-9.4-24.6 0-33.9z`]},l_={prefix:`fas`,iconName:`circle-exclamation`,icon:[512,512,[`exclamation-circle`],`f06a`,`M256 512a256 256 0 1 1 0-512 256 256 0 1 1 0 512zm0-192a32 32 0 1 0 0 64 32 32 0 1 0 0-64zm0-192c-18.2 0-32.7 15.5-31.4 33.7l7.4 104c.9 12.6 11.4 22.3 23.9 22.3 12.6 0 23-9.7 23.9-22.3l7.4-104c1.3-18.2-13.1-33.7-31.4-33.7z`]},u_={prefix:`fas`,iconName:`check`,icon:[448,512,[10003,10004],`f00c`,`M434.8 70.1c14.3 10.4 17.5 30.4 7.1 44.7l-256 352c-5.5 7.6-14 12.3-23.4 13.1s-18.5-2.7-25.1-9.3l-128-128c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0l101.5 101.5 234-321.7c10.4-14.3 30.4-17.5 44.7-7.1z`]},d_={prefix:`fas`,iconName:`sort`,icon:[384,512,[`unsorted`],`f0dc`,`M2.4 204.2c5 12 16.6 19.8 29.6 19.8l320 0c12.9 0 24.6-7.8 29.6-19.8s2.2-25.7-6.9-34.9l-160-160c-12.5-12.5-32.8-12.5-45.3 0l-160 160c-9.2 9.2-11.9 22.9-6.9 34.9zm0 103.5c-5 12-2.2 25.7 6.9 34.9l160 160c12.5 12.5 32.8 12.5 45.3 0l160-160c9.2-9.2 11.9-22.9 6.9-34.9S364.9 288 352 288L32 288c-12.9 0-24.6 7.8-29.6 19.8z`]},f_={prefix:`fas`,iconName:`xmark`,icon:[384,512,[128473,10005,10006,10060,215,`close`,`multiply`,`remove`,`times`],`f00d`,`M55.1 73.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3L147.2 256 9.9 393.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0L192.5 301.3 329.9 438.6c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L237.8 256 375.1 118.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L192.5 210.7 55.1 73.4z`]},p_={prefix:`fas`,iconName:`circle-check`,icon:[512,512,[61533,`check-circle`],`f058`,`M256 512a256 256 0 1 1 0-512 256 256 0 1 1 0 512zM374 145.7c-10.7-7.8-25.7-5.4-33.5 5.3L221.1 315.2 169 263.1c-9.4-9.4-24.6-9.4-33.9 0s-9.4 24.6 0 33.9l72 72c5 5 11.8 7.5 18.8 7s13.4-4.1 17.5-9.8L379.3 179.2c7.8-10.7 5.4-25.7-5.3-33.5z`]},m_={prefix:`fas`,iconName:`chevron-down`,icon:[448,512,[],`f078`,`M201.4 406.6c12.5 12.5 32.8 12.5 45.3 0l192-192c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L224 338.7 54.6 169.4c-12.5-12.5-32.8-12.5-45.3 0s-12.5 32.8 0 45.3l192 192z`]},h_={prefix:`fas`,iconName:`triangle-exclamation`,icon:[512,512,[9888,`exclamation-triangle`,`warning`],`f071`,`M256 0c14.7 0 28.2 8.1 35.2 21l216 400c6.7 12.4 6.4 27.4-.8 39.5S486.1 480 472 480L40 480c-14.1 0-27.2-7.4-34.4-19.5s-7.5-27.1-.8-39.5l216-400c7-12.9 20.5-21 35.2-21zm0 352a32 32 0 1 0 0 64 32 32 0 1 0 0-64zm0-192c-18.2 0-32.7 15.5-31.4 33.7l7.4 104c.9 12.5 11.4 22.3 23.9 22.3 12.6 0 23-9.7 23.9-22.3l7.4-104c1.3-18.2-13.1-33.7-31.4-33.7z`]},g_={prefix:`fas`,iconName:`copy`,icon:[448,512,[],`f0c5`,`M192 0c-35.3 0-64 28.7-64 64l0 256c0 35.3 28.7 64 64 64l192 0c35.3 0 64-28.7 64-64l0-200.6c0-17.4-7.1-34.1-19.7-46.2L370.6 17.8C358.7 6.4 342.8 0 326.3 0L192 0zM64 128c-35.3 0-64 28.7-64 64L0 448c0 35.3 28.7 64 64 64l192 0c35.3 0 64-28.7 64-64l0-16-64 0 0 16-192 0 0-256 16 0 0-64-16 0z`]},__={prefix:`fas`,iconName:`eye-slash`,icon:[576,512,[],`f070`,`M41-24.9c-9.4-9.4-24.6-9.4-33.9 0S-2.3-.3 7 9.1l528 528c9.4 9.4 24.6 9.4 33.9 0s9.4-24.6 0-33.9l-96.4-96.4c2.7-2.4 5.4-4.8 8-7.2 46.8-43.5 78.1-95.4 93-131.1 3.3-7.9 3.3-16.7 0-24.6-14.9-35.7-46.2-87.7-93-131.1-47.1-43.7-111.8-80.6-192.6-80.6-56.8 0-105.6 18.2-146 44.2L41-24.9zM204.5 138.7c23.5-16.8 52.4-26.7 83.5-26.7 79.5 0 144 64.5 144 144 0 31.1-9.9 59.9-26.7 83.5l-34.7-34.7c12.7-21.4 17-47.7 10.1-73.7-13.7-51.2-66.4-81.6-117.6-67.9-8.6 2.3-16.7 5.7-24 10l-34.7-34.7zM325.3 395.1c-11.9 3.2-24.4 4.9-37.3 4.9-79.5 0-144-64.5-144-144 0-12.9 1.7-25.4 4.9-37.3L69.4 139.2c-32.6 36.8-55 75.8-66.9 104.5-3.3 7.9-3.3 16.7 0 24.6 14.9 35.7 46.2 87.7 93 131.1 47.1 43.7 111.8 80.6 192.6 80.6 37.3 0 71.2-7.9 101.5-20.6l-64.2-64.2z`]},v_={prefix:`fas`,iconName:`sort-down`,icon:[384,512,[`sort-desc`],`f0dd`,`M32 288c-12.9 0-24.6 7.8-29.6 19.8S.2 333.5 9.4 342.6l160 160c12.5 12.5 32.8 12.5 45.3 0l160-160c9.2-9.2 11.9-22.9 6.9-34.9S364.9 288 352 288L32 288z`]};function y_(e){var t,n,r=``;if(typeof e==`string`||typeof e==`number`)r+=e;else if(typeof e==`object`){if(Array.isArray(e)){var i=e.length;for(t=0;t<i;t++)e[t]&&(n=y_(e[t]))&&(r&&(r+=` `),r+=n)}else for(n in e)e[n]&&(r&&(r+=` `),r+=n)}return r}function b_(){for(var e,t,n=0,r=``,i=arguments.length;n<i;n++)(e=arguments[n])&&(t=y_(e))&&(r&&(r+=` `),r+=t);return r}var x_=e=>typeof e==`boolean`?`${e}`:e===0?`0`:e,S_=b_,C_=(e,t)=>n=>{if(t?.variants==null)return S_(e,n?.class,n?.className);let{variants:r,defaultVariants:i}=t,a=Object.keys(r).map(e=>{let t=n?.[e],a=i?.[e];if(t===null)return null;let o=x_(t)||x_(a);return r[e][o]}),o=n&&Object.entries(n).reduce((e,t)=>{let[n,r]=t;return r===void 0||(e[n]=r),e},{});return S_(e,a,t?.compoundVariants?.reduce((e,t)=>{let{class:n,className:r,...a}=t;return Object.entries(a).every(e=>{let[t,n]=e;return Array.isArray(n)?n.includes({...i,...o}[t]):{...i,...o}[t]===n})?[...e,n,r]:e},[]),n?.class,n?.className)},w_=(e,t)=>{let n=Array(e.length+t.length);for(let t=0;t<e.length;t++)n[t]=e[t];for(let r=0;r<t.length;r++)n[e.length+r]=t[r];return n},T_=(e,t)=>({classGroupId:e,validator:t}),E_=(e=new Map,t=null,n)=>({nextPart:e,validators:t,classGroupId:n}),D_=`-`,O_=[],k_=`arbitrary..`,A_=e=>{let t=N_(e),{conflictingClassGroups:n,conflictingClassGroupModifiers:r}=e;return{getClassGroupId:e=>{if(e.startsWith(`[`)&&e.endsWith(`]`))return M_(e);let n=e.split(D_);return j_(n,+(n[0]===``&&n.length>1),t)},getConflictingClassGroupIds:(e,t)=>{if(t){let t=r[e],i=n[e];return t?i?w_(i,t):t:i||O_}return n[e]||O_}}},j_=(e,t,n)=>{if(e.length-t===0)return n.classGroupId;let r=e[t],i=n.nextPart.get(r);if(i){let n=j_(e,t+1,i);if(n)return n}let a=n.validators;if(a===null)return;let o=t===0?e.join(D_):e.slice(t).join(D_),s=a.length;for(let e=0;e<s;e++){let t=a[e];if(t.validator(o))return t.classGroupId}},M_=e=>e.slice(1,-1).indexOf(`:`)===-1?void 0:(()=>{let t=e.slice(1,-1),n=t.indexOf(`:`),r=t.slice(0,n);return r?k_+r:void 0})(),N_=e=>{let{theme:t,classGroups:n}=e;return P_(n,t)},P_=(e,t)=>{let n=E_();for(let r in e){let i=e[r];F_(i,n,r,t)}return n},F_=(e,t,n,r)=>{let i=e.length;for(let a=0;a<i;a++){let i=e[a];I_(i,t,n,r)}},I_=(e,t,n,r)=>{if(typeof e==`string`){L_(e,t,n);return}if(typeof e==`function`){R_(e,t,n,r);return}z_(e,t,n,r)},L_=(e,t,n)=>{let r=e===``?t:B_(t,e);r.classGroupId=n},R_=(e,t,n,r)=>{if(V_(e)){F_(e(r),t,n,r);return}t.validators===null&&(t.validators=[]),t.validators.push(T_(n,e))},z_=(e,t,n,r)=>{let i=Object.entries(e),a=i.length;for(let e=0;e<a;e++){let[a,o]=i[e];F_(o,B_(t,a),n,r)}},B_=(e,t)=>{let n=e,r=t.split(D_),i=r.length;for(let e=0;e<i;e++){let t=r[e],i=n.nextPart.get(t);i||(i=E_(),n.nextPart.set(t,i)),n=i}return n},V_=e=>`isThemeGetter`in e&&e.isThemeGetter===!0,H_=e=>{if(e<1)return{get:()=>void 0,set:()=>{}};let t=0,n=Object.create(null),r=Object.create(null),i=(i,a)=>{n[i]=a,t++,t>e&&(t=0,r=n,n=Object.create(null))};return{get(e){let t=n[e];if(t!==void 0)return t;if((t=r[e])!==void 0)return i(e,t),t},set(e,t){e in n?n[e]=t:i(e,t)}}},U_=`!`,W_=`:`,G_=[],K_=(e,t,n,r,i)=>({modifiers:e,hasImportantModifier:t,baseClassName:n,maybePostfixModifierPosition:r,isExternal:i}),q_=e=>{let{prefix:t,experimentalParseClassName:n}=e,r=e=>{let t=[],n=0,r=0,i=0,a,o=e.length;for(let s=0;s<o;s++){let o=e[s];if(n===0&&r===0){if(o===W_){t.push(e.slice(i,s)),i=s+1;continue}if(o===`/`){a=s;continue}}o===`[`?n++:o===`]`?n--:o===`(`?r++:o===`)`&&r--}let s=t.length===0?e:e.slice(i),c=s,l=!1;s.endsWith(U_)?(c=s.slice(0,-1),l=!0):s.startsWith(U_)&&(c=s.slice(1),l=!0);let u=a&&a>i?a-i:void 0;return K_(t,l,c,u)};if(t){let e=t+W_,n=r;r=t=>t.startsWith(e)?n(t.slice(e.length)):K_(G_,!1,t,void 0,!0)}if(n){let e=r;r=t=>n({className:t,parseClassName:e})}return r},J_=e=>{let t=new Map;return e.orderSensitiveModifiers.forEach((e,n)=>{t.set(e,1e6+n)}),e=>{let n=[],r=[];for(let i=0;i<e.length;i++){let a=e[i],o=a[0]===`[`,s=t.has(a);o||s?(r.length>0&&(r.sort(),n.push(...r),r=[]),n.push(a)):r.push(a)}return r.length>0&&(r.sort(),n.push(...r)),n}},Y_=e=>({cache:H_(e.cacheSize),parseClassName:q_(e),sortModifiers:J_(e),postfixLookupClassGroupIds:X_(e),...A_(e)}),X_=e=>{let t=Object.create(null),n=e.postfixLookupClassGroups;if(n)for(let e=0;e<n.length;e++)t[n[e]]=!0;return t},Z_=/\s+/,Q_=(e,t)=>{let{parseClassName:n,getClassGroupId:r,getConflictingClassGroupIds:i,sortModifiers:a,postfixLookupClassGroupIds:o}=t,s=[],c=e.trim().split(Z_),l=``;for(let e=c.length-1;e>=0;--e){let t=c[e],{isExternal:u,modifiers:d,hasImportantModifier:f,baseClassName:p,maybePostfixModifierPosition:m}=n(t);if(u){l=t+(l.length>0?` `+l:l);continue}let h=!!m,g;if(h){g=r(p.substring(0,m));let e=g&&o[g]?r(p):void 0;e&&e!==g&&(g=e,h=!1)}else g=r(p);if(!g){if(!h){l=t+(l.length>0?` `+l:l);continue}if(g=r(p),!g){l=t+(l.length>0?` `+l:l);continue}h=!1}let _=d.length===0?``:d.length===1?d[0]:a(d).join(`:`),v=f?_+U_:_,y=v+g;if(s.indexOf(y)>-1)continue;s.push(y);let b=i(g,h);for(let e=0;e<b.length;++e){let t=b[e];s.push(v+t)}l=t+(l.length>0?` `+l:l)}return l},$_=(...e)=>{let t=0,n,r,i=``;for(;t<e.length;)(n=e[t++])&&(r=ev(n))&&(i&&(i+=` `),i+=r);return i},ev=e=>{if(typeof e==`string`)return e;let t,n=``;for(let r=0;r<e.length;r++)e[r]&&(t=ev(e[r]))&&(n&&(n+=` `),n+=t);return n},tv=(e,...t)=>{let n,r,i,a,o=o=>(n=Y_(t.reduce((e,t)=>t(e),e())),r=n.cache.get,i=n.cache.set,a=s,s(o)),s=e=>{let t=r(e);if(t)return t;let a=Q_(e,n);return i(e,a),a};return a=o,(...e)=>a($_(...e))},nv=[],rv=e=>{let t=t=>t[e]||nv;return t.isThemeGetter=!0,t},iv=/^\[(?:(\w[\w-]*):)?(.+)\]$/i,av=/^\((?:(\w[\w-]*):)?(.+)\)$/i,ov=/^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/,sv=/^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/,cv=/\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/,lv=/^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/,uv=/^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/,dv=/^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/,fv=e=>ov.test(e),Y=e=>!!e&&!Number.isNaN(Number(e)),pv=e=>!!e&&Number.isInteger(Number(e)),mv=e=>e.endsWith(`%`)&&Y(e.slice(0,-1)),hv=e=>sv.test(e),gv=()=>!0,_v=e=>cv.test(e)&&!lv.test(e),vv=()=>!1,yv=e=>uv.test(e),bv=e=>dv.test(e),xv=e=>!X(e)&&!Z(e),Sv=e=>e.startsWith(`@container`)&&(e[10]===`/`&&e[11]!==void 0||e[11]===`s`&&e[16]!==void 0&&e.startsWith(`-size/`,10)||e[11]===`n`&&e[18]!==void 0&&e.startsWith(`-normal/`,10)),Cv=e=>Rv(e,Hv,vv),X=e=>iv.test(e),wv=e=>Rv(e,Uv,_v),Tv=e=>Rv(e,Wv,Y),Ev=e=>Rv(e,Kv,gv),Dv=e=>Rv(e,Gv,vv),Ov=e=>Rv(e,Bv,vv),kv=e=>Rv(e,Vv,bv),Av=e=>Rv(e,qv,yv),Z=e=>av.test(e),jv=e=>zv(e,Uv),Mv=e=>zv(e,Gv),Nv=e=>zv(e,Bv),Pv=e=>zv(e,Hv),Fv=e=>zv(e,Vv),Iv=e=>zv(e,qv,!0),Lv=e=>zv(e,Kv,!0),Rv=(e,t,n)=>{let r=iv.exec(e);return r?r[1]?t(r[1]):n(r[2]):!1},zv=(e,t,n=!1)=>{let r=av.exec(e);return r?r[1]?t(r[1]):n:!1},Bv=e=>e===`position`||e===`percentage`,Vv=e=>e===`image`||e===`url`,Hv=e=>e===`length`||e===`size`||e===`bg-size`,Uv=e=>e===`length`,Wv=e=>e===`number`,Gv=e=>e===`family-name`,Kv=e=>e===`number`||e===`weight`,qv=e=>e===`shadow`,Jv=tv(()=>{let e=rv(`color`),t=rv(`font`),n=rv(`text`),r=rv(`font-weight`),i=rv(`tracking`),a=rv(`leading`),o=rv(`breakpoint`),s=rv(`container`),c=rv(`spacing`),l=rv(`radius`),u=rv(`shadow`),d=rv(`inset-shadow`),f=rv(`text-shadow`),p=rv(`drop-shadow`),m=rv(`blur`),h=rv(`perspective`),g=rv(`aspect`),_=rv(`ease`),v=rv(`animate`),y=()=>[`auto`,`avoid`,`all`,`avoid-page`,`page`,`left`,`right`,`column`],b=()=>[`center`,`top`,`bottom`,`left`,`right`,`top-left`,`left-top`,`top-right`,`right-top`,`bottom-right`,`right-bottom`,`bottom-left`,`left-bottom`],x=()=>[...b(),Z,X],S=()=>[`auto`,`hidden`,`clip`,`visible`,`scroll`],C=()=>[`auto`,`contain`,`none`],w=()=>[Z,X,c],ee=()=>[fv,`full`,`auto`,...w()],te=()=>[pv,`none`,`subgrid`,Z,X],T=()=>[`auto`,{span:[`full`,pv,Z,X]},pv,Z,X],ne=()=>[pv,`auto`,Z,X],re=()=>[`auto`,`min`,`max`,`fr`,Z,X],ie=()=>[`start`,`end`,`center`,`between`,`around`,`evenly`,`stretch`,`baseline`,`center-safe`,`end-safe`],E=()=>[`start`,`end`,`center`,`stretch`,`center-safe`,`end-safe`],ae=()=>[`auto`,...w()],oe=()=>[fv,`auto`,`full`,`dvw`,`dvh`,`lvw`,`lvh`,`svw`,`svh`,`min`,`max`,`fit`,...w()],se=()=>[fv,`screen`,`full`,`dvw`,`lvw`,`svw`,`min`,`max`,`fit`,...w()],ce=()=>[fv,`screen`,`full`,`lh`,`dvh`,`lvh`,`svh`,`min`,`max`,`fit`,...w()],D=()=>[e,Z,X],le=()=>[...b(),Nv,Ov,{position:[Z,X]}],ue=()=>[`no-repeat`,{repeat:[``,`x`,`y`,`space`,`round`]}],de=()=>[`auto`,`cover`,`contain`,Pv,Cv,{size:[Z,X]}],fe=()=>[mv,jv,wv],pe=()=>[``,`none`,`full`,l,Z,X],me=()=>[``,Y,jv,wv],he=()=>[`solid`,`dashed`,`dotted`,`double`],ge=()=>[`normal`,`multiply`,`screen`,`overlay`,`darken`,`lighten`,`color-dodge`,`color-burn`,`hard-light`,`soft-light`,`difference`,`exclusion`,`hue`,`saturation`,`color`,`luminosity`],_e=()=>[Y,mv,Nv,Ov],ve=()=>[``,`none`,m,Z,X],ye=()=>[`none`,Y,Z,X],be=()=>[`none`,Y,Z,X],O=()=>[Y,Z,X],xe=()=>[fv,`full`,...w()];return{cacheSize:500,theme:{animate:[`spin`,`ping`,`pulse`,`bounce`],aspect:[`video`],blur:[hv],breakpoint:[hv],color:[gv],container:[hv],"drop-shadow":[hv],ease:[`in`,`out`,`in-out`],font:[xv],"font-weight":[`thin`,`extralight`,`light`,`normal`,`medium`,`semibold`,`bold`,`extrabold`,`black`],"inset-shadow":[hv],leading:[`none`,`tight`,`snug`,`normal`,`relaxed`,`loose`],perspective:[`dramatic`,`near`,`normal`,`midrange`,`distant`,`none`],radius:[hv],shadow:[hv],spacing:[`px`,Y],text:[hv],"text-shadow":[hv],tracking:[`tighter`,`tight`,`normal`,`wide`,`wider`,`widest`]},classGroups:{aspect:[{aspect:[`auto`,`square`,fv,X,Z,g]}],container:[`container`],"container-type":[{"@container":[``,`normal`,`size`,Z,X]}],"container-named":[Sv],columns:[{columns:[Y,X,Z,s]}],"break-after":[{"break-after":y()}],"break-before":[{"break-before":y()}],"break-inside":[{"break-inside":[`auto`,`avoid`,`avoid-page`,`avoid-column`]}],"box-decoration":[{"box-decoration":[`slice`,`clone`]}],box:[{box:[`border`,`content`]}],display:[`block`,`inline-block`,`inline`,`flex`,`inline-flex`,`table`,`inline-table`,`table-caption`,`table-cell`,`table-column`,`table-column-group`,`table-footer-group`,`table-header-group`,`table-row-group`,`table-row`,`flow-root`,`grid`,`inline-grid`,`contents`,`list-item`,`hidden`],sr:[`sr-only`,`not-sr-only`],float:[{float:[`right`,`left`,`none`,`start`,`end`]}],clear:[{clear:[`left`,`right`,`both`,`none`,`start`,`end`]}],isolation:[`isolate`,`isolation-auto`],"object-fit":[{object:[`contain`,`cover`,`fill`,`none`,`scale-down`]}],"object-position":[{object:x()}],overflow:[{overflow:S()}],"overflow-x":[{"overflow-x":S()}],"overflow-y":[{"overflow-y":S()}],overscroll:[{overscroll:C()}],"overscroll-x":[{"overscroll-x":C()}],"overscroll-y":[{"overscroll-y":C()}],position:[`static`,`fixed`,`absolute`,`relative`,`sticky`],inset:[{inset:ee()}],"inset-x":[{"inset-x":ee()}],"inset-y":[{"inset-y":ee()}],start:[{"inset-s":ee(),start:ee()}],end:[{"inset-e":ee(),end:ee()}],"inset-bs":[{"inset-bs":ee()}],"inset-be":[{"inset-be":ee()}],top:[{top:ee()}],right:[{right:ee()}],bottom:[{bottom:ee()}],left:[{left:ee()}],visibility:[`visible`,`invisible`,`collapse`],z:[{z:[pv,`auto`,Z,X]}],basis:[{basis:[fv,`full`,`auto`,s,...w()]}],"flex-direction":[{flex:[`row`,`row-reverse`,`col`,`col-reverse`]}],"flex-wrap":[{flex:[`nowrap`,`wrap`,`wrap-reverse`]}],flex:[{flex:[Y,fv,`auto`,`initial`,`none`,X]}],grow:[{grow:[``,Y,Z,X]}],shrink:[{shrink:[``,Y,Z,X]}],order:[{order:[pv,`first`,`last`,`none`,Z,X]}],"grid-cols":[{"grid-cols":te()}],"col-start-end":[{col:T()}],"col-start":[{"col-start":ne()}],"col-end":[{"col-end":ne()}],"grid-rows":[{"grid-rows":te()}],"row-start-end":[{row:T()}],"row-start":[{"row-start":ne()}],"row-end":[{"row-end":ne()}],"grid-flow":[{"grid-flow":[`row`,`col`,`dense`,`row-dense`,`col-dense`]}],"auto-cols":[{"auto-cols":re()}],"auto-rows":[{"auto-rows":re()}],gap:[{gap:w()}],"gap-x":[{"gap-x":w()}],"gap-y":[{"gap-y":w()}],"justify-content":[{justify:[...ie(),`normal`]}],"justify-items":[{"justify-items":[...E(),`normal`]}],"justify-self":[{"justify-self":[`auto`,...E()]}],"align-content":[{content:[`normal`,...ie()]}],"align-items":[{items:[...E(),{baseline:[``,`last`]}]}],"align-self":[{self:[`auto`,...E(),{baseline:[``,`last`]}]}],"place-content":[{"place-content":ie()}],"place-items":[{"place-items":[...E(),`baseline`]}],"place-self":[{"place-self":[`auto`,...E()]}],p:[{p:w()}],px:[{px:w()}],py:[{py:w()}],ps:[{ps:w()}],pe:[{pe:w()}],pbs:[{pbs:w()}],pbe:[{pbe:w()}],pt:[{pt:w()}],pr:[{pr:w()}],pb:[{pb:w()}],pl:[{pl:w()}],m:[{m:ae()}],mx:[{mx:ae()}],my:[{my:ae()}],ms:[{ms:ae()}],me:[{me:ae()}],mbs:[{mbs:ae()}],mbe:[{mbe:ae()}],mt:[{mt:ae()}],mr:[{mr:ae()}],mb:[{mb:ae()}],ml:[{ml:ae()}],"space-x":[{"space-x":w()}],"space-x-reverse":[`space-x-reverse`],"space-y":[{"space-y":w()}],"space-y-reverse":[`space-y-reverse`],size:[{size:oe()}],"inline-size":[{inline:[`auto`,...se()]}],"min-inline-size":[{"min-inline":[`auto`,...se()]}],"max-inline-size":[{"max-inline":[`none`,...se()]}],"block-size":[{block:[`auto`,...ce()]}],"min-block-size":[{"min-block":[`auto`,...ce()]}],"max-block-size":[{"max-block":[`none`,...ce()]}],w:[{w:[s,`screen`,...oe()]}],"min-w":[{"min-w":[s,`screen`,`none`,...oe()]}],"max-w":[{"max-w":[s,`screen`,`none`,`prose`,{screen:[o]},...oe()]}],h:[{h:[`screen`,`lh`,...oe()]}],"min-h":[{"min-h":[`screen`,`lh`,`none`,...oe()]}],"max-h":[{"max-h":[`screen`,`lh`,...oe()]}],"font-size":[{text:[`base`,n,jv,wv]}],"font-smoothing":[`antialiased`,`subpixel-antialiased`],"font-style":[`italic`,`not-italic`],"font-weight":[{font:[r,Lv,Ev]}],"font-stretch":[{"font-stretch":[`ultra-condensed`,`extra-condensed`,`condensed`,`semi-condensed`,`normal`,`semi-expanded`,`expanded`,`extra-expanded`,`ultra-expanded`,mv,X]}],"font-family":[{font:[Mv,Dv,t]}],"font-features":[{"font-features":[X]}],"fvn-normal":[`normal-nums`],"fvn-ordinal":[`ordinal`],"fvn-slashed-zero":[`slashed-zero`],"fvn-figure":[`lining-nums`,`oldstyle-nums`],"fvn-spacing":[`proportional-nums`,`tabular-nums`],"fvn-fraction":[`diagonal-fractions`,`stacked-fractions`],tracking:[{tracking:[i,Z,X]}],"line-clamp":[{"line-clamp":[Y,`none`,Z,Tv]}],leading:[{leading:[a,...w()]}],"list-image":[{"list-image":[`none`,Z,X]}],"list-style-position":[{list:[`inside`,`outside`]}],"list-style-type":[{list:[`disc`,`decimal`,`none`,Z,X]}],"text-alignment":[{text:[`left`,`center`,`right`,`justify`,`start`,`end`]}],"placeholder-color":[{placeholder:D()}],"text-color":[{text:D()}],"text-decoration":[`underline`,`overline`,`line-through`,`no-underline`],"text-decoration-style":[{decoration:[...he(),`wavy`]}],"text-decoration-thickness":[{decoration:[Y,`from-font`,`auto`,Z,wv]}],"text-decoration-color":[{decoration:D()}],"underline-offset":[{"underline-offset":[Y,`auto`,Z,X]}],"text-transform":[`uppercase`,`lowercase`,`capitalize`,`normal-case`],"text-overflow":[`truncate`,`text-ellipsis`,`text-clip`],"text-wrap":[{text:[`wrap`,`nowrap`,`balance`,`pretty`]}],indent:[{indent:w()}],"tab-size":[{tab:[pv,Z,X]}],"vertical-align":[{align:[`baseline`,`top`,`middle`,`bottom`,`text-top`,`text-bottom`,`sub`,`super`,Z,X]}],whitespace:[{whitespace:[`normal`,`nowrap`,`pre`,`pre-line`,`pre-wrap`,`break-spaces`]}],break:[{break:[`normal`,`words`,`all`,`keep`]}],wrap:[{wrap:[`break-word`,`anywhere`,`normal`]}],hyphens:[{hyphens:[`none`,`manual`,`auto`]}],content:[{content:[`none`,Z,X]}],"bg-attachment":[{bg:[`fixed`,`local`,`scroll`]}],"bg-clip":[{"bg-clip":[`border`,`padding`,`content`,`text`]}],"bg-origin":[{"bg-origin":[`border`,`padding`,`content`]}],"bg-position":[{bg:le()}],"bg-repeat":[{bg:ue()}],"bg-size":[{bg:de()}],"bg-image":[{bg:[`none`,{linear:[{to:[`t`,`tr`,`r`,`br`,`b`,`bl`,`l`,`tl`]},pv,Z,X],radial:[``,Z,X],conic:[pv,Z,X]},Fv,kv]}],"bg-color":[{bg:D()}],"gradient-from-pos":[{from:fe()}],"gradient-via-pos":[{via:fe()}],"gradient-to-pos":[{to:fe()}],"gradient-from":[{from:D()}],"gradient-via":[{via:D()}],"gradient-to":[{to:D()}],rounded:[{rounded:pe()}],"rounded-s":[{"rounded-s":pe()}],"rounded-e":[{"rounded-e":pe()}],"rounded-t":[{"rounded-t":pe()}],"rounded-r":[{"rounded-r":pe()}],"rounded-b":[{"rounded-b":pe()}],"rounded-l":[{"rounded-l":pe()}],"rounded-ss":[{"rounded-ss":pe()}],"rounded-se":[{"rounded-se":pe()}],"rounded-ee":[{"rounded-ee":pe()}],"rounded-es":[{"rounded-es":pe()}],"rounded-tl":[{"rounded-tl":pe()}],"rounded-tr":[{"rounded-tr":pe()}],"rounded-br":[{"rounded-br":pe()}],"rounded-bl":[{"rounded-bl":pe()}],"border-w":[{border:me()}],"border-w-x":[{"border-x":me()}],"border-w-y":[{"border-y":me()}],"border-w-s":[{"border-s":me()}],"border-w-e":[{"border-e":me()}],"border-w-bs":[{"border-bs":me()}],"border-w-be":[{"border-be":me()}],"border-w-t":[{"border-t":me()}],"border-w-r":[{"border-r":me()}],"border-w-b":[{"border-b":me()}],"border-w-l":[{"border-l":me()}],"divide-x":[{"divide-x":me()}],"divide-x-reverse":[`divide-x-reverse`],"divide-y":[{"divide-y":me()}],"divide-y-reverse":[`divide-y-reverse`],"border-style":[{border:[...he(),`hidden`,`none`]}],"divide-style":[{divide:[...he(),`hidden`,`none`]}],"border-color":[{border:D()}],"border-color-x":[{"border-x":D()}],"border-color-y":[{"border-y":D()}],"border-color-s":[{"border-s":D()}],"border-color-e":[{"border-e":D()}],"border-color-bs":[{"border-bs":D()}],"border-color-be":[{"border-be":D()}],"border-color-t":[{"border-t":D()}],"border-color-r":[{"border-r":D()}],"border-color-b":[{"border-b":D()}],"border-color-l":[{"border-l":D()}],"divide-color":[{divide:D()}],"outline-style":[{outline:[...he(),`none`,`hidden`]}],"outline-offset":[{"outline-offset":[Y,Z,X]}],"outline-w":[{outline:[``,Y,jv,wv]}],"outline-color":[{outline:D()}],shadow:[{shadow:[``,`none`,u,Iv,Av]}],"shadow-color":[{shadow:D()}],"inset-shadow":[{"inset-shadow":[`none`,d,Iv,Av]}],"inset-shadow-color":[{"inset-shadow":D()}],"ring-w":[{ring:me()}],"ring-w-inset":[`ring-inset`],"ring-color":[{ring:D()}],"ring-offset-w":[{"ring-offset":[Y,wv]}],"ring-offset-color":[{"ring-offset":D()}],"inset-ring-w":[{"inset-ring":me()}],"inset-ring-color":[{"inset-ring":D()}],"text-shadow":[{"text-shadow":[`none`,f,Iv,Av]}],"text-shadow-color":[{"text-shadow":D()}],opacity:[{opacity:[Y,Z,X]}],"mix-blend":[{"mix-blend":[...ge(),`plus-darker`,`plus-lighter`]}],"bg-blend":[{"bg-blend":ge()}],"mask-clip":[{"mask-clip":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]},`mask-no-clip`],"mask-composite":[{mask:[`add`,`subtract`,`intersect`,`exclude`]}],"mask-image-linear-pos":[{"mask-linear":[Y]}],"mask-image-linear-from-pos":[{"mask-linear-from":_e()}],"mask-image-linear-to-pos":[{"mask-linear-to":_e()}],"mask-image-linear-from-color":[{"mask-linear-from":D()}],"mask-image-linear-to-color":[{"mask-linear-to":D()}],"mask-image-t-from-pos":[{"mask-t-from":_e()}],"mask-image-t-to-pos":[{"mask-t-to":_e()}],"mask-image-t-from-color":[{"mask-t-from":D()}],"mask-image-t-to-color":[{"mask-t-to":D()}],"mask-image-r-from-pos":[{"mask-r-from":_e()}],"mask-image-r-to-pos":[{"mask-r-to":_e()}],"mask-image-r-from-color":[{"mask-r-from":D()}],"mask-image-r-to-color":[{"mask-r-to":D()}],"mask-image-b-from-pos":[{"mask-b-from":_e()}],"mask-image-b-to-pos":[{"mask-b-to":_e()}],"mask-image-b-from-color":[{"mask-b-from":D()}],"mask-image-b-to-color":[{"mask-b-to":D()}],"mask-image-l-from-pos":[{"mask-l-from":_e()}],"mask-image-l-to-pos":[{"mask-l-to":_e()}],"mask-image-l-from-color":[{"mask-l-from":D()}],"mask-image-l-to-color":[{"mask-l-to":D()}],"mask-image-x-from-pos":[{"mask-x-from":_e()}],"mask-image-x-to-pos":[{"mask-x-to":_e()}],"mask-image-x-from-color":[{"mask-x-from":D()}],"mask-image-x-to-color":[{"mask-x-to":D()}],"mask-image-y-from-pos":[{"mask-y-from":_e()}],"mask-image-y-to-pos":[{"mask-y-to":_e()}],"mask-image-y-from-color":[{"mask-y-from":D()}],"mask-image-y-to-color":[{"mask-y-to":D()}],"mask-image-radial":[{"mask-radial":[Z,X]}],"mask-image-radial-from-pos":[{"mask-radial-from":_e()}],"mask-image-radial-to-pos":[{"mask-radial-to":_e()}],"mask-image-radial-from-color":[{"mask-radial-from":D()}],"mask-image-radial-to-color":[{"mask-radial-to":D()}],"mask-image-radial-shape":[{"mask-radial":[`circle`,`ellipse`]}],"mask-image-radial-size":[{"mask-radial":[{closest:[`side`,`corner`],farthest:[`side`,`corner`]}]}],"mask-image-radial-pos":[{"mask-radial-at":b()}],"mask-image-conic-pos":[{"mask-conic":[Y]}],"mask-image-conic-from-pos":[{"mask-conic-from":_e()}],"mask-image-conic-to-pos":[{"mask-conic-to":_e()}],"mask-image-conic-from-color":[{"mask-conic-from":D()}],"mask-image-conic-to-color":[{"mask-conic-to":D()}],"mask-mode":[{mask:[`alpha`,`luminance`,`match`]}],"mask-origin":[{"mask-origin":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]}],"mask-position":[{mask:le()}],"mask-repeat":[{mask:ue()}],"mask-size":[{mask:de()}],"mask-type":[{"mask-type":[`alpha`,`luminance`]}],"mask-image":[{mask:[`none`,Z,X]}],filter:[{filter:[``,`none`,Z,X]}],blur:[{blur:ve()}],brightness:[{brightness:[Y,Z,X]}],contrast:[{contrast:[Y,Z,X]}],"drop-shadow":[{"drop-shadow":[``,`none`,p,Iv,Av]}],"drop-shadow-color":[{"drop-shadow":D()}],grayscale:[{grayscale:[``,Y,Z,X]}],"hue-rotate":[{"hue-rotate":[Y,Z,X]}],invert:[{invert:[``,Y,Z,X]}],saturate:[{saturate:[Y,Z,X]}],sepia:[{sepia:[``,Y,Z,X]}],"backdrop-filter":[{"backdrop-filter":[``,`none`,Z,X]}],"backdrop-blur":[{"backdrop-blur":ve()}],"backdrop-brightness":[{"backdrop-brightness":[Y,Z,X]}],"backdrop-contrast":[{"backdrop-contrast":[Y,Z,X]}],"backdrop-grayscale":[{"backdrop-grayscale":[``,Y,Z,X]}],"backdrop-hue-rotate":[{"backdrop-hue-rotate":[Y,Z,X]}],"backdrop-invert":[{"backdrop-invert":[``,Y,Z,X]}],"backdrop-opacity":[{"backdrop-opacity":[Y,Z,X]}],"backdrop-saturate":[{"backdrop-saturate":[Y,Z,X]}],"backdrop-sepia":[{"backdrop-sepia":[``,Y,Z,X]}],"border-collapse":[{border:[`collapse`,`separate`]}],"border-spacing":[{"border-spacing":w()}],"border-spacing-x":[{"border-spacing-x":w()}],"border-spacing-y":[{"border-spacing-y":w()}],"table-layout":[{table:[`auto`,`fixed`]}],caption:[{caption:[`top`,`bottom`]}],transition:[{transition:[``,`all`,`colors`,`opacity`,`shadow`,`transform`,`none`,Z,X]}],"transition-behavior":[{transition:[`normal`,`discrete`]}],duration:[{duration:[Y,`initial`,Z,X]}],ease:[{ease:[`linear`,`initial`,_,Z,X]}],delay:[{delay:[Y,Z,X]}],animate:[{animate:[`none`,v,Z,X]}],backface:[{backface:[`hidden`,`visible`]}],perspective:[{perspective:[h,Z,X]}],"perspective-origin":[{"perspective-origin":x()}],rotate:[{rotate:ye()}],"rotate-x":[{"rotate-x":ye()}],"rotate-y":[{"rotate-y":ye()}],"rotate-z":[{"rotate-z":ye()}],scale:[{scale:be()}],"scale-x":[{"scale-x":be()}],"scale-y":[{"scale-y":be()}],"scale-z":[{"scale-z":be()}],"scale-3d":[`scale-3d`],skew:[{skew:O()}],"skew-x":[{"skew-x":O()}],"skew-y":[{"skew-y":O()}],transform:[{transform:[Z,X,``,`none`,`gpu`,`cpu`]}],"transform-origin":[{origin:x()}],"transform-style":[{transform:[`3d`,`flat`]}],translate:[{translate:xe()}],"translate-x":[{"translate-x":xe()}],"translate-y":[{"translate-y":xe()}],"translate-z":[{"translate-z":xe()}],"translate-none":[`translate-none`],zoom:[{zoom:[pv,Z,X]}],accent:[{accent:D()}],appearance:[{appearance:[`none`,`auto`]}],"caret-color":[{caret:D()}],"color-scheme":[{scheme:[`normal`,`dark`,`light`,`light-dark`,`only-dark`,`only-light`]}],cursor:[{cursor:[`auto`,`default`,`pointer`,`wait`,`text`,`move`,`help`,`not-allowed`,`none`,`context-menu`,`progress`,`cell`,`crosshair`,`vertical-text`,`alias`,`copy`,`no-drop`,`grab`,`grabbing`,`all-scroll`,`col-resize`,`row-resize`,`n-resize`,`e-resize`,`s-resize`,`w-resize`,`ne-resize`,`nw-resize`,`se-resize`,`sw-resize`,`ew-resize`,`ns-resize`,`nesw-resize`,`nwse-resize`,`zoom-in`,`zoom-out`,Z,X]}],"field-sizing":[{"field-sizing":[`fixed`,`content`]}],"pointer-events":[{"pointer-events":[`auto`,`none`]}],resize:[{resize:[`none`,``,`y`,`x`]}],"scroll-behavior":[{scroll:[`auto`,`smooth`]}],"scrollbar-thumb-color":[{"scrollbar-thumb":D()}],"scrollbar-track-color":[{"scrollbar-track":D()}],"scrollbar-gutter":[{"scrollbar-gutter":[`auto`,`stable`,`both`]}],"scrollbar-w":[{scrollbar:[`auto`,`thin`,`none`]}],"scroll-m":[{"scroll-m":w()}],"scroll-mx":[{"scroll-mx":w()}],"scroll-my":[{"scroll-my":w()}],"scroll-ms":[{"scroll-ms":w()}],"scroll-me":[{"scroll-me":w()}],"scroll-mbs":[{"scroll-mbs":w()}],"scroll-mbe":[{"scroll-mbe":w()}],"scroll-mt":[{"scroll-mt":w()}],"scroll-mr":[{"scroll-mr":w()}],"scroll-mb":[{"scroll-mb":w()}],"scroll-ml":[{"scroll-ml":w()}],"scroll-p":[{"scroll-p":w()}],"scroll-px":[{"scroll-px":w()}],"scroll-py":[{"scroll-py":w()}],"scroll-ps":[{"scroll-ps":w()}],"scroll-pe":[{"scroll-pe":w()}],"scroll-pbs":[{"scroll-pbs":w()}],"scroll-pbe":[{"scroll-pbe":w()}],"scroll-pt":[{"scroll-pt":w()}],"scroll-pr":[{"scroll-pr":w()}],"scroll-pb":[{"scroll-pb":w()}],"scroll-pl":[{"scroll-pl":w()}],"snap-align":[{snap:[`start`,`end`,`center`,`align-none`]}],"snap-stop":[{snap:[`normal`,`always`]}],"snap-type":[{snap:[`none`,`x`,`y`,`both`]}],"snap-strictness":[{snap:[`mandatory`,`proximity`]}],touch:[{touch:[`auto`,`none`,`manipulation`]}],"touch-x":[{"touch-pan":[`x`,`left`,`right`]}],"touch-y":[{"touch-pan":[`y`,`up`,`down`]}],"touch-pz":[`touch-pinch-zoom`],select:[{select:[`none`,`text`,`all`,`auto`]}],"will-change":[{"will-change":[`auto`,`scroll`,`contents`,`transform`,Z,X]}],fill:[{fill:[`none`,...D()]}],"stroke-w":[{stroke:[Y,jv,wv,Tv]}],stroke:[{stroke:[`none`,...D()]}],"forced-color-adjust":[{"forced-color-adjust":[`auto`,`none`]}]},conflictingClassGroups:{"container-named":[`container-type`],overflow:[`overflow-x`,`overflow-y`],overscroll:[`overscroll-x`,`overscroll-y`],inset:[`inset-x`,`inset-y`,`inset-bs`,`inset-be`,`start`,`end`,`top`,`right`,`bottom`,`left`],"inset-x":[`right`,`left`],"inset-y":[`top`,`bottom`],flex:[`basis`,`grow`,`shrink`],gap:[`gap-x`,`gap-y`],p:[`px`,`py`,`ps`,`pe`,`pbs`,`pbe`,`pt`,`pr`,`pb`,`pl`],px:[`pr`,`pl`],py:[`pt`,`pb`],m:[`mx`,`my`,`ms`,`me`,`mbs`,`mbe`,`mt`,`mr`,`mb`,`ml`],mx:[`mr`,`ml`],my:[`mt`,`mb`],size:[`w`,`h`],"font-size":[`leading`],"fvn-normal":[`fvn-ordinal`,`fvn-slashed-zero`,`fvn-figure`,`fvn-spacing`,`fvn-fraction`],"fvn-ordinal":[`fvn-normal`],"fvn-slashed-zero":[`fvn-normal`],"fvn-figure":[`fvn-normal`],"fvn-spacing":[`fvn-normal`],"fvn-fraction":[`fvn-normal`],"line-clamp":[`display`,`overflow`],rounded:[`rounded-s`,`rounded-e`,`rounded-t`,`rounded-r`,`rounded-b`,`rounded-l`,`rounded-ss`,`rounded-se`,`rounded-ee`,`rounded-es`,`rounded-tl`,`rounded-tr`,`rounded-br`,`rounded-bl`],"rounded-s":[`rounded-ss`,`rounded-es`],"rounded-e":[`rounded-se`,`rounded-ee`],"rounded-t":[`rounded-tl`,`rounded-tr`],"rounded-r":[`rounded-tr`,`rounded-br`],"rounded-b":[`rounded-br`,`rounded-bl`],"rounded-l":[`rounded-tl`,`rounded-bl`],"border-spacing":[`border-spacing-x`,`border-spacing-y`],"border-w":[`border-w-x`,`border-w-y`,`border-w-s`,`border-w-e`,`border-w-bs`,`border-w-be`,`border-w-t`,`border-w-r`,`border-w-b`,`border-w-l`],"border-w-x":[`border-w-r`,`border-w-l`],"border-w-y":[`border-w-t`,`border-w-b`],"border-color":[`border-color-x`,`border-color-y`,`border-color-s`,`border-color-e`,`border-color-bs`,`border-color-be`,`border-color-t`,`border-color-r`,`border-color-b`,`border-color-l`],"border-color-x":[`border-color-r`,`border-color-l`],"border-color-y":[`border-color-t`,`border-color-b`],translate:[`translate-x`,`translate-y`,`translate-none`],"translate-none":[`translate`,`translate-x`,`translate-y`,`translate-z`],"scroll-m":[`scroll-mx`,`scroll-my`,`scroll-ms`,`scroll-me`,`scroll-mbs`,`scroll-mbe`,`scroll-mt`,`scroll-mr`,`scroll-mb`,`scroll-ml`],"scroll-mx":[`scroll-mr`,`scroll-ml`],"scroll-my":[`scroll-mt`,`scroll-mb`],"scroll-p":[`scroll-px`,`scroll-py`,`scroll-ps`,`scroll-pe`,`scroll-pbs`,`scroll-pbe`,`scroll-pt`,`scroll-pr`,`scroll-pb`,`scroll-pl`],"scroll-px":[`scroll-pr`,`scroll-pl`],"scroll-py":[`scroll-pt`,`scroll-pb`],touch:[`touch-x`,`touch-y`,`touch-pz`],"touch-x":[`touch`],"touch-y":[`touch`],"touch-pz":[`touch`]},conflictingClassGroupModifiers:{"font-size":[`leading`]},postfixLookupClassGroups:[`container-type`],orderSensitiveModifiers:[`*`,`**`,`after`,`backdrop`,`before`,`details-content`,`file`,`first-letter`,`first-line`,`marker`,`placeholder`,`selection`]}});function Yv(...e){return Jv(b_(e))}var Xv=F({__name:`Alert`,props:{class:{type:[Boolean,null,String,Object,Array]},variant:{}},setup(e){let t=e;return(n,r)=>(R(),z(`div`,{"data-slot":`alert`,class:O(N(Yv)(N($v)({variant:e.variant}),t.class)),role:`alert`},[I(n.$slots,`default`)],2))}}),Zv=F({__name:`AlertDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`alert-description`,class:O(N(Yv)(`text-muted-foreground text-sm text-balance md:text-pretty [&_p:not(:last-child)]:mb-4 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[I(e.$slots,`default`)],2))}}),Qv=F({__name:`AlertTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`alert-title`,class:O(N(Yv)(`font-medium group-has-[>svg]/alert:col-start-2 cn-font-heading [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[I(e.$slots,`default`)],2))}}),$v=C_(`grid gap-0.5 rounded-lg border px-2.5 py-2 text-left text-sm has-data-[slot=alert-action]:relative has-data-[slot=alert-action]:pr-18 has-[>svg]:grid-cols-[auto_1fr] has-[>svg]:gap-x-2 *:[svg]:row-span-2 *:[svg]:translate-y-0.5 *:[svg]:text-current *:[svg:not([class*=size-])]:size-4 group/alert relative w-full`,{variants:{variant:{default:`bg-card text-card-foreground`,destructive:`text-destructive bg-card *:data-[slot=alert-description]:text-destructive/90 *:[svg]:text-current`}},defaultVariants:{variant:`default`}});function ey(e){return typeof e==`string`?`'${e}'`:new iy().serialize(e)}var ty=` _-,;:!?.'"()[]{}@*/\\&#%\`^+<=>|~$0123456789abcdefghijklmnopqrstuvwxyz`,ny=(function(){let e=new Uint8Array(128);for(let t=0;t<69;t++)e[ty.charCodeAt(t)]=t+1;for(let t=65;t<=90;t++)e[t]=e[t+32];return e})();function ry(e,t){if(e===t)return 0;let n=Math.min(e.length,t.length),r=0;for(let i=0;i<n;i++){let n=e.charCodeAt(i),a=t.charCodeAt(i);if(n===a)continue;let o=n<128&&ny[n]?ny[n]:n+128,s=a<128&&ny[a]?ny[a]:a+128;if(o!==s)return o<s?-1:1;r===0&&(r=n>a?-1:1)}return e.length===t.length?r:e.length<t.length?-1:1}var iy=(function(){class e{#e=new Map;compare(e,t){let n=typeof e,r=typeof t;return n===`string`&&r===`string`?ry(e,t):n===`number`&&r===`number`?e-t:ry(this.serialize(e,!0),this.serialize(t,!0))}serialize(e,t){if(e===null)return`null`;switch(typeof e){case`string`:return t?e:`'${e}'`;case`bigint`:return`${e}n`;case`object`:return this.$object(e);case`function`:return this.$function(e)}return String(e)}serializeObject(e){let t=Object.prototype.toString.call(e);if(t!==`[object Object]`)return this.serializeBuiltInType(t.length<10?`unknown:${t}`:t.slice(8,-1),e);let n=e.constructor,r=n===Object||n===void 0?``:n.name;if(r!==``&&globalThis[r]===n)return this.serializeBuiltInType(r,e);if(`toJSON`in e&&typeof e.toJSON==`function`){let t=e.toJSON();return r+(typeof t==`object`&&t?this.$object(t):`(${this.serialize(t)})`)}let i=Object.keys(e).sort(ry),a=`${r}{`;for(let t=0;t<i.length;t++){let n=i[t];a+=`${n}:${this.serialize(e[n])}`,t<i.length-1&&(a+=`,`)}return a+`}`}serializeBuiltInType(e,t){let n=this[`$`+e];if(n)return n.call(this,t);if(typeof t.entries==`function`)return this.serializeObjectEntries(e,t.entries());throw Error(`Cannot serialize ${e}`)}serializeObjectEntries(e,t){let n=Array.from(t).sort((e,t)=>this.compare(e[0],t[0])),r=`${e}{`;for(let e=0;e<n.length;e++){let[t,i]=n[e];r+=`${this.serialize(t,!0)}:${this.serialize(i)}`,e<n.length-1&&(r+=`,`)}return r+`}`}$object(e){let t=this.#e.get(e);return t===void 0&&(this.#e.set(e,`#${this.#e.size}`),t=this.serializeObject(e),this.#e.set(e,t)),t}$function(e){let t=Function.prototype.toString.call(e);return t.slice(-15)===`[native code] }`?`${e.name||``}()[native]`:`${e.name}(${e.length})${t.replace(/\s*\n\s*/g,``)}`}$Array(e){let t=`[`;for(let n=0;n<e.length;n++)t+=this.serialize(e[n]),n<e.length-1&&(t+=`,`);return t+`]`}$Date(e){try{return`Date(${e.toISOString()})`}catch{return`Date(null)`}}$ArrayBuffer(e){return`ArrayBuffer[${new Uint8Array(e).join(`,`)}]`}$Set(e){return`Set${this.$Array(Array.from(e).sort((e,t)=>this.compare(e,t)))}`}$Map(e){return this.serializeObjectEntries(`Map`,e.entries())}}for(let t of[`Error`,`RegExp`,`URL`])e.prototype[`$`+t]=function(e){return`${t}(${e})`};for(let t of[`Int8Array`,`Uint8Array`,`Uint8ClampedArray`,`Int16Array`,`Uint16Array`,`Int32Array`,`Uint32Array`,`Float32Array`,`Float64Array`])e.prototype[`$`+t]=function(e){return`${t}[${e.join(`,`)}]`};for(let t of[`BigInt64Array`,`BigUint64Array`])e.prototype[`$`+t]=function(e){return`${t}[${e.join(`n,`)}${e.length>0?`n`:``}]`};return e})();function ay(e,t){return e===t||ey(e)===ey(t)}function oy(e,t){let n=typeof e==`string`&&!t?`${e}Context`:t,r=Symbol(n);return[t=>{let n=yr(r,t);if(n||n===null)return n;throw Error(`Injection \`${r.toString()}\` not found. Component must be used within ${Array.isArray(e)?`one of the following components: ${e.join(`, `)}`:`\`${e}\``}`)},e=>(vr(r,e),e)]}function sy(){let e=document.activeElement;if(e==null)return null;for(;e!=null&&e.shadowRoot!=null&&e.shadowRoot.activeElement!=null;)e=e.shadowRoot.activeElement;return e}function cy(e){return e==null}function ly(e,t){return cy(e)?!1:Array.isArray(e)?e.some(e=>ay(e,t)):ay(e,t)}function uy(e,t){return Fe()?(Ie(e,t),!0):!1}function dy(e){let t=!1,n,r=Pe(!0);return((...i)=>(t||=(n=r.run(()=>e(...i)),!0),n))}var fy=typeof window<`u`&&typeof document<`u`;typeof WorkerGlobalScope<`u`&&globalThis instanceof WorkerGlobalScope;var py=e=>e!==void 0,my=Object.prototype.toString,hy=e=>my.call(e)===`[object Object]`,gy=_y();function _y(){var e,t;return fy&&!!((e=window)!=null&&(e=e.navigator)!=null&&e.userAgent)&&(/iP(?:ad|hone|od)/.test(window.navigator.userAgent)||((t=window)==null||(t=t.navigator)==null?void 0:t.maxTouchPoints)>2&&/iPad|Macintosh/.test(window?.navigator.userAgent))}function vy(e){return Array.isArray(e)?e:[e]}function yy(e){return e||Fs()}function by(e){if(!fy)return e;let t=0,n,r,i=()=>{--t,r&&t<=0&&(r.stop(),n=void 0,r=void 0)};return((...a)=>(t+=1,r||(r=Pe(!0),n=r.run(()=>e(...a))),uy(i),n))}function xy(e){return Zt(j(e)?new Proxy({},{get(t,n,r){return N(Reflect.get(e.value,n,r))},set(t,n,r){return j(e.value[n])&&!j(r)?e.value[n].value=r:e.value[n]=r,!0},deleteProperty(t,n){return Reflect.deleteProperty(e.value,n)},has(t,n){return Reflect.has(e.value,n)},ownKeys(){return Object.keys(e.value)},getOwnPropertyDescriptor(){return{enumerable:!0,configurable:!0}}}):e)}function Sy(e){return xy(W(e))}function Cy(e,...t){let n=t.flat(),r=n[0];return Sy(()=>Object.fromEntries(typeof r==`function`?Object.entries(yn(e)).filter(([e,t])=>!r(mn(t),e)):Object.entries(yn(e)).filter(e=>!n.includes(e[0]))))}function wy(e,t=1e4){return vn((n,r)=>{let i=mn(e),a,o=()=>setTimeout(()=>{i=mn(e),r()},mn(t));return uy(()=>{clearTimeout(a)}),{get(){return n(),i},set(e){i=e,r(),clearTimeout(a),a=o()}}})}function Ty(e,t){yy(t)&&ea(e,t)}function Ey(e,t,n){return Er(e,t,{...n,immediate:!0})}var Dy=fy?window:void 0;fy&&window.document,fy&&window.navigator,fy&&window.location;function Oy(e){let t=mn(e);return t?.$el??t}function ky(...e){let t=(e,t,n,r)=>(e.addEventListener(t,n,r),()=>e.removeEventListener(t,n,r)),n=W(()=>{let t=vy(mn(e[0])).filter(e=>e!=null);return t.every(e=>typeof e!=`string`)?t:void 0});return Ey(()=>[n.value?.map(e=>Oy(e))??[Dy].filter(e=>e!=null),vy(mn(n.value?e[1]:e[0])),vy(N(n.value?e[2]:e[1])),mn(n.value?e[3]:e[2])],([e,n,r,i],a,o)=>{if(!e?.length||!n?.length||!r?.length)return;let s=hy(i)?{...i}:i,c=e.flatMap(e=>n.flatMap(n=>r.map(r=>t(e,n,r,s))));o(()=>{c.forEach(e=>e())})},{flush:`post`})}function Ay(){let e=un(!1),t=Fs();return t&&Zi(()=>{e.value=!0},t),e}function jy(e){let t=Ay();return W(()=>(t.value,!!e()))}function My(e){return typeof e==`function`?e:typeof e==`string`?t=>t.key===e:Array.isArray(e)?t=>e.includes(t.key):()=>!0}function Ny(...e){let t,n,r={};e.length===3?(t=e[0],n=e[1],r=e[2]):e.length===2?typeof e[1]==`object`?(t=!0,n=e[0],r=e[1]):(t=e[0],n=e[1]):(t=!0,n=e[0]);let{target:i=Dy,eventName:a=`keydown`,passive:o=!1,dedupe:s=!1}=r,c=My(t);return ky(i,a,e=>{e.repeat&&mn(s)||c(e)&&n(e)},o)}function Py(e){return JSON.parse(JSON.stringify(e))}function Fy(e,t,n={}){let{window:r=Dy,...i}=n,a,o=jy(()=>r&&`ResizeObserver`in r),s=()=>{a&&=(a.disconnect(),void 0)},c=Er(W(()=>{let t=mn(e);return Array.isArray(t)?t.map(e=>Oy(e)):[Oy(t)]}),e=>{if(s(),o.value&&r){a=new ResizeObserver(t);for(let t of e)t&&a.observe(t,i)}},{immediate:!0,flush:`post`}),l=()=>{s(),c()};return uy(l),{isSupported:o,stop:l}}function Iy(e,t,n,r={}){var i,a;let{clone:o=!1,passive:s=!1,eventName:c,deep:l=!1,defaultValue:u,shouldEmit:d}=r,f=Fs(),p=n||f?.emit||(f==null||(i=f.$emit)==null?void 0:i.bind(f))||(f==null||(a=f.proxy)==null||(a=a.$emit)==null?void 0:a.bind(f?.proxy)),m=c;t||=`modelValue`,m||=`update:${t.toString()}`;let h=e=>o?typeof o==`function`?o(e):Py(e):e,g=()=>py(e[t])?h(e[t]):u,_=e=>{d?d(e)&&p(m,e):p(m,e)};if(s){let n=M(g()),r=!1;return Er(()=>e[t],e=>{r||(r=!0,n.value=h(e),Qn(()=>r=!1))}),Er(n,n=>{!r&&(n!==e[t]||l)&&_(n)},{deep:l}),n}return W({get(){return g()},set(e){_(e)}})}function Ly(e){return e?e.flatMap(e=>e.type===L?Ly(e.children):[e]):[]}var Ry=[`INPUT`,`TEXTAREA`];function zy(e,t,n,r={}){if(!t||r.enableIgnoredElement&&Ry.includes(t.nodeName))return null;let{arrowKeyOptions:i=`both`,attributeName:a=`[data-reka-collection-item]`,itemsArray:o=[],loop:s=!0,dir:c=`ltr`,preventScroll:l=!0,focus:u=!1}=r,[d,f,p,m,h,g]=[e.key===`ArrowRight`,e.key===`ArrowLeft`,e.key===`ArrowUp`,e.key===`ArrowDown`,e.key===`Home`,e.key===`End`],_=p||m,v=d||f;if(!h&&!g&&(!_&&!v||i===`vertical`&&v||i===`horizontal`&&_))return null;let y=n?Array.from(n.querySelectorAll(a)):o;if(!y.length)return null;l&&e.preventDefault();let b=null;return v||_?b=By(y,t,{goForward:_?m:c===`ltr`?d:f,loop:s}):h?b=y.at(0)||null:g&&(b=y.at(-1)||null),u&&b?.focus(),b}function By(e,t,n,r=e.includes(t)?e.length:e.length+1){if(--r===0)return null;let i=e.indexOf(t),a;if(a=i===-1?n.goForward?0:e.length-1:n.goForward?i+1:i-1,!n.loop&&(a<0||a>=e.length))return null;let o=e[(a+e.length)%e.length];return o?o.hasAttribute(`disabled`)&&o.getAttribute(`disabled`)!==`false`?By(e,o,n,r):o:null}var[Vy,Hy]=oy(`ConfigProvider`);function Uy(e){let t=Vy({dir:M(`ltr`)});return W(()=>e?.value||t.dir?.value||`ltr`)}function Wy(e){let t=Fs(),n=t?.type.emits,r={};return n?.length||console.warn(`No emitted event found. Please check component: ${t?.type.__name}`),n?.forEach(t=>{r[ce(E(t))]=(...n)=>e(t,...n)}),r}function Gy(){let e=Fs(),t=M(),n=W(()=>r());$i(()=>{n.value!==r()&&pn(t)});function r(){return t.value&&`$el`in t.value&&[`#text`,`#comment`].includes(t.value.$el.nodeName)?t.value.$el.nextElementSibling:Oy(t)}let i=Object.assign({},e.exposed),a={};for(let t in e.props)Object.defineProperty(a,t,{enumerable:!0,configurable:!0,get:()=>e.props[t]});if(Object.keys(i).length>0)for(let e in i)Object.defineProperty(a,e,{enumerable:!0,configurable:!0,get:()=>i[e]});Object.defineProperty(a,"$el",{enumerable:!0,configurable:!0,get:()=>e.vnode.el}),e.exposed=a;function o(n){if(t.value=n,n&&(Object.defineProperty(a,"$el",{enumerable:!0,configurable:!0,get:()=>n instanceof Element?n:n.$el}),!(n instanceof Element)&&!Object.hasOwn(n,`$el`))){let t=n.$.exposed,r=Object.assign({},a);for(let e in t)Object.defineProperty(r,e,{enumerable:!0,configurable:!0,get:()=>t[e]});e.exposed=r}}return{forwardRef:o,currentRef:t,currentElement:n}}function Ky(e){let t=Fs(),n=Object.keys(t?.type.props??{}).reduce((e,n)=>{let r=(t?.type.props[n]).default;return r!==void 0&&(e[n]=r),e},{}),r=Sn(e);return W(()=>{let e={},i=t?.vnode.props??{};return Object.keys(i).forEach(t=>{e[E(t)]=i[t]}),Object.keys({...n,...e}).reduce((e,t)=>(r.value[t]!==void 0&&(e[t]=r.value[t]),e),{})})}function qy(e,t){let n=Ky(e),r=t?Wy(t):{};return W(()=>({...n.value,...r}))}var Jy=0;function Yy(e,t=`reka`){if(e)return e;let n,r=Vy({useId:void 0});return n=r.useId?r.useId():`useId`in bu?ai?.():`${++Jy}`,t?`${t}-${n}`:n}function Xy(e,t){let n=M(e);function r(e){return t[n.value][e]??n.value}return{state:n,dispatch:e=>{n.value=r(e)}}}function Zy(e,t){let n=M({}),r=M(`none`),i=M(e),a=e.value?`mounted`:`unmounted`,o,s=t.value?.ownerDocument.defaultView??Dy,{state:c,dispatch:l}=Xy(a,{mounted:{UNMOUNT:`unmounted`,ANIMATION_OUT:`unmountSuspended`},unmountSuspended:{MOUNT:`mounted`,ANIMATION_END:`unmounted`},unmounted:{MOUNT:`mounted`}}),u=e=>{if(fy){let n=new CustomEvent(e,{bubbles:!1,cancelable:!1});t.value?.dispatchEvent(n)}};Er(e,async(e,i)=>{let a=i!==e;if(await Qn(),a){let a=r.value,o=Qy(t.value);e?(l(`MOUNT`),u(`enter`),o===`none`&&u(`after-enter`)):o===`none`||o===`undefined`||n.value?.display===`none`?(l(`UNMOUNT`),u(`leave`),u(`after-leave`)):i&&a!==o?(l(`ANIMATION_OUT`),u(`leave`)):(l(`UNMOUNT`),u(`after-leave`))}},{immediate:!0});let d=e=>{if(e.target!==t.value)return;let n=Qy(t.value),r=n.includes(CSS.escape(e.animationName)),a=c.value===`mounted`?`enter`:`leave`;if(r&&(u(`after-${a}`),l(`ANIMATION_END`),!i.value)){let e=t.value.style.animationFillMode;t.value.style.animationFillMode=`forwards`,o=s?.setTimeout(()=>{t.value?.style.animationFillMode===`forwards`&&(t.value.style.animationFillMode=e)})}n===`none`&&l(`ANIMATION_END`)},f=e=>{e.target===t.value&&(r.value=Qy(t.value))},p=Er(t,(e,t)=>{e?(n.value=getComputedStyle(e),e.addEventListener(`animationstart`,f),e.addEventListener(`animationcancel`,d),e.addEventListener(`animationend`,d)):(l(`ANIMATION_END`),o!==void 0&&s?.clearTimeout(o),t?.removeEventListener(`animationstart`,f),t?.removeEventListener(`animationcancel`,d),t?.removeEventListener(`animationend`,d))},{immediate:!0}),m=Er(c,()=>{let e=Qy(t.value);r.value=c.value===`mounted`?e:`none`});return ta(()=>{p(),m(),t.value&&(t.value.removeEventListener(`animationstart`,f),t.value.removeEventListener(`animationcancel`,d),t.value.removeEventListener(`animationend`,d)),o!==void 0&&s?.clearTimeout(o)}),{isPresent:W(()=>[`mounted`,`unmountSuspended`].includes(c.value))}}function Qy(e){return e&&getComputedStyle(e).animationName||`none`}var $y=F({name:`Presence`,props:{present:{type:Boolean,required:!0},forceMount:{type:Boolean}},slots:{},setup(e,{slots:t,expose:n}){let{present:r,forceMount:i}=yn(e),a=M(),{isPresent:o}=Zy(r,a);n({present:o});let s=t.default({present:o.value});s=Ly(s||[]);let c=Fs();if(s&&s?.length>1){let e=c?.parent?.type.name?`<${c.parent.type.name} />`:`component`;throw Error([`Detected an invalid children for \`${e}\` for  \`Presence\` component.`,``,"Note: Presence works similarly to `v-if` directly, but it waits for animation/transition to finished before unmounting. So it expect only one direct child of valid VNode type.",`You can apply a few solutions:`,["Provide a single child element so that `presence` directive attach correctly.",`Ensure the first child is an actual element instead of a raw text node or comment node.`].map(e=>`  - ${e}`).join(`
`)].join(`
`))}return()=>i.value||r.value||o.value?G(t.default({present:o.value})[0],{ref:e=>{let t=Oy(e);return t?.hasAttribute===void 0||(t?.hasAttribute(`data-reka-popper-content-wrapper`)?a.value=t.firstElementChild:a.value=t),t}}):null}}),eb=F({name:`PrimitiveSlot`,inheritAttrs:!1,setup(e,{attrs:t,slots:n}){return()=>{if(!n.default)return null;let e=Ly(n.default()),r=e.findIndex(e=>e.type!==cs);if(r===-1)return e;let i=e[r];delete i.props?.ref;let a=i.props?ks(t,i.props):t,o=Cs({...i,props:{}},a);return e.length===1?o:(e[r]=o,e)}}}),tb=[`area`,`img`,`input`],nb=F({name:`Primitive`,inheritAttrs:!1,props:{asChild:{type:Boolean,default:!1},as:{type:[String,Object],default:`div`}},setup(e,{attrs:t,slots:n}){let r=e.asChild?`template`:e.as;return typeof r==`string`&&tb.includes(r)?()=>G(r,t):r===`template`?()=>G(eb,t,{default:n.default}):()=>G(e.as,t,{default:n.default})}});function rb(){let e=M();return{primitiveElement:e,currentElement:W(()=>[`#text`,`#comment`].includes(e.value?.$el.nodeName)?e.value?.$el.nextElementSibling:Oy(e))}}var[ib,ab]=oy(`CollapsibleRoot`),ob=F({__name:`CollapsibleRoot`,props:{defaultOpen:{type:Boolean,required:!1,default:!1},open:{type:Boolean,required:!1,default:void 0},disabled:{type:Boolean,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:open`],setup(e,{expose:t,emit:n}){let r=e,i=Iy(r,`open`,n,{defaultValue:r.defaultOpen,passive:r.open===void 0}),{disabled:a,unmountOnHide:o}=yn(r);return ab({contentId:``,disabled:a,open:i,unmountOnHide:o,onOpenToggle:()=>{a.value||(i.value=!i.value)}}),t({open:i}),Gy(),(e,t)=>(R(),B(N(nb),{as:e.as,"as-child":r.asChild,"data-state":N(i)?`open`:`closed`,"data-disabled":N(a)?``:void 0},{default:P(()=>[I(e.$slots,`default`,{open:N(i)})]),_:3},8,[`as`,`as-child`,`data-state`,`data-disabled`]))}}),sb=F({inheritAttrs:!1,__name:`CollapsibleContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`contentFound`],setup(e,{emit:t}){let n=e,r=t,i=ib();i.contentId||=Yy(void 0,`reka-collapsible-content`);let a=M(),{forwardRef:o,currentElement:s}=Gy(),c=M(0),l=M(0),u=W(()=>i.open.value),d=M(u.value),f=M();Er(()=>[u.value,a.value?.present],async()=>{await Qn();let e=s.value;if(!e)return;f.value=f.value||{transitionDuration:e.style.transitionDuration,animationName:e.style.animationName},e.style.transitionDuration=`0s`,e.style.animationName=`none`;let t=e.getBoundingClientRect();l.value=t.height,c.value=t.width,d.value||(e.style.transitionDuration=f.value.transitionDuration,e.style.animationName=f.value.animationName)},{immediate:!0});let p=W(()=>d.value&&i.open.value);return Zi(()=>{requestAnimationFrame(()=>{d.value=!1})}),ky(s,`beforematch`,e=>{requestAnimationFrame(()=>{i.onOpenToggle(),r(`contentFound`)})}),(e,t)=>(R(),B(N($y),{ref_key:`presentRef`,ref:a,present:e.forceMount||N(i).open.value,"force-mount":!0},{default:P(({present:t})=>[H(N(nb),ks(e.$attrs,{id:N(i).contentId,ref:N(o),"as-child":n.asChild,as:e.as,hidden:t?void 0:N(i).unmountOnHide.value?``:`until-found`,"data-state":p.value?void 0:N(i).open.value?`open`:`closed`,"data-disabled":N(i).disabled?.value?``:void 0,style:{"--reka-collapsible-content-height":`${l.value}px`,"--reka-collapsible-content-width":`${c.value}px`}}),{default:P(()=>[!N(i).unmountOnHide.value||t?I(e.$slots,`default`,{key:0}):Ts(`v-if`,!0)]),_:2},1040,[`id`,`as-child`,`as`,`hidden`,`data-state`,`data-disabled`,`style`])]),_:3},8,[`present`]))}}),cb=F({__name:`CollapsibleTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e;Gy();let n=ib();return(e,r)=>(R(),B(N(nb),{type:e.as===`button`?`button`:void 0,as:e.as,"as-child":t.asChild,"aria-controls":N(n).contentId,"aria-expanded":N(n).open.value,"data-state":N(n).open.value?`open`:`closed`,"data-disabled":N(n).disabled?.value?``:void 0,disabled:N(n).disabled?.value,onClick:N(n).onOpenToggle},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`type`,`as`,`as-child`,`aria-controls`,`aria-expanded`,`data-state`,`data-disabled`,`disabled`,`onClick`]))}});function lb({type:e,defaultValue:t,modelValue:n}){let r=n||t;return n!==void 0||t!==void 0?Array.isArray(r)?`multiple`:`single`:e??`single`}function ub({type:e,defaultValue:t,modelValue:n}){return e||lb({type:e,defaultValue:t,modelValue:n})}function db({type:e,defaultValue:t}){return t===void 0?e===`single`?void 0:[]:t}function fb(e,t){let n=W(()=>ub(e)),r=Iy(e,`modelValue`,t,{defaultValue:db(e),passive:e.modelValue===void 0,deep:!0});function i(e){if(n.value===`single`)r.value=ay(e,r.value)?void 0:e;else{let t=Array.isArray(r.value)?[...r.value||[]]:[r.value].filter(Boolean);if(ly(t,e)){let n=t.findIndex(t=>ay(t,e));t.splice(n,1)}else t.push(e);r.value=t}}return{modelValue:r,changeModelValue:i,isSingle:W(()=>n.value===`single`)}}var[pb,mb]=oy(`AccordionRoot`),hb=F({__name:`AccordionRoot`,props:{collapsible:{type:Boolean,required:!1,default:!1},disabled:{type:Boolean,required:!1,default:!1},dir:{type:String,required:!1},orientation:{type:String,required:!1,default:`vertical`},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},type:{type:String,required:!1},modelValue:{type:null,required:!1},defaultValue:{type:null,required:!1}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,{dir:i,disabled:a,unmountOnHide:o}=yn(n),s=Uy(i),{modelValue:c,changeModelValue:l,isSingle:u}=fb(n,r),{forwardRef:d,currentElement:f}=Gy();return mb({disabled:a,direction:s,orientation:n.orientation,parentElement:f,isSingle:u,collapsible:n.collapsible,modelValue:c,changeModelValue:l,unmountOnHide:o}),(e,t)=>(R(),B(N(nb),{ref:N(d),"as-child":e.asChild,as:e.as},{default:P(()=>[I(e.$slots,`default`,{modelValue:N(c)})]),_:3},8,[`as-child`,`as`]))}}),gb=function(e){return e.Open=`open`,e.Closed=`closed`,e}(gb||{}),[_b,vb]=oy(`AccordionItem`),yb=F({__name:`AccordionItem`,props:{disabled:{type:Boolean,required:!1},value:{type:String,required:!0},unmountOnHide:{type:Boolean,required:!1,default:void 0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e,{expose:t}){let n=e,r=pb(),i=W(()=>r.isSingle.value?n.value===r.modelValue.value:Array.isArray(r.modelValue.value)&&r.modelValue.value.includes(n.value)),a=W(()=>r.disabled.value||n.disabled),o=W(()=>a.value?``:void 0),s=W(()=>i.value?gb.Open:gb.Closed);t({open:i,dataDisabled:o});let{currentRef:c,currentElement:l}=Gy();vb({open:i,dataState:s,disabled:a,dataDisabled:o,triggerId:``,currentRef:c,currentElement:l,value:W(()=>n.value)});function u(e){let t=e.target;if(Array.from(r.parentElement.value?.querySelectorAll(`[data-reka-collection-item]`)??[]).findIndex(e=>e===t)===-1)return null;zy(e,t,r.parentElement.value,{arrowKeyOptions:r.orientation,dir:r.direction.value,focus:!0})}return(e,t)=>(R(),B(N(ob),{"data-orientation":N(r).orientation,"data-disabled":o.value,"data-state":s.value,disabled:a.value,open:i.value,as:n.as,"as-child":n.asChild,"unmount-on-hide":n.unmountOnHide??N(r).unmountOnHide.value,onKeydown:ou(u,[`up`,`down`,`left`,`right`,`home`,`end`])},{default:P(()=>[I(e.$slots,`default`,{open:i.value})]),_:3},8,[`data-orientation`,`data-disabled`,`data-state`,`disabled`,`open`,`as`,`as-child`,`unmount-on-hide`]))}}),bb=F({__name:`AccordionContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=pb(),r=_b();return Gy(),(e,i)=>(R(),B(N(sb),{role:`region`,"as-child":t.asChild,as:e.as,"force-mount":t.forceMount,"aria-labelledby":N(r).triggerId,"data-state":N(r).dataState.value,"data-disabled":N(r).dataDisabled.value,"data-orientation":N(n).orientation,style:{"--reka-accordion-content-width":`var(--reka-collapsible-content-width)`,"--reka-accordion-content-height":`var(--reka-collapsible-content-height)`},onContentFound:i[0]||=e=>N(n).changeModelValue(N(r).value.value)},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`force-mount`,`aria-labelledby`,`data-state`,`data-disabled`,`data-orientation`]))}}),xb=F({__name:`AccordionHeader`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`h3`}},setup(e){let t=e,n=pb(),r=_b();return Gy(),(e,i)=>(R(),B(N(nb),{as:t.as,"as-child":t.asChild,"data-orientation":N(n).orientation,"data-state":N(r).dataState.value,"data-disabled":N(r).dataDisabled.value},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`data-orientation`,`data-state`,`data-disabled`]))}}),Sb=F({__name:`AccordionTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=pb(),r=_b();r.triggerId||=Yy(void 0,`reka-accordion-trigger`);function i(){let e=n.isSingle.value&&r.open.value&&!n.collapsible;r.disabled.value||e||n.changeModelValue(r.value.value)}return(e,a)=>(R(),B(N(cb),{id:N(r).triggerId,ref:N(r).currentRef,"data-reka-collection-item":``,as:t.as,"as-child":t.asChild,"aria-disabled":N(r).disabled.value||void 0,"aria-expanded":N(r).open.value||!1,"data-disabled":N(r).dataDisabled.value,"data-orientation":N(n).orientation,"data-state":N(r).dataState.value,disabled:N(r).disabled.value,onClick:i},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`id`,`as`,`as-child`,`aria-disabled`,`aria-expanded`,`data-disabled`,`data-orientation`,`data-state`,`disabled`]))}}),Cb=`data-reka-collection-item`;function wb(e={}){let{key:t=``,isProvider:n=!1}=e,r=`${t}CollectionProvider`,i;n?(i={collectionRef:M(),itemMap:M(new Map)},vr(r,i)):i=yr(r);let a=(e=!1)=>{let t=i.collectionRef.value;if(!t)return[];let n=Array.from(t.querySelectorAll(`[${Cb}]`)),r=new Map(n.map((e,t)=>[e,t])),a=Array.from(i.itemMap.value.values()).sort((e,t)=>(r.get(e.ref)??-1)-(r.get(t.ref)??-1));return e?a:a.filter(e=>e.ref.dataset.disabled!==``)},o=F({name:`CollectionSlot`,inheritAttrs:!1,setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=rb();return Er(a,()=>{i.collectionRef.value=a.value}),()=>G(eb,{ref:r,...n},t)}}),s=F({name:`CollectionItem`,inheritAttrs:!1,props:{value:{validator:()=>!0}},setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=rb();return Cr(t=>{if(a.value){let n=sn(a.value);i.itemMap.value.set(n,{ref:a.value,value:e.value}),t(()=>i.itemMap.value.delete(n))}}),()=>G(eb,{...n,[Cb]:``,ref:r},t)}});return{getItems:a,reactiveItems:W(()=>Array.from(i.itemMap.value.values())),itemMapSize:W(()=>i.itemMap.value.size),CollectionSlot:o,CollectionItem:s}}var Tb=`rovingFocusGroup.onEntryFocus`,Eb={bubbles:!1,cancelable:!0},Db={ArrowLeft:`prev`,ArrowUp:`prev`,ArrowRight:`next`,ArrowDown:`next`,PageUp:`first`,Home:`first`,PageDown:`last`,End:`last`};function Ob(e,t){return t===`rtl`?e===`ArrowLeft`?`ArrowRight`:e===`ArrowRight`?`ArrowLeft`:e:e}function kb(e,t,n){let r=Ob(e.key,n);if(!(t===`vertical`&&[`ArrowLeft`,`ArrowRight`].includes(r))&&!(t===`horizontal`&&[`ArrowUp`,`ArrowDown`].includes(r)))return Db[r]}function Ab(e,t=!1){let n=sy();for(let r of e)if(r===n||(r.focus({preventScroll:t}),sy()!==n))return}function jb(e,t){return e.map((n,r)=>e[(t+r)%e.length])}var[Mb,Nb]=oy(`RovingFocusGroup`),Pb=F({__name:`RovingFocusGroup`,props:{orientation:{type:String,required:!1,default:void 0},dir:{type:String,required:!1},loop:{type:Boolean,required:!1,default:!1},currentTabStopId:{type:[String,null],required:!1},defaultCurrentTabStopId:{type:String,required:!1},preventScrollOnEntryFocus:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`entryFocus`,`update:currentTabStopId`],setup(e,{expose:t,emit:n}){let r=e,i=n,{loop:a,orientation:o,dir:s}=yn(r),c=Uy(s),l=Iy(r,`currentTabStopId`,i,{defaultValue:r.defaultCurrentTabStopId,passive:r.currentTabStopId===void 0}),u=M(!1),d=M(!1),f=M(0),{getItems:p,CollectionSlot:m}=wb({isProvider:!0});function h(e){let t=!d.value;if(e.currentTarget&&e.target===e.currentTarget&&t&&!u.value){let t=new CustomEvent(Tb,Eb);if(e.currentTarget.dispatchEvent(t),i(`entryFocus`,t),!t.defaultPrevented){let e=p().map(e=>e.ref).filter(e=>e.dataset.disabled!==``);Ab([e.find(e=>e.getAttribute(`data-active`)===``),e.find(e=>e.getAttribute(`data-highlighted`)===``),e.find(e=>e.id===l.value),...e].filter(Boolean),r.preventScrollOnEntryFocus)}}d.value=!1}function g(){setTimeout(()=>{d.value=!1},1)}return t({getItems:p}),Nb({loop:a,dir:c,orientation:o,currentTabStopId:l,onItemFocus:e=>{l.value=e},onItemShiftTab:()=>{u.value=!0},onFocusableItemAdd:()=>{f.value++},onFocusableItemRemove:()=>{f.value--}}),(e,t)=>(R(),B(N(m),null,{default:P(()=>[H(N(nb),{tabindex:u.value||f.value===0?-1:0,"data-orientation":N(o),as:e.as,"as-child":e.asChild,dir:N(c),style:{outline:`none`},onMousedown:t[0]||=e=>d.value=!0,onMouseup:g,onFocus:h,onBlur:t[1]||=e=>u.value=!1},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`as`,`as-child`,`dir`])]),_:3}))}}),Fb=F({__name:`RovingFocusItem`,props:{tabStopId:{type:String,required:!1},focusable:{type:Boolean,required:!1,default:!0},active:{type:Boolean,required:!1},allowShiftKey:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Mb(),r=Yy(),i=W(()=>t.tabStopId||r),a=W(()=>n.currentTabStopId.value===i.value),{getItems:o,CollectionItem:s}=wb();Zi(()=>{t.focusable&&n.onFocusableItemAdd()}),ta(()=>{t.focusable&&n.onFocusableItemRemove()}),Er(()=>t.focusable,(e,t)=>{e!==t&&(e?n.onFocusableItemAdd():n.onFocusableItemRemove())});function c(e){if(e.key===`Tab`&&e.shiftKey){n.onItemShiftTab();return}if(e.target!==e.currentTarget)return;let r=kb(e,n.orientation.value,n.dir.value);if(r!==void 0){if(e.metaKey||e.ctrlKey||e.altKey||!t.allowShiftKey&&e.shiftKey)return;e.preventDefault();let i=[...o().map(e=>e.ref).filter(e=>e.dataset.disabled!==``)];if(r===`last`)i.reverse();else if(r===`prev`||r===`next`){r===`prev`&&i.reverse();let t=i.indexOf(e.currentTarget);i=n.loop.value?jb(i,t+1):i.slice(t+1)}Qn(()=>Ab(i))}}return(e,t)=>(R(),B(N(s),null,{default:P(()=>[H(N(nb),{tabindex:a.value?0:-1,"data-orientation":N(n).orientation.value,"data-active":e.active?``:void 0,"data-disabled":e.focusable?void 0:``,as:e.as,"as-child":e.asChild,onMousedown:t[0]||=t=>{e.focusable?N(n).onItemFocus(i.value):t.preventDefault()},onFocus:t[1]||=e=>N(n).onItemFocus(i.value),onKeydown:c},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`data-active`,`data-disabled`,`as`,`as-child`])]),_:3}))}}),[Ib,Lb]=oy(`TabsRoot`),Rb=F({__name:`TabsRoot`,props:{defaultValue:{type:null,required:!1},orientation:{type:String,required:!1,default:`horizontal`},dir:{type:String,required:!1},activationMode:{type:String,required:!1,default:`automatic`},modelValue:{type:null,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,{orientation:i,unmountOnHide:a,dir:o}=yn(n),s=Uy(o);Gy();let c=Iy(n,`modelValue`,r,{defaultValue:n.defaultValue,passive:n.modelValue===void 0}),l=M(),u=un(new Set);return Lb({modelValue:c,changeModelValue:e=>{c.value=e},orientation:i,dir:s,unmountOnHide:a,activationMode:n.activationMode,baseId:Yy(void 0,`reka-tabs`),tabsList:l,contentIds:u,registerContent:e=>{u.value=new Set([...u.value,e])},unregisterContent:e=>{let t=new Set(u.value);t.delete(e),u.value=t}}),(e,t)=>(R(),B(N(nb),{dir:N(s),"data-orientation":N(i),"as-child":e.asChild,as:e.as},{default:P(()=>[I(e.$slots,`default`,{modelValue:N(c)})]),_:3},8,[`dir`,`data-orientation`,`as-child`,`as`]))}});function zb(e,t){return`${e}-trigger-${t}`}function Bb(e,t){return`${e}-content-${t}`}var Vb=F({__name:`TabsContent`,props:{value:{type:[String,Number],required:!0},forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{forwardRef:n}=Gy(),r=Ib(),i=W(()=>zb(r.baseId,t.value)),a=W(()=>Bb(r.baseId,t.value)),o=W(()=>t.value===r.modelValue.value),s=M(o.value);return Zi(()=>{r.registerContent(t.value),requestAnimationFrame(()=>{s.value=!1})}),ea(()=>{r.unregisterContent(t.value)}),(e,t)=>(R(),B(N($y),{present:e.forceMount||o.value,"force-mount":``},{default:P(({present:t})=>[H(N(nb),{id:a.value,ref:N(n),"as-child":e.asChild,as:e.as,role:`tabpanel`,"data-state":o.value?`active`:`inactive`,"data-orientation":N(r).orientation.value,"aria-labelledby":i.value,hidden:!t,tabindex:`0`,style:ge({animationDuration:s.value?`0s`:void 0})},{default:P(()=>[!N(r).unmountOnHide.value||t?I(e.$slots,`default`,{key:0}):Ts(`v-if`,!0)]),_:2},1032,[`id`,`as-child`,`as`,`data-state`,`data-orientation`,`aria-labelledby`,`hidden`,`style`])]),_:3},8,[`present`]))}}),Hb=F({__name:`TabsList`,props:{loop:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let{loop:t}=yn(e),{forwardRef:n,currentElement:r}=Gy(),i=Ib();return i.tabsList=r,(e,r)=>(R(),B(N(Pb),{"as-child":``,orientation:N(i).orientation.value,dir:N(i).dir.value,loop:N(t)},{default:P(()=>[H(N(nb),{ref:N(n),role:`tablist`,"as-child":e.asChild,as:e.as,"aria-orientation":N(i).orientation.value},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`aria-orientation`])]),_:3},8,[`orientation`,`dir`,`loop`]))}}),Ub=F({__name:`TabsTrigger`,props:{value:{type:[String,Number],required:!0},disabled:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e,{forwardRef:n}=Gy(),r=Ib(),i=W(()=>zb(r.baseId,t.value)),a=W(()=>r.contentIds.value.has(t.value)?Bb(r.baseId,t.value):void 0),o=W(()=>t.value===r.modelValue.value);return(e,t)=>(R(),B(N(Fb),{"as-child":``,focusable:!e.disabled,active:o.value},{default:P(()=>[H(N(nb),{id:i.value,ref:N(n),role:`tab`,type:e.as===`button`?`button`:void 0,as:e.as,"as-child":e.asChild,"aria-selected":o.value?`true`:`false`,"aria-controls":a.value,"data-state":o.value?`active`:`inactive`,disabled:e.disabled,"data-disabled":e.disabled?``:void 0,"data-orientation":N(r).orientation.value,onMousedown:t[0]||=iu(t=>{!e.disabled&&t.ctrlKey===!1?N(r).changeModelValue(e.value):t.preventDefault()},[`left`]),onKeydown:t[1]||=ou(t=>N(r).changeModelValue(e.value),[`enter`,`space`]),onFocus:t[2]||=()=>{let t=N(r).activationMode!==`manual`;!o.value&&!e.disabled&&t&&N(r).changeModelValue(e.value)}},{default:P(()=>[I(e.$slots,`default`)]),_:3},8,[`id`,`type`,`as`,`as-child`,`aria-selected`,`aria-controls`,`data-state`,`disabled`,`data-disabled`,`data-orientation`])]),_:3},8,[`focusable`,`active`]))}}),Wb=F({__name:`Button`,props:{variant:{},size:{},class:{type:[Boolean,null,String,Object,Array]},asChild:{type:Boolean},as:{default:`button`}},setup(e){let t=e;return(n,r)=>(R(),B(N(nb),{"data-slot":`button`,"data-variant":e.variant,"data-size":e.size,as:e.as,"as-child":e.asChild,class:O(N(Yv)(N(Gb)({variant:e.variant,size:e.size}),t.class))},{default:P(()=>[I(n.$slots,`default`)]),_:3},8,[`data-variant`,`data-size`,`as`,`as-child`,`class`]))}}),Gb=C_(`focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 rounded-lg border border-transparent bg-clip-padding text-sm font-medium focus-visible:ring-3 aria-invalid:ring-3 active:not-aria-[haspopup]:translate-y-px [&_svg:not([class*=size-])]:size-4 group/button inline-flex shrink-0 items-center justify-center whitespace-nowrap transition-all outline-none select-none disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:shrink-0`,{variants:{variant:{default:`bg-primary text-primary-foreground [a]:hover:bg-primary/80`,outline:`border-border bg-background hover:bg-muted hover:text-foreground dark:bg-input/30 dark:border-input dark:hover:bg-input/50 aria-expanded:bg-muted aria-expanded:text-foreground`,secondary:`bg-secondary text-secondary-foreground hover:bg-secondary/80 aria-expanded:bg-secondary aria-expanded:text-secondary-foreground`,ghost:`hover:bg-muted hover:text-foreground dark:hover:bg-muted/50 aria-expanded:bg-muted aria-expanded:text-foreground`,destructive:`bg-destructive/10 hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/20 text-destructive focus-visible:border-destructive/40 dark:hover:bg-destructive/30`,link:`text-primary underline-offset-4 hover:underline`},size:{default:`h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2`,xs:`h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*=size-])]:size-3`,sm:`h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*=size-])]:size-3.5`,lg:`h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2`,icon:`size-8`,"icon-xs":`size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*=size-])]:size-3`,"icon-sm":`size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg`,"icon-lg":`size-9`}},defaultVariants:{variant:`default`,size:`default`}}),Kb=[`data-size`],qb=F({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e;return(n,r)=>(R(),z(`div`,{"data-slot":`card`,"data-size":e.size,class:O(N(Yv)(`ring-foreground/10 bg-card text-card-foreground gap-4 overflow-hidden rounded-xl py-4 text-sm ring-1 has-data-[slot=card-footer]:pb-0 has-[>img:first-child]:pt-0 data-[size=sm]:gap-3 data-[size=sm]:py-3 data-[size=sm]:has-data-[slot=card-footer]:pb-0 *:[img:first-child]:rounded-t-xl *:[img:last-child]:rounded-b-xl group/card flex flex-col`,t.class))},[I(n.$slots,`default`)],10,Kb))}}),Jb=F({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-content`,class:O(N(Yv)(`px-4 group-data-[size=sm]/card:px-3`,t.class))},[I(e.$slots,`default`)],2))}}),Yb=F({__name:`CardDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-description`,class:O(N(Yv)(`text-muted-foreground text-sm`,t.class))},[I(e.$slots,`default`)],2))}}),Xb=F({__name:`CardHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-header`,class:O(N(Yv)(`gap-1 rounded-t-xl px-4 group-data-[size=sm]/card:px-3 [.border-b]:pb-4 group-data-[size=sm]/card:[.border-b]:pb-3 group/card-header @container/card-header grid auto-rows-min items-start has-data-[slot=card-action]:grid-cols-[1fr_auto] has-data-[slot=card-description]:grid-rows-[auto_auto]`,t.class))},[I(e.$slots,`default`)],2))}}),Zb=F({__name:`CardTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,{"data-slot":`card-title`,class:O(N(Yv)(`text-base leading-snug font-medium group-data-[size=sm]/card:text-sm cn-font-heading`,t.class))},[I(e.$slots,`default`)],2))}}),Qb=F({__name:`Input`,props:{defaultValue:{},modelValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=Iy(n,`modelValue`,t,{passive:!0,defaultValue:n.defaultValue});return(e,t)=>gr((R(),z(`input`,{"onUpdate:modelValue":t[0]||=e=>j(r)?r.value=e:null,"data-slot":`input`,class:O(N(Yv)(`dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 disabled:bg-input/50 dark:disabled:bg-input/80 h-8 rounded-lg border bg-transparent px-2.5 py-1 text-base transition-colors file:h-6 file:text-sm file:font-medium focus-visible:ring-3 aria-invalid:ring-3 md:text-sm w-full min-w-0 outline-none file:inline-flex file:border-0 file:bg-transparent file:text-foreground placeholder:text-muted-foreground disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50`,n.class))},null,2)),[[Wl,N(r)]])}}),$b=`llmgwAdminKey`;function ex(){try{return sessionStorage.getItem($b)??``}catch{return``}}function tx(e){try{sessionStorage.setItem($b,e)}catch{}}function nx(){try{sessionStorage.removeItem($b)}catch{}}var rx=t_(`auth`,{state:()=>({apiKey:ex(),error:``}),getters:{isAuthenticated:e=>e.apiKey!==``},actions:{submit(e){e&&(this.apiKey=e,this.error=``,tx(e))},reject(e){this.apiKey=``,this.error=e,nx()}}}),ix=class extends Error{status;constructor(e,t){super(e),this.name=`AdminApiError`,this.status=t}};async function ax(e){let t=rx(),n=t.apiKey,r=await fetch(e,{credentials:`same-origin`,headers:n?{"x-api-key":n}:{}});if(r.status===401||r.status===403)throw t.apiKey===n&&t.reject(`invalid key, or not an admin`),new ix(`${e}: HTTP ${r.status}`,r.status);if(!r.ok)throw new ix(`${e}: HTTP ${r.status}`,r.status);return await r.json()}var ox=5e3,sx=t_(`dashboard`,{state:()=>({overview:null,usage:null,targets:null,lastUpdated:null,error:``,timer:void 0}),actions:{async refresh(){if(!rx().isAuthenticated)return;let[e,t,n]=await Promise.allSettled([ax(`/admin/api/overview`),ax(`/admin/api/usage`),ax(`/admin/api/targets`)]);e.status===`fulfilled`&&(this.overview=e.value),t.status===`fulfilled`&&(this.usage=t.value),n.status===`fulfilled`&&(this.targets=n.value);let r=[];if(e.status===`rejected`&&r.push({label:`overview`,reason:e.reason}),t.status===`rejected`&&r.push({label:`usage`,reason:t.reason}),n.status===`rejected`&&r.push({label:`targets`,reason:n.reason}),r.length===0){this.lastUpdated=new Date,this.error=``;return}r.some(({reason:e})=>e instanceof ix&&(e.status===401||e.status===403))||(r.length<3&&(this.lastUpdated=new Date),this.error=r.map(({label:e,reason:t})=>`${e}: ${t instanceof Error?t.message:String(t)}`).join(`; `))},startPolling(){this.timer===void 0&&(this.refresh(),this.timer=setInterval(()=>void this.refresh(),ox))},stopPolling(){this.timer!==void 0&&(clearInterval(this.timer),this.timer=void 0)}}}),cx={class:`mx-auto flex min-h-[70vh] max-w-md flex-col justify-center px-4`},lx={class:`flex size-12 items-center justify-center rounded-full bg-primary/10 text-primary`},ux={class:`flex flex-col items-center gap-1`},dx={"aria-labelledby":`authgate-security-heading`,class:`flex flex-col gap-1.5 text-xs text-muted-foreground`},fx={class:`flex items-start gap-1.5`},px={class:`flex items-start gap-1.5`},mx={class:`flex items-start gap-1.5`},hx={class:`relative`},gx=((e,t)=>{let n=e.__vccOpts||e;for(let[e,r]of t)n[e]=r;return n})(F({__name:`AuthGate`,setup(e){let t=rx(),n=sx(),r=M(``),i=M(!1),a=M(null),o=W(()=>r.value.trim()!==``);function s(){let e=r.value;r.value=``,t.submit(e),n.refresh()}function c(){Qn(()=>a.value?.$el?.focus())}return Zi(c),Er(()=>t.error,e=>{e&&c()}),(e,n)=>{let c=ca(`FontAwesomeIcon`);return R(),z(`div`,cx,[H(N(qb),null,{default:P(()=>[H(N(Xb),{class:`flex flex-col items-center gap-3 text-center`},{default:P(()=>[V(`div`,lx,[H(c,{icon:N(i_),class:`size-5`,"aria-hidden":`true`},null,8,[`icon`])]),V(`div`,ux,[n[3]||=V(`span`,{class:`text-xs font-medium text-muted-foreground`},`LLM Gateway`,-1),H(N(Zb),{class:`text-lg font-semibold`},{default:P(()=>[...n[2]||=[U(`Admin key required`,-1)]]),_:1})]),H(N(Yb),null,{default:P(()=>[...n[4]||=[U(`Enter an admin API key to continue.`,-1)]]),_:1})]),_:1}),H(N(Jb),{class:`flex flex-col gap-4`},{default:P(()=>[n[10]||=V(`h2`,{id:`authgate-security-heading`,class:`sr-only`},` How this key is handled `,-1),V(`ul`,dx,[V(`li`,fx,[H(c,{icon:N(u_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[5]||=V(`span`,null,`Kept only in this tab's session storage`,-1)]),V(`li`,px,[H(c,{icon:N(u_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[6]||=V(`span`,null,`Never written to disk`,-1)]),V(`li`,mx,[H(c,{icon:N(u_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[7]||=V(`span`,null,`Sent only to this page's own /admin/api/* requests`,-1)])]),V(`form`,{class:`flex flex-col gap-3`,onSubmit:iu(s,[`prevent`])},[V(`div`,hx,[H(N(Qb),{ref_key:`keyInputEl`,ref:a,modelValue:r.value,"onUpdate:modelValue":n[0]||=e=>r.value=e,type:i.value?`text`:`password`,autocomplete:`off`,placeholder:`API key`,"aria-label":`Admin API key`,"aria-invalid":!!N(t).error,"aria-describedby":N(t).error?`authgate-error`:void 0,class:O([`h-10 pr-10`,{"authgate-shake":N(t).error}])},null,8,[`modelValue`,`type`,`aria-invalid`,`aria-describedby`,`class`]),H(N(Wb),{type:`button`,variant:`ghost`,size:`icon-xs`,class:`absolute top-1/2 right-1.5 -translate-y-1/2 text-muted-foreground hover:text-foreground`,"aria-label":i.value?`Hide key`:`Show key`,onClick:n[1]||=e=>i.value=!i.value},{default:P(()=>[H(c,{icon:i.value?N(__):N(o_),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`aria-label`])]),H(N(Wb),{type:`submit`,class:`w-full`,disabled:!o.value},{default:P(()=>[...n[8]||=[U(` Continue `,-1)]]),_:1},8,[`disabled`])],32),N(t).error?(R(),B(N(Xv),{key:0,id:`authgate-error`,variant:`destructive`},{default:P(()=>[H(N(Qv),null,{default:P(()=>[...n[9]||=[U(`Authentication failed`,-1)]]),_:1}),H(N(Zv),null,{default:P(()=>[U(k(N(t).error),1)]),_:1})]),_:1})):Ts(``,!0)]),_:1})]),_:1})])}}}),[[`__scopeId`,`data-v-4be6bc09`]]);function _x(e,t){return typeof e==`function`?e(t):e}function vx(e,t){return n=>{t.setState(t=>({...t,[e]:_x(n,t[e])}))}}function yx(e){return e instanceof Function}function bx(e){return Array.isArray(e)&&e.every(e=>typeof e==`number`)}function xx(e,t){let n=[],r=e=>{e.forEach(e=>{n.push(e);let i=t(e);i!=null&&i.length&&r(i)})};return r(e),n}function Q(e,t,n){let r=[],i;return a=>{let o;n.key&&n.debug&&(o=Date.now());let s=e(a);if(!(s.length!==r.length||s.some((e,t)=>r[t]!==e)))return i;r=s;let c;if(n.key&&n.debug&&(c=Date.now()),i=t(...s),n==null||n.onChange==null||n.onChange(i),n.key&&n.debug&&n!=null&&n.debug()){let e=Math.round((Date.now()-o)*100)/100,t=Math.round((Date.now()-c)*100)/100,r=t/16,i=(e,t)=>{for(e=String(e);e.length<t;)e=` `+e;return e};console.info(`%c⏱ ${i(t,5)} /${i(e,5)} ms`,`
            font-size: .6rem;
            font-weight: bold;
            color: hsl(${Math.max(0,Math.min(120-120*r,120))}deg 100% 31%);`,n?.key)}return i}}function $(e,t,n,r){return{debug:()=>e?.debugAll??e[t],key:!1,onChange:r}}function Sx(e,t,n,r){let i={id:`${t.id}_${n.id}`,row:t,column:n,getValue:()=>t.getValue(r),renderValue:()=>i.getValue()??e.options.renderFallbackValue,getContext:Q(()=>[e,n,t,i],(e,t,n,r)=>({table:e,column:t,row:n,cell:r,getValue:r.getValue,renderValue:r.renderValue}),$(e.options,`debugCells`,`cell.getContext`))};return e._features.forEach(r=>{r.createCell==null||r.createCell(i,n,t,e)},{}),i}function Cx(e,t,n,r){let i={...e._getDefaultColumnDef(),...t},a=i.accessorKey,o=i.id??(a?typeof String.prototype.replaceAll==`function`?a.replaceAll(`.`,`_`):a.replace(/\./g,`_`):void 0)??(typeof i.header==`string`?i.header:void 0),s;if(i.accessorFn?s=i.accessorFn:a&&(s=a.includes(`.`)?e=>{let t=e;for(let e of a.split(`.`))t=t?.[e];return t}:e=>e[i.accessorKey]),!o)throw Error();let c={id:`${String(o)}`,accessorFn:s,parent:r,depth:n,columnDef:i,columns:[],getFlatColumns:Q(()=>[!0],()=>[c,...c.columns?.flatMap(e=>e.getFlatColumns())],$(e.options,`debugColumns`,`column.getFlatColumns`)),getLeafColumns:Q(()=>[e._getOrderColumnsFn()],e=>{var t;return(t=c.columns)!=null&&t.length?e(c.columns.flatMap(e=>e.getLeafColumns())):[c]},$(e.options,`debugColumns`,`column.getLeafColumns`))};for(let t of e._features)t.createColumn==null||t.createColumn(c,e);return c}var wx=`debugHeaders`;function Tx(e,t,n){let r={id:n.id??t.id,column:t,index:n.index,isPlaceholder:!!n.isPlaceholder,placeholderId:n.placeholderId,depth:n.depth,subHeaders:[],colSpan:0,rowSpan:0,headerGroup:null,getLeafHeaders:()=>{let e=[],t=n=>{n.subHeaders&&n.subHeaders.length&&n.subHeaders.map(t),e.push(n)};return t(r),e},getContext:()=>({table:e,header:r,column:t})};return e._features.forEach(t=>{t.createHeader==null||t.createHeader(r,e)}),r}var Ex={createTable:e=>{e.getHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(t,n,r,i)=>{let a=r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],o=i?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],s=n.filter(e=>!(r!=null&&r.includes(e.id))&&!(i!=null&&i.includes(e.id)));return Dx(t,[...a,...s,...o],e)},$(e.options,wx,`getHeaderGroups`)),e.getCenterHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(t,n,r,i)=>(n=n.filter(e=>!(r!=null&&r.includes(e.id))&&!(i!=null&&i.includes(e.id))),Dx(t,n,e,`center`)),$(e.options,wx,`getCenterHeaderGroups`)),e.getLeftHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left],(t,n,r)=>Dx(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`left`),$(e.options,wx,`getLeftHeaderGroups`)),e.getRightHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.right],(t,n,r)=>Dx(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`right`),$(e.options,wx,`getRightHeaderGroups`)),e.getFooterGroups=Q(()=>[e.getHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getFooterGroups`)),e.getLeftFooterGroups=Q(()=>[e.getLeftHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getLeftFooterGroups`)),e.getCenterFooterGroups=Q(()=>[e.getCenterHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getCenterFooterGroups`)),e.getRightFooterGroups=Q(()=>[e.getRightHeaderGroups()],e=>[...e].reverse(),$(e.options,wx,`getRightFooterGroups`)),e.getFlatHeaders=Q(()=>[e.getHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getFlatHeaders`)),e.getLeftFlatHeaders=Q(()=>[e.getLeftHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getLeftFlatHeaders`)),e.getCenterFlatHeaders=Q(()=>[e.getCenterHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getCenterFlatHeaders`)),e.getRightFlatHeaders=Q(()=>[e.getRightHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,wx,`getRightFlatHeaders`)),e.getCenterLeafHeaders=Q(()=>[e.getCenterFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getCenterLeafHeaders`)),e.getLeftLeafHeaders=Q(()=>[e.getLeftFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getLeftLeafHeaders`)),e.getRightLeafHeaders=Q(()=>[e.getRightFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,wx,`getRightLeafHeaders`)),e.getLeafHeaders=Q(()=>[e.getLeftHeaderGroups(),e.getCenterHeaderGroups(),e.getRightHeaderGroups()],(e,t,n)=>[...e[0]?.headers??[],...t[0]?.headers??[],...n[0]?.headers??[]].map(e=>e.getLeafHeaders()).flat(),$(e.options,wx,`getLeafHeaders`))}};function Dx(e,t,n,r){let i=0,a=function(e,t){t===void 0&&(t=1),i=Math.max(i,t),e.filter(e=>e.getIsVisible()).forEach(e=>{var n;(n=e.columns)!=null&&n.length&&a(e.columns,t+1)},0)};a(e);let o=[],s=(e,t)=>{let i={depth:t,id:[r,`${t}`].filter(Boolean).join(`_`),headers:[]},a=[];e.forEach(e=>{let o=[...a].reverse()[0],s=e.column.depth===i.depth,c,l=!1;if(s&&e.column.parent?c=e.column.parent:(c=e.column,l=!0),o&&o?.column===c)o.subHeaders.push(e);else{let i=Tx(n,c,{id:[r,t,c.id,e?.id].filter(Boolean).join(`_`),isPlaceholder:l,placeholderId:l?`${a.filter(e=>e.column===c).length}`:void 0,depth:t,index:a.length});i.subHeaders.push(e),a.push(i)}i.headers.push(e),e.headerGroup=i}),o.push(i),t>0&&s(a,t-1)};s(t.map((e,t)=>Tx(n,e,{depth:i,index:t})),i-1),o.reverse();let c=e=>e.filter(e=>e.column.getIsVisible()).map(e=>{let t=0,n=0,r=[0];e.subHeaders&&e.subHeaders.length?(r=[],c(e.subHeaders).forEach(e=>{let{colSpan:n,rowSpan:i}=e;t+=n,r.push(i)})):t=1;let i=Math.min(...r);return n+=i,e.colSpan=t,e.rowSpan=n,{colSpan:t,rowSpan:n}});return c(o[0]?.headers??[]),o}var Ox=(e,t,n,r,i,a,o)=>{let s={id:t,index:r,original:n,depth:i,parentId:o,_valuesCache:{},_uniqueValuesCache:{},getValue:t=>{if(s._valuesCache.hasOwnProperty(t))return s._valuesCache[t];let n=e.getColumn(t);if(n!=null&&n.accessorFn)return s._valuesCache[t]=n.accessorFn(s.original,r),s._valuesCache[t]},getUniqueValues:t=>{if(s._uniqueValuesCache.hasOwnProperty(t))return s._uniqueValuesCache[t];let n=e.getColumn(t);if(n!=null&&n.accessorFn)return n.columnDef.getUniqueValues?(s._uniqueValuesCache[t]=n.columnDef.getUniqueValues(s.original,r),s._uniqueValuesCache[t]):(s._uniqueValuesCache[t]=[s.getValue(t)],s._uniqueValuesCache[t])},renderValue:t=>s.getValue(t)??e.options.renderFallbackValue,subRows:a??[],getLeafRows:()=>xx(s.subRows,e=>e.subRows),getParentRow:()=>s.parentId?e.getRow(s.parentId,!0):void 0,getParentRows:()=>{let e=[],t=s;for(;;){let n=t.getParentRow();if(!n)break;e.push(n),t=n}return e.reverse()},getAllCells:Q(()=>[e.getAllLeafColumns()],t=>t.map(t=>Sx(e,s,t,t.id)),$(e.options,`debugRows`,`getAllCells`)),_getAllCellsByColumnId:Q(()=>[s.getAllCells()],e=>e.reduce((e,t)=>(e[t.column.id]=t,e),{}),$(e.options,`debugRows`,`getAllCellsByColumnId`))};for(let t=0;t<e._features.length;t++){let n=e._features[t];n==null||n.createRow==null||n.createRow(s,e)}return s},kx={createColumn:(e,t)=>{e._getFacetedRowModel=t.options.getFacetedRowModel&&t.options.getFacetedRowModel(t,e.id),e.getFacetedRowModel=()=>e._getFacetedRowModel?e._getFacetedRowModel():t.getPreFilteredRowModel(),e._getFacetedUniqueValues=t.options.getFacetedUniqueValues&&t.options.getFacetedUniqueValues(t,e.id),e.getFacetedUniqueValues=()=>e._getFacetedUniqueValues?e._getFacetedUniqueValues():new Map,e._getFacetedMinMaxValues=t.options.getFacetedMinMaxValues&&t.options.getFacetedMinMaxValues(t,e.id),e.getFacetedMinMaxValues=()=>{if(e._getFacetedMinMaxValues)return e._getFacetedMinMaxValues()}}},Ax=(e,t,n)=>{var r,i;let a=n==null||(r=n.toString())==null?void 0:r.toLowerCase();return!!((i=e.getValue(t))!=null&&(i=i.toString())!=null&&(i=i.toLowerCase())!=null&&i.includes(a))};Ax.autoRemove=e=>Bx(e);var jx=(e,t,n)=>{var r;return!!((r=e.getValue(t))!=null&&(r=r.toString())!=null&&r.includes(n))};jx.autoRemove=e=>Bx(e);var Mx=(e,t,n)=>{var r;return((r=e.getValue(t))==null||(r=r.toString())==null?void 0:r.toLowerCase())===n?.toLowerCase()};Mx.autoRemove=e=>Bx(e);var Nx=(e,t,n)=>e.getValue(t)?.includes(n);Nx.autoRemove=e=>Bx(e);var Px=(e,t,n)=>!n.some(n=>{var r;return!((r=e.getValue(t))!=null&&r.includes(n))});Px.autoRemove=e=>Bx(e)||!(e!=null&&e.length);var Fx=(e,t,n)=>n.some(n=>e.getValue(t)?.includes(n));Fx.autoRemove=e=>Bx(e)||!(e!=null&&e.length);var Ix=(e,t,n)=>e.getValue(t)===n;Ix.autoRemove=e=>Bx(e);var Lx=(e,t,n)=>e.getValue(t)==n;Lx.autoRemove=e=>Bx(e);var Rx=(e,t,n)=>{let[r,i]=n,a=e.getValue(t);return a>=r&&a<=i};Rx.resolveFilterValue=e=>{let[t,n]=e,r=typeof t==`number`?t:parseFloat(t),i=typeof n==`number`?n:parseFloat(n),a=t===null||Number.isNaN(r)?-1/0:r,o=n===null||Number.isNaN(i)?1/0:i;if(a>o){let e=a;a=o,o=e}return[a,o]},Rx.autoRemove=e=>Bx(e)||Bx(e[0])&&Bx(e[1]);var zx={includesString:Ax,includesStringSensitive:jx,equalsString:Mx,arrIncludes:Nx,arrIncludesAll:Px,arrIncludesSome:Fx,equals:Ix,weakEquals:Lx,inNumberRange:Rx};function Bx(e){return e==null||e===``}var Vx={getDefaultColumnDef:()=>({filterFn:`auto`}),getInitialState:e=>({columnFilters:[],...e}),getDefaultOptions:e=>({onColumnFiltersChange:vx(`columnFilters`,e),filterFromLeafRows:!1,maxLeafRowFilterDepth:100}),createColumn:(e,t)=>{e.getAutoFilterFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);return typeof n==`string`?zx.includesString:typeof n==`number`?zx.inNumberRange:typeof n==`boolean`||typeof n==`object`&&n?zx.equals:Array.isArray(n)?zx.arrIncludes:zx.weakEquals},e.getFilterFn=()=>yx(e.columnDef.filterFn)?e.columnDef.filterFn:e.columnDef.filterFn===`auto`?e.getAutoFilterFn():t.options.filterFns?.[e.columnDef.filterFn]??zx[e.columnDef.filterFn],e.getCanFilter=()=>(e.columnDef.enableColumnFilter??!0)&&(t.options.enableColumnFilters??!0)&&(t.options.enableFilters??!0)&&!!e.accessorFn,e.getIsFiltered=()=>e.getFilterIndex()>-1,e.getFilterValue=()=>{var n;return(n=t.getState().columnFilters)==null||(n=n.find(t=>t.id===e.id))==null?void 0:n.value},e.getFilterIndex=()=>t.getState().columnFilters?.findIndex(t=>t.id===e.id)??-1,e.setFilterValue=n=>{t.setColumnFilters(t=>{let r=e.getFilterFn(),i=t?.find(t=>t.id===e.id),a=_x(n,i?i.value:void 0);if(Hx(r,a,e))return t?.filter(t=>t.id!==e.id)??[];let o={id:e.id,value:a};return i?t?.map(t=>t.id===e.id?o:t)??[]:t!=null&&t.length?[...t,o]:[o]})}},createRow:(e,t)=>{e.columnFilters={},e.columnFiltersMeta={}},createTable:e=>{e.setColumnFilters=t=>{let n=e.getAllLeafColumns();e.options.onColumnFiltersChange==null||e.options.onColumnFiltersChange(e=>_x(t,e)?.filter(e=>{let t=n.find(t=>t.id===e.id);return!(t&&Hx(t.getFilterFn(),e.value,t))}))},e.resetColumnFilters=t=>{e.setColumnFilters(t?[]:e.initialState?.columnFilters??[])},e.getPreFilteredRowModel=()=>e.getCoreRowModel(),e.getFilteredRowModel=()=>(!e._getFilteredRowModel&&e.options.getFilteredRowModel&&(e._getFilteredRowModel=e.options.getFilteredRowModel(e)),e.options.manualFiltering||!e._getFilteredRowModel?e.getPreFilteredRowModel():e._getFilteredRowModel())}};function Hx(e,t,n){return(e&&e.autoRemove?e.autoRemove(t,n):!1)||t===void 0||typeof t==`string`&&!t}var Ux={sum:(e,t,n)=>n.reduce((t,n)=>{let r=n.getValue(e);return t+(typeof r==`number`?r:0)},0),min:(e,t,n)=>{let r;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r>n||r===void 0&&n>=n)&&(r=n)}),r},max:(e,t,n)=>{let r;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r<n||r===void 0&&n>=n)&&(r=n)}),r},extent:(e,t,n)=>{let r,i;return n.forEach(t=>{let n=t.getValue(e);n!=null&&(r===void 0?n>=n&&(r=i=n):(r>n&&(r=n),i<n&&(i=n)))}),[r,i]},mean:(e,t)=>{let n=0,r=0;if(t.forEach(t=>{let i=t.getValue(e);i!=null&&(i=+i)>=i&&(++n,r+=i)}),n)return r/n},median:(e,t)=>{if(!t.length)return;let n=t.map(t=>t.getValue(e));if(!bx(n))return;if(n.length===1)return n[0];let r=Math.floor(n.length/2),i=n.sort((e,t)=>e-t);return n.length%2==0?(i[r-1]+i[r])/2:i[r]},unique:(e,t)=>Array.from(new Set(t.map(t=>t.getValue(e))).values()),uniqueCount:(e,t)=>new Set(t.map(t=>t.getValue(e))).size,count:(e,t)=>t.length},Wx={getDefaultColumnDef:()=>({aggregatedCell:e=>{var t;return((t=e.getValue())==null||t.toString==null?void 0:t.toString())??null},aggregationFn:`auto`}),getInitialState:e=>({grouping:[],...e}),getDefaultOptions:e=>({onGroupingChange:vx(`grouping`,e),groupedColumnMode:`reorder`}),createColumn:(e,t)=>{e.toggleGrouping=()=>{t.setGrouping(t=>t!=null&&t.includes(e.id)?t.filter(t=>t!==e.id):[...t??[],e.id])},e.getCanGroup=()=>(e.columnDef.enableGrouping??!0)&&(t.options.enableGrouping??!0)&&(!!e.accessorFn||!!e.columnDef.getGroupingValue),e.getIsGrouped=()=>t.getState().grouping?.includes(e.id),e.getGroupedIndex=()=>t.getState().grouping?.indexOf(e.id),e.getToggleGroupingHandler=()=>{let t=e.getCanGroup();return()=>{t&&e.toggleGrouping()}},e.getAutoAggregationFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);if(typeof n==`number`)return Ux.sum;if(Object.prototype.toString.call(n)===`[object Date]`)return Ux.extent},e.getAggregationFn=()=>{if(!e)throw Error();return yx(e.columnDef.aggregationFn)?e.columnDef.aggregationFn:e.columnDef.aggregationFn===`auto`?e.getAutoAggregationFn():t.options.aggregationFns?.[e.columnDef.aggregationFn]??Ux[e.columnDef.aggregationFn]}},createTable:e=>{e.setGrouping=t=>e.options.onGroupingChange==null?void 0:e.options.onGroupingChange(t),e.resetGrouping=t=>{e.setGrouping(t?[]:e.initialState?.grouping??[])},e.getPreGroupedRowModel=()=>e.getFilteredRowModel(),e.getGroupedRowModel=()=>(!e._getGroupedRowModel&&e.options.getGroupedRowModel&&(e._getGroupedRowModel=e.options.getGroupedRowModel(e)),e.options.manualGrouping||!e._getGroupedRowModel?e.getPreGroupedRowModel():e._getGroupedRowModel())},createRow:(e,t)=>{e.getIsGrouped=()=>!!e.groupingColumnId,e.getGroupingValue=n=>{if(e._groupingValuesCache.hasOwnProperty(n))return e._groupingValuesCache[n];let r=t.getColumn(n);return r!=null&&r.columnDef.getGroupingValue?(e._groupingValuesCache[n]=r.columnDef.getGroupingValue(e.original),e._groupingValuesCache[n]):e.getValue(n)},e._groupingValuesCache={}},createCell:(e,t,n,r)=>{e.getIsGrouped=()=>t.getIsGrouped()&&t.id===n.groupingColumnId,e.getIsPlaceholder=()=>!e.getIsGrouped()&&t.getIsGrouped(),e.getIsAggregated=()=>{var t;return!e.getIsGrouped()&&!e.getIsPlaceholder()&&!!((t=n.subRows)!=null&&t.length)}}};function Gx(e,t,n){if(!(t!=null&&t.length)||!n)return e;let r=e.filter(e=>!t.includes(e.id));return n===`remove`?r:[...t.map(t=>e.find(e=>e.id===t)).filter(Boolean),...r]}var Kx={getInitialState:e=>({columnOrder:[],...e}),getDefaultOptions:e=>({onColumnOrderChange:vx(`columnOrder`,e)}),createColumn:(e,t)=>{e.getIndex=Q(e=>[rS(t,e)],t=>t.findIndex(t=>t.id===e.id),$(t.options,`debugColumns`,`getIndex`)),e.getIsFirstColumn=n=>rS(t,n)[0]?.id===e.id,e.getIsLastColumn=n=>{let r=rS(t,n);return r[r.length-1]?.id===e.id}},createTable:e=>{e.setColumnOrder=t=>e.options.onColumnOrderChange==null?void 0:e.options.onColumnOrderChange(t),e.resetColumnOrder=t=>{e.setColumnOrder(t?[]:e.initialState.columnOrder??[])},e._getOrderColumnsFn=Q(()=>[e.getState().columnOrder,e.getState().grouping,e.options.groupedColumnMode],(e,t,n)=>r=>{let i=[];if(!(e!=null&&e.length))i=r;else{let t=[...e],n=[...r];for(;n.length&&t.length;){let e=t.shift(),r=n.findIndex(t=>t.id===e);r>-1&&i.push(n.splice(r,1)[0])}i=[...i,...n]}return Gx(i,t,n)},$(e.options,`debugTable`,`_getOrderColumnsFn`))}},qx=()=>({left:[],right:[]}),Jx={getInitialState:e=>({columnPinning:qx(),...e}),getDefaultOptions:e=>({onColumnPinningChange:vx(`columnPinning`,e)}),createColumn:(e,t)=>{e.pin=n=>{let r=e.getLeafColumns().map(e=>e.id).filter(Boolean);t.setColumnPinning(e=>n===`right`?{left:(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),right:[...(e?.right??[]).filter(e=>!(r!=null&&r.includes(e))),...r]}:n===`left`?{left:[...(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),...r],right:(e?.right??[]).filter(e=>!(r!=null&&r.includes(e)))}:{left:(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),right:(e?.right??[]).filter(e=>!(r!=null&&r.includes(e)))})},e.getCanPin=()=>e.getLeafColumns().some(e=>(e.columnDef.enablePinning??!0)&&(t.options.enableColumnPinning??t.options.enablePinning??!0)),e.getIsPinned=()=>{let n=e.getLeafColumns().map(e=>e.id),{left:r,right:i}=t.getState().columnPinning,a=n.some(e=>r?.includes(e)),o=n.some(e=>i?.includes(e));return a?`left`:o?`right`:!1},e.getPinnedIndex=()=>{var n;let r=e.getIsPinned();return r?((n=t.getState().columnPinning)==null||(n=n[r])==null?void 0:n.indexOf(e.id))??-1:0}},createRow:(e,t)=>{e.getCenterVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.left,t.getState().columnPinning.right],(e,t,n)=>{let r=[...t??[],...n??[]];return e.filter(e=>!r.includes(e.column.id))},$(t.options,`debugRows`,`getCenterVisibleCells`)),e.getLeftVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.column.id===t)).filter(Boolean).map(e=>({...e,position:`left`})),$(t.options,`debugRows`,`getLeftVisibleCells`)),e.getRightVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.column.id===t)).filter(Boolean).map(e=>({...e,position:`right`})),$(t.options,`debugRows`,`getRightVisibleCells`))},createTable:e=>{e.setColumnPinning=t=>e.options.onColumnPinningChange==null?void 0:e.options.onColumnPinningChange(t),e.resetColumnPinning=t=>e.setColumnPinning(t?qx():e.initialState?.columnPinning??qx()),e.getIsSomeColumnsPinned=t=>{let n=e.getState().columnPinning;return t?!!n[t]?.length:!!(n.left?.length||n.right?.length)},e.getLeftLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),$(e.options,`debugColumns`,`getLeftLeafColumns`)),e.getRightLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),$(e.options,`debugColumns`,`getRightLeafColumns`)),e.getCenterLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(e,t,n)=>{let r=[...t??[],...n??[]];return e.filter(e=>!r.includes(e.id))},$(e.options,`debugColumns`,`getCenterLeafColumns`))}};function Yx(e){return e||(typeof document<`u`?document:null)}var Xx={size:150,minSize:20,maxSize:2**53-1},Zx=()=>({startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,isResizingColumn:!1,columnSizingStart:[]}),Qx={getDefaultColumnDef:()=>Xx,getInitialState:e=>({columnSizing:{},columnSizingInfo:Zx(),...e}),getDefaultOptions:e=>({columnResizeMode:`onEnd`,columnResizeDirection:`ltr`,onColumnSizingChange:vx(`columnSizing`,e),onColumnSizingInfoChange:vx(`columnSizingInfo`,e)}),createColumn:(e,t)=>{e.getSize=()=>{let n=t.getState().columnSizing[e.id];return Math.min(Math.max(e.columnDef.minSize??Xx.minSize,n??e.columnDef.size??Xx.size),e.columnDef.maxSize??Xx.maxSize)},e.getStart=Q(e=>[e,rS(t,e),t.getState().columnSizing],(t,n)=>n.slice(0,e.getIndex(t)).reduce((e,t)=>e+t.getSize(),0),$(t.options,`debugColumns`,`getStart`)),e.getAfter=Q(e=>[e,rS(t,e),t.getState().columnSizing],(t,n)=>n.slice(e.getIndex(t)+1).reduce((e,t)=>e+t.getSize(),0),$(t.options,`debugColumns`,`getAfter`)),e.resetSize=()=>{t.setColumnSizing(t=>{let{[e.id]:n,...r}=t;return r})},e.getCanResize=()=>(e.columnDef.enableResizing??!0)&&(t.options.enableColumnResizing??!0),e.getIsResizing=()=>t.getState().columnSizingInfo.isResizingColumn===e.id},createHeader:(e,t)=>{e.getSize=()=>{let t=0,n=e=>{e.subHeaders.length?e.subHeaders.forEach(n):t+=e.column.getSize()??0};return n(e),t},e.getStart=()=>{if(e.index>0){let t=e.headerGroup.headers[e.index-1];return t.getStart()+t.getSize()}return 0},e.getResizeHandler=n=>{let r=t.getColumn(e.column.id),i=r?.getCanResize();return a=>{if(!r||!i||(a.persist==null||a.persist(),tS(a)&&a.touches&&a.touches.length>1))return;let o=e.getSize(),s=e?e.getLeafHeaders().map(e=>[e.column.id,e.column.getSize()]):[[r.id,r.getSize()]],c=tS(a)?Math.round(a.touches[0].clientX):a.clientX,l={},u=(e,n)=>{typeof n==`number`&&(t.setColumnSizingInfo(e=>{let r=t.options.columnResizeDirection===`rtl`?-1:1,i=(n-(e?.startOffset??0))*r,a=Math.max(i/(e?.startSize??0),-.999999);return e.columnSizingStart.forEach(e=>{let[t,n]=e;l[t]=Math.round(Math.max(n+n*a,0)*100)/100}),{...e,deltaOffset:i,deltaPercentage:a}}),(t.options.columnResizeMode===`onChange`||e===`end`)&&t.setColumnSizing(e=>({...e,...l})))},d=e=>u(`move`,e),f=e=>{u(`end`,e),t.setColumnSizingInfo(e=>({...e,isResizingColumn:!1,startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,columnSizingStart:[]}))},p=Yx(n),m={moveHandler:e=>d(e.clientX),upHandler:e=>{p?.removeEventListener(`mousemove`,m.moveHandler),p?.removeEventListener(`mouseup`,m.upHandler),f(e.clientX)}},h={moveHandler:e=>(e.cancelable&&(e.preventDefault(),e.stopPropagation()),d(e.touches[0].clientX),!1),upHandler:e=>{p?.removeEventListener(`touchmove`,h.moveHandler),p?.removeEventListener(`touchend`,h.upHandler),e.cancelable&&(e.preventDefault(),e.stopPropagation()),f(e.touches[0]?.clientX)}},g=eS()?{passive:!1}:!1;tS(a)?(p?.addEventListener(`touchmove`,h.moveHandler,g),p?.addEventListener(`touchend`,h.upHandler,g)):(p?.addEventListener(`mousemove`,m.moveHandler,g),p?.addEventListener(`mouseup`,m.upHandler,g)),t.setColumnSizingInfo(e=>({...e,startOffset:c,startSize:o,deltaOffset:0,deltaPercentage:0,columnSizingStart:s,isResizingColumn:r.id}))}}},createTable:e=>{e.setColumnSizing=t=>e.options.onColumnSizingChange==null?void 0:e.options.onColumnSizingChange(t),e.setColumnSizingInfo=t=>e.options.onColumnSizingInfoChange==null?void 0:e.options.onColumnSizingInfoChange(t),e.resetColumnSizing=t=>{e.setColumnSizing(t?{}:e.initialState.columnSizing??{})},e.resetHeaderSizeInfo=t=>{e.setColumnSizingInfo(t?Zx():e.initialState.columnSizingInfo??Zx())},e.getTotalSize=()=>e.getHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getLeftTotalSize=()=>e.getLeftHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getCenterTotalSize=()=>e.getCenterHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0,e.getRightTotalSize=()=>e.getRightHeaderGroups()[0]?.headers.reduce((e,t)=>e+t.getSize(),0)??0}},$x=null;function eS(){if(typeof $x==`boolean`)return $x;let e=!1;try{let t={get passive(){return e=!0,!1}},n=()=>{};window.addEventListener(`test`,n,t),window.removeEventListener(`test`,n)}catch{e=!1}return $x=e,$x}function tS(e){return e.type===`touchstart`}var nS={getInitialState:e=>({columnVisibility:{},...e}),getDefaultOptions:e=>({onColumnVisibilityChange:vx(`columnVisibility`,e)}),createColumn:(e,t)=>{e.toggleVisibility=n=>{e.getCanHide()&&t.setColumnVisibility(t=>({...t,[e.id]:n??!e.getIsVisible()}))},e.getIsVisible=()=>{let n=e.columns;return(n.length?n.some(e=>e.getIsVisible()):t.getState().columnVisibility?.[e.id])??!0},e.getCanHide=()=>(e.columnDef.enableHiding??!0)&&(t.options.enableHiding??!0),e.getToggleVisibilityHandler=()=>t=>{e.toggleVisibility==null||e.toggleVisibility(t.target.checked)}},createRow:(e,t)=>{e._getAllVisibleCells=Q(()=>[e.getAllCells(),t.getState().columnVisibility],e=>e.filter(e=>e.column.getIsVisible()),$(t.options,`debugRows`,`_getAllVisibleCells`)),e.getVisibleCells=Q(()=>[e.getLeftVisibleCells(),e.getCenterVisibleCells(),e.getRightVisibleCells()],(e,t,n)=>[...e,...t,...n],$(t.options,`debugRows`,`getVisibleCells`))},createTable:e=>{let t=(t,n)=>Q(()=>[n(),n().filter(e=>e.getIsVisible()).map(e=>e.id).join(`_`)],e=>e.filter(e=>e.getIsVisible==null?void 0:e.getIsVisible()),$(e.options,`debugColumns`,t));e.getVisibleFlatColumns=t(`getVisibleFlatColumns`,()=>e.getAllFlatColumns()),e.getVisibleLeafColumns=t(`getVisibleLeafColumns`,()=>e.getAllLeafColumns()),e.getLeftVisibleLeafColumns=t(`getLeftVisibleLeafColumns`,()=>e.getLeftLeafColumns()),e.getRightVisibleLeafColumns=t(`getRightVisibleLeafColumns`,()=>e.getRightLeafColumns()),e.getCenterVisibleLeafColumns=t(`getCenterVisibleLeafColumns`,()=>e.getCenterLeafColumns()),e.setColumnVisibility=t=>e.options.onColumnVisibilityChange==null?void 0:e.options.onColumnVisibilityChange(t),e.resetColumnVisibility=t=>{e.setColumnVisibility(t?{}:e.initialState.columnVisibility??{})},e.toggleAllColumnsVisible=t=>{t??=!e.getIsAllColumnsVisible(),e.setColumnVisibility(e.getAllLeafColumns().reduce((e,n)=>({...e,[n.id]:t||!(n.getCanHide!=null&&n.getCanHide())}),{}))},e.getIsAllColumnsVisible=()=>!e.getAllLeafColumns().some(e=>!(e.getIsVisible!=null&&e.getIsVisible())),e.getIsSomeColumnsVisible=()=>e.getAllLeafColumns().some(e=>e.getIsVisible==null?void 0:e.getIsVisible()),e.getToggleAllColumnsVisibilityHandler=()=>t=>{e.toggleAllColumnsVisible(t.target?.checked)}}};function rS(e,t){return t?t===`center`?e.getCenterVisibleLeafColumns():t===`left`?e.getLeftVisibleLeafColumns():e.getRightVisibleLeafColumns():e.getVisibleLeafColumns()}var iS={createTable:e=>{e._getGlobalFacetedRowModel=e.options.getFacetedRowModel&&e.options.getFacetedRowModel(e,`__global__`),e.getGlobalFacetedRowModel=()=>e.options.manualFiltering||!e._getGlobalFacetedRowModel?e.getPreFilteredRowModel():e._getGlobalFacetedRowModel(),e._getGlobalFacetedUniqueValues=e.options.getFacetedUniqueValues&&e.options.getFacetedUniqueValues(e,`__global__`),e.getGlobalFacetedUniqueValues=()=>e._getGlobalFacetedUniqueValues?e._getGlobalFacetedUniqueValues():new Map,e._getGlobalFacetedMinMaxValues=e.options.getFacetedMinMaxValues&&e.options.getFacetedMinMaxValues(e,`__global__`),e.getGlobalFacetedMinMaxValues=()=>{if(e._getGlobalFacetedMinMaxValues)return e._getGlobalFacetedMinMaxValues()}}},aS={getInitialState:e=>({globalFilter:void 0,...e}),getDefaultOptions:e=>({onGlobalFilterChange:vx(`globalFilter`,e),globalFilterFn:`auto`,getColumnCanGlobalFilter:t=>{var n;let r=(n=e.getCoreRowModel().flatRows[0])==null||(n=n._getAllCellsByColumnId()[t.id])==null?void 0:n.getValue();return typeof r==`string`||typeof r==`number`}}),createColumn:(e,t)=>{e.getCanGlobalFilter=()=>(e.columnDef.enableGlobalFilter??!0)&&(t.options.enableGlobalFilter??!0)&&(t.options.enableFilters??!0)&&((t.options.getColumnCanGlobalFilter==null?void 0:t.options.getColumnCanGlobalFilter(e))??!0)&&!!e.accessorFn},createTable:e=>{e.getGlobalAutoFilterFn=()=>zx.includesString,e.getGlobalFilterFn=()=>{let{globalFilterFn:t}=e.options;return yx(t)?t:t===`auto`?e.getGlobalAutoFilterFn():e.options.filterFns?.[t]??zx[t]},e.setGlobalFilter=t=>{e.options.onGlobalFilterChange==null||e.options.onGlobalFilterChange(t)},e.resetGlobalFilter=t=>{e.setGlobalFilter(t?void 0:e.initialState.globalFilter)}}},oS={getInitialState:e=>({expanded:{},...e}),getDefaultOptions:e=>({onExpandedChange:vx(`expanded`,e),paginateExpandedRows:!0}),createTable:e=>{let t=!1,n=!1;e._autoResetExpanded=()=>{if(!t){e._queue(()=>{t=!0});return}if(e.options.autoResetAll??e.options.autoResetExpanded??!e.options.manualExpanding){if(n)return;n=!0,e._queue(()=>{e.resetExpanded(),n=!1})}},e.setExpanded=t=>e.options.onExpandedChange==null?void 0:e.options.onExpandedChange(t),e.toggleAllRowsExpanded=t=>{t??!e.getIsAllRowsExpanded()?e.setExpanded(!0):e.setExpanded({})},e.resetExpanded=t=>{e.setExpanded(t?{}:e.initialState?.expanded??{})},e.getCanSomeRowsExpand=()=>e.getPrePaginationRowModel().flatRows.some(e=>e.getCanExpand()),e.getToggleAllRowsExpandedHandler=()=>t=>{t.persist==null||t.persist(),e.toggleAllRowsExpanded()},e.getIsSomeRowsExpanded=()=>{let t=e.getState().expanded;return t===!0||Object.values(t).some(Boolean)},e.getIsAllRowsExpanded=()=>{let t=e.getState().expanded;return typeof t==`boolean`?t===!0:!(!Object.keys(t).length||e.getRowModel().flatRows.some(e=>!e.getIsExpanded()))},e.getExpandedDepth=()=>{let t=0;return(e.getState().expanded===!0?Object.keys(e.getRowModel().rowsById):Object.keys(e.getState().expanded)).forEach(e=>{let n=e.split(`.`);t=Math.max(t,n.length)}),t},e.getPreExpandedRowModel=()=>e.getSortedRowModel(),e.getExpandedRowModel=()=>(!e._getExpandedRowModel&&e.options.getExpandedRowModel&&(e._getExpandedRowModel=e.options.getExpandedRowModel(e)),e.options.manualExpanding||!e._getExpandedRowModel?e.getPreExpandedRowModel():e._getExpandedRowModel())},createRow:(e,t)=>{e.toggleExpanded=n=>{t.setExpanded(r=>{let i=r===!0||!!(r!=null&&r[e.id]),a={};if(r===!0?Object.keys(t.getRowModel().rowsById).forEach(e=>{a[e]=!0}):a=r,n??=!i,!i&&n)return{...a,[e.id]:!0};if(i&&!n){let{[e.id]:t,...n}=a;return n}return r})},e.getIsExpanded=()=>{let n=t.getState().expanded;return!!((t.options.getIsRowExpanded==null?void 0:t.options.getIsRowExpanded(e))??(n===!0||n?.[e.id]))},e.getCanExpand=()=>{var n;return(t.options.getRowCanExpand==null?void 0:t.options.getRowCanExpand(e))??((t.options.enableExpanding??!0)&&!!((n=e.subRows)!=null&&n.length))},e.getIsAllParentsExpanded=()=>{let n=!0,r=e;for(;n&&r.parentId;)r=t.getRow(r.parentId,!0),n=r.getIsExpanded();return n},e.getToggleExpandedHandler=()=>{let t=e.getCanExpand();return()=>{t&&e.toggleExpanded()}}}},sS=0,cS=10,lS=()=>({pageIndex:sS,pageSize:cS}),uS={getInitialState:e=>({...e,pagination:{...lS(),...e?.pagination}}),getDefaultOptions:e=>({onPaginationChange:vx(`pagination`,e)}),createTable:e=>{let t=!1,n=!1;e._autoResetPageIndex=()=>{if(!t){e._queue(()=>{t=!0});return}if(e.options.autoResetAll??e.options.autoResetPageIndex??!e.options.manualPagination){if(n)return;n=!0,e._queue(()=>{e.resetPageIndex(),n=!1})}},e.setPagination=t=>e.options.onPaginationChange==null?void 0:e.options.onPaginationChange(e=>_x(t,e)),e.resetPagination=t=>{e.setPagination(t?lS():e.initialState.pagination??lS())},e.setPageIndex=t=>{e.setPagination(n=>{let r=_x(t,n.pageIndex),i=e.options.pageCount===void 0||e.options.pageCount===-1?2**53-1:e.options.pageCount-1;return r=Math.max(0,Math.min(r,i)),{...n,pageIndex:r}})},e.resetPageIndex=t=>{var n;e.setPageIndex(t?sS:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageIndex)??sS)},e.resetPageSize=t=>{var n;e.setPageSize(t?cS:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageSize)??cS)},e.setPageSize=t=>{e.setPagination(e=>{let n=Math.max(1,_x(t,e.pageSize)),r=e.pageSize*e.pageIndex,i=Math.floor(r/n);return{...e,pageIndex:i,pageSize:n}})},e.setPageCount=t=>e.setPagination(n=>{let r=_x(t,e.options.pageCount??-1);return typeof r==`number`&&(r=Math.max(-1,r)),{...n,pageCount:r}}),e.getPageOptions=Q(()=>[e.getPageCount()],e=>{let t=[];return e&&e>0&&(t=[...Array(e)].fill(null).map((e,t)=>t)),t},$(e.options,`debugTable`,`getPageOptions`)),e.getCanPreviousPage=()=>e.getState().pagination.pageIndex>0,e.getCanNextPage=()=>{let{pageIndex:t}=e.getState().pagination,n=e.getPageCount();return n===-1||n!==0&&t<n-1},e.previousPage=()=>e.setPageIndex(e=>e-1),e.nextPage=()=>e.setPageIndex(e=>e+1),e.firstPage=()=>e.setPageIndex(0),e.lastPage=()=>e.setPageIndex(e.getPageCount()-1),e.getPrePaginationRowModel=()=>e.getExpandedRowModel(),e.getPaginationRowModel=()=>(!e._getPaginationRowModel&&e.options.getPaginationRowModel&&(e._getPaginationRowModel=e.options.getPaginationRowModel(e)),e.options.manualPagination||!e._getPaginationRowModel?e.getPrePaginationRowModel():e._getPaginationRowModel()),e.getPageCount=()=>e.options.pageCount??Math.ceil(e.getRowCount()/e.getState().pagination.pageSize),e.getRowCount=()=>e.options.rowCount??e.getPrePaginationRowModel().rows.length}},dS=()=>({top:[],bottom:[]}),fS={getInitialState:e=>({rowPinning:dS(),...e}),getDefaultOptions:e=>({onRowPinningChange:vx(`rowPinning`,e)}),createRow:(e,t)=>{e.pin=(n,r,i)=>{let a=r?e.getLeafRows().map(e=>{let{id:t}=e;return t}):[],o=i?e.getParentRows().map(e=>{let{id:t}=e;return t}):[],s=new Set([...o,e.id,...a]);t.setRowPinning(e=>n===`bottom`?{top:(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),bottom:[...(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e))),...Array.from(s)]}:n===`top`?{top:[...(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),...Array.from(s)],bottom:(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e)))}:{top:(e?.top??[]).filter(e=>!(s!=null&&s.has(e))),bottom:(e?.bottom??[]).filter(e=>!(s!=null&&s.has(e)))})},e.getCanPin=()=>{let{enableRowPinning:n,enablePinning:r}=t.options;return typeof n==`function`?n(e):n??r??!0},e.getIsPinned=()=>{let n=[e.id],{top:r,bottom:i}=t.getState().rowPinning,a=n.some(e=>r?.includes(e)),o=n.some(e=>i?.includes(e));return a?`top`:o?`bottom`:!1},e.getPinnedIndex=()=>{let n=e.getIsPinned();return n?((n===`top`?t.getTopRows():t.getBottomRows())?.map(e=>{let{id:t}=e;return t}))?.indexOf(e.id)??-1:-1}},createTable:e=>{e.setRowPinning=t=>e.options.onRowPinningChange==null?void 0:e.options.onRowPinningChange(t),e.resetRowPinning=t=>e.setRowPinning(t?dS():e.initialState?.rowPinning??dS()),e.getIsSomeRowsPinned=t=>{let n=e.getState().rowPinning;return t?!!n[t]?.length:!!(n.top?.length||n.bottom?.length)},e._getPinnedRows=(t,n,r)=>(e.options.keepPinnedRows??!0?(n??[]).map(t=>{let n=e.getRow(t,!0);return n.getIsAllParentsExpanded()?n:null}):(n??[]).map(e=>t.find(t=>t.id===e))).filter(Boolean).map(e=>({...e,position:r})),e.getTopRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.top],(t,n)=>e._getPinnedRows(t,n,`top`),$(e.options,`debugRows`,`getTopRows`)),e.getBottomRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.bottom],(t,n)=>e._getPinnedRows(t,n,`bottom`),$(e.options,`debugRows`,`getBottomRows`)),e.getCenterRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.top,e.getState().rowPinning.bottom],(e,t,n)=>{let r=new Set([...t??[],...n??[]]);return e.filter(e=>!r.has(e.id))},$(e.options,`debugRows`,`getCenterRows`))}},pS={getInitialState:e=>({rowSelection:{},...e}),getDefaultOptions:e=>({onRowSelectionChange:vx(`rowSelection`,e),enableRowSelection:!0,enableMultiRowSelection:!0,enableSubRowSelection:!0}),createTable:e=>{e.setRowSelection=t=>e.options.onRowSelectionChange==null?void 0:e.options.onRowSelectionChange(t),e.resetRowSelection=t=>e.setRowSelection(t?{}:e.initialState.rowSelection??{}),e.toggleAllRowsSelected=t=>{e.setRowSelection(n=>{t=t===void 0?!e.getIsAllRowsSelected():t;let r={...n},i=e.getPreGroupedRowModel().flatRows;return t?i.forEach(e=>{e.getCanSelect()&&(r[e.id]=!0)}):i.forEach(e=>{delete r[e.id]}),r})},e.toggleAllPageRowsSelected=t=>e.setRowSelection(n=>{let r=t===void 0?!e.getIsAllPageRowsSelected():t,i={...n};return e.getRowModel().rows.forEach(t=>{mS(i,t.id,r,!0,e)}),i}),e.getPreSelectedRowModel=()=>e.getCoreRowModel(),e.getSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getCoreRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getSelectedRowModel`)),e.getFilteredSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getFilteredRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getFilteredSelectedRowModel`)),e.getGroupedSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getSortedRowModel()],(t,n)=>Object.keys(t).length?hS(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getGroupedSelectedRowModel`)),e.getIsAllRowsSelected=()=>{let t=e.getFilteredRowModel().flatRows,{rowSelection:n}=e.getState(),r=!!(t.length&&Object.keys(n).length);return r&&t.some(e=>e.getCanSelect()&&!n[e.id])&&(r=!1),r},e.getIsAllPageRowsSelected=()=>{let t=e.getPaginationRowModel().flatRows.filter(e=>e.getCanSelect()),{rowSelection:n}=e.getState(),r=!!t.length;return r&&t.some(e=>!n[e.id])&&(r=!1),r},e.getIsSomeRowsSelected=()=>{let t=Object.keys(e.getState().rowSelection??{}).length;return t>0&&t<e.getFilteredRowModel().flatRows.length},e.getIsSomePageRowsSelected=()=>{let t=e.getPaginationRowModel().flatRows;return!e.getIsAllPageRowsSelected()&&t.filter(e=>e.getCanSelect()).some(e=>e.getIsSelected()||e.getIsSomeSelected())},e.getToggleAllRowsSelectedHandler=()=>t=>{e.toggleAllRowsSelected(t.target.checked)},e.getToggleAllPageRowsSelectedHandler=()=>t=>{e.toggleAllPageRowsSelected(t.target.checked)}},createRow:(e,t)=>{e.toggleSelected=(n,r)=>{let i=e.getIsSelected();t.setRowSelection(a=>{if(n=n===void 0?!i:n,e.getCanSelect()&&i===n)return a;let o={...a};return mS(o,e.id,n,r?.selectChildren??!0,t),o})},e.getIsSelected=()=>{let{rowSelection:n}=t.getState();return gS(e,n)},e.getIsSomeSelected=()=>{let{rowSelection:n}=t.getState();return _S(e,n)===`some`},e.getIsAllSubRowsSelected=()=>{let{rowSelection:n}=t.getState();return _S(e,n)===`all`},e.getCanSelect=()=>typeof t.options.enableRowSelection==`function`?t.options.enableRowSelection(e):t.options.enableRowSelection??!0,e.getCanSelectSubRows=()=>typeof t.options.enableSubRowSelection==`function`?t.options.enableSubRowSelection(e):t.options.enableSubRowSelection??!0,e.getCanMultiSelect=()=>typeof t.options.enableMultiRowSelection==`function`?t.options.enableMultiRowSelection(e):t.options.enableMultiRowSelection??!0,e.getToggleSelectedHandler=()=>{let t=e.getCanSelect();return n=>{t&&e.toggleSelected(n.target?.checked)}}}},mS=(e,t,n,r,i)=>{var a;let o=i.getRow(t,!0);n?(o.getCanMultiSelect()||Object.keys(e).forEach(t=>delete e[t]),o.getCanSelect()&&(e[t]=!0)):delete e[t],r&&(a=o.subRows)!=null&&a.length&&o.getCanSelectSubRows()&&o.subRows.forEach(t=>mS(e,t.id,n,r,i))};function hS(e,t){let n=e.getState().rowSelection,r=[],i={},a=function(e,t){return e.map(e=>{var t;let o=gS(e,n);if(o&&(r.push(e),i[e.id]=e),(t=e.subRows)!=null&&t.length&&(e={...e,subRows:a(e.subRows)}),o)return e}).filter(Boolean)};return{rows:a(t.rows),flatRows:r,rowsById:i}}function gS(e,t){return t[e.id]??!1}function _S(e,t,n){var r;if(!((r=e.subRows)!=null&&r.length))return!1;let i=!0,a=!1;return e.subRows.forEach(e=>{if(!(a&&!i)&&(e.getCanSelect()&&(gS(e,t)?a=!0:i=!1),e.subRows&&e.subRows.length)){let n=_S(e,t);n===`all`?a=!0:(n===`some`&&(a=!0),i=!1)}}),i?`all`:a?`some`:!1}var vS=/([0-9]+)/gm,yS=(e,t,n)=>DS(ES(e.getValue(n)).toLowerCase(),ES(t.getValue(n)).toLowerCase()),bS=(e,t,n)=>DS(ES(e.getValue(n)),ES(t.getValue(n))),xS=(e,t,n)=>TS(ES(e.getValue(n)).toLowerCase(),ES(t.getValue(n)).toLowerCase()),SS=(e,t,n)=>TS(ES(e.getValue(n)),ES(t.getValue(n))),CS=(e,t,n)=>{let r=e.getValue(n),i=t.getValue(n);return r>i?1:r<i?-1:0},wS=(e,t,n)=>TS(e.getValue(n),t.getValue(n));function TS(e,t){return e===t?0:e>t?1:-1}function ES(e){return typeof e==`number`?isNaN(e)||e===1/0||e===-1/0?``:String(e):typeof e==`string`?e:``}function DS(e,t){let n=e.split(vS).filter(Boolean),r=t.split(vS).filter(Boolean);for(;n.length&&r.length;){let e=n.shift(),t=r.shift(),i=parseInt(e,10),a=parseInt(t,10),o=[i,a].sort();if(isNaN(o[0])){if(e>t)return 1;if(t>e)return-1;continue}if(isNaN(o[1]))return isNaN(i)?-1:1;if(i>a)return 1;if(a>i)return-1}return n.length-r.length}var OS={alphanumeric:yS,alphanumericCaseSensitive:bS,text:xS,textCaseSensitive:SS,datetime:CS,basic:wS},kS=[Ex,nS,Kx,Jx,kx,Vx,iS,aS,{getInitialState:e=>({sorting:[],...e}),getDefaultColumnDef:()=>({sortingFn:`auto`,sortUndefined:1}),getDefaultOptions:e=>({onSortingChange:vx(`sorting`,e),isMultiSortEvent:e=>e.shiftKey}),createColumn:(e,t)=>{e.getAutoSortingFn=()=>{let n=t.getFilteredRowModel().flatRows.slice(10),r=!1;for(let t of n){let n=t?.getValue(e.id);if(Object.prototype.toString.call(n)===`[object Date]`)return OS.datetime;if(typeof n==`string`&&(r=!0,n.split(vS).length>1))return OS.alphanumeric}return r?OS.text:OS.basic},e.getAutoSortDir=()=>typeof t.getFilteredRowModel().flatRows[0]?.getValue(e.id)==`string`?`asc`:`desc`,e.getSortingFn=()=>{if(!e)throw Error();return yx(e.columnDef.sortingFn)?e.columnDef.sortingFn:e.columnDef.sortingFn===`auto`?e.getAutoSortingFn():t.options.sortingFns?.[e.columnDef.sortingFn]??OS[e.columnDef.sortingFn]},e.toggleSorting=(n,r)=>{let i=e.getNextSortingOrder(),a=n!=null;t.setSorting(o=>{let s=o?.find(t=>t.id===e.id),c=o?.findIndex(t=>t.id===e.id),l=[],u,d=a?n:i===`desc`;return u=o!=null&&o.length&&e.getCanMultiSort()&&r?s?`toggle`:`add`:o!=null&&o.length&&c!==o.length-1?`replace`:s?`toggle`:`replace`,u===`toggle`&&(a||i||(u=`remove`)),u===`add`?(l=[...o,{id:e.id,desc:d}],l.splice(0,l.length-(t.options.maxMultiSortColCount??2**53-1))):l=u===`toggle`?o.map(t=>t.id===e.id?{...t,desc:d}:t):u===`remove`?o.filter(t=>t.id!==e.id):[{id:e.id,desc:d}],l})},e.getFirstSortDir=()=>e.columnDef.sortDescFirst??t.options.sortDescFirst??e.getAutoSortDir()===`desc`?`desc`:`asc`,e.getNextSortingOrder=n=>{let r=e.getFirstSortDir(),i=e.getIsSorted();return i?i!==r&&(t.options.enableSortingRemoval??!0)&&(!n||(t.options.enableMultiRemove??!0))?!1:i===`desc`?`asc`:`desc`:r},e.getCanSort=()=>(e.columnDef.enableSorting??!0)&&(t.options.enableSorting??!0)&&!!e.accessorFn,e.getCanMultiSort=()=>e.columnDef.enableMultiSort??t.options.enableMultiSort??!!e.accessorFn,e.getIsSorted=()=>{let n=t.getState().sorting?.find(t=>t.id===e.id);return n?n.desc?`desc`:`asc`:!1},e.getSortIndex=()=>t.getState().sorting?.findIndex(t=>t.id===e.id)??-1,e.clearSorting=()=>{t.setSorting(t=>t!=null&&t.length?t.filter(t=>t.id!==e.id):[])},e.getToggleSortingHandler=()=>{let n=e.getCanSort();return r=>{n&&(r.persist==null||r.persist(),e.toggleSorting==null||e.toggleSorting(void 0,e.getCanMultiSort()?t.options.isMultiSortEvent==null?void 0:t.options.isMultiSortEvent(r):!1))}}},createTable:e=>{e.setSorting=t=>e.options.onSortingChange==null?void 0:e.options.onSortingChange(t),e.resetSorting=t=>{e.setSorting(t?[]:e.initialState?.sorting??[])},e.getPreSortedRowModel=()=>e.getGroupedRowModel(),e.getSortedRowModel=()=>(!e._getSortedRowModel&&e.options.getSortedRowModel&&(e._getSortedRowModel=e.options.getSortedRowModel(e)),e.options.manualSorting||!e._getSortedRowModel?e.getPreSortedRowModel():e._getSortedRowModel())}},Wx,oS,uS,fS,pS,Qx];function AS(e){let t=[...kS,...e._features??[]],n={_features:t},r=n._features.reduce((e,t)=>Object.assign(e,t.getDefaultOptions==null?void 0:t.getDefaultOptions(n)),{}),i=e=>n.options.mergeOptions?n.options.mergeOptions(r,e):{...r,...e},a={...e.initialState??{}};n._features.forEach(e=>{a=(e.getInitialState==null?void 0:e.getInitialState(a))??a});let o=[],s=!1,c={_features:t,options:{...r,...e},initialState:a,_queue:e=>{o.push(e),s||(s=!0,Promise.resolve().then(()=>{for(;o.length;)o.shift()();s=!1}).catch(e=>setTimeout(()=>{throw e})))},reset:()=>{n.setState(n.initialState)},setOptions:e=>{let t=_x(e,n.options);n.options=i(t)},getState:()=>n.options.state,setState:e=>{n.options.onStateChange==null||n.options.onStateChange(e)},_getRowId:(e,t,r)=>(n.options.getRowId==null?void 0:n.options.getRowId(e,t,r))??`${r?[r.id,t].join(`.`):t}`,getCoreRowModel:()=>(n._getCoreRowModel||=n.options.getCoreRowModel(n),n._getCoreRowModel()),getRowModel:()=>n.getPaginationRowModel(),getRow:(e,t)=>{let r=(t?n.getPrePaginationRowModel():n.getRowModel()).rowsById[e];if(!r&&(r=n.getCoreRowModel().rowsById[e],!r))throw Error();return r},_getDefaultColumnDef:Q(()=>[n.options.defaultColumn],e=>(e??={},{header:e=>{let t=e.header.column.columnDef;return t.accessorKey?t.accessorKey:t.accessorFn?t.id:null},cell:e=>{var t;return((t=e.renderValue())==null||t.toString==null?void 0:t.toString())??null},...n._features.reduce((e,t)=>Object.assign(e,t.getDefaultColumnDef==null?void 0:t.getDefaultColumnDef()),{}),...e}),$(e,`debugColumns`,`_getDefaultColumnDef`)),_getColumnDefs:()=>n.options.columns,getAllColumns:Q(()=>[n._getColumnDefs()],e=>{let t=function(e,r,i){return i===void 0&&(i=0),e.map(e=>{let a=Cx(n,e,i,r),o=e;return a.columns=o.columns?t(o.columns,a,i+1):[],a})};return t(e)},$(e,`debugColumns`,`getAllColumns`)),getAllFlatColumns:Q(()=>[n.getAllColumns()],e=>e.flatMap(e=>e.getFlatColumns()),$(e,`debugColumns`,`getAllFlatColumns`)),_getAllFlatColumnsById:Q(()=>[n.getAllFlatColumns()],e=>e.reduce((e,t)=>(e[t.id]=t,e),{}),$(e,`debugColumns`,`getAllFlatColumnsById`)),getAllLeafColumns:Q(()=>[n.getAllColumns(),n._getOrderColumnsFn()],(e,t)=>t(e.flatMap(e=>e.getLeafColumns())),$(e,`debugColumns`,`getAllLeafColumns`)),getColumn:e=>n._getAllFlatColumnsById()[e]};Object.assign(n,c);for(let e=0;e<n._features.length;e++){let t=n._features[e];t==null||t.createTable==null||t.createTable(n)}return n}function jS(){return e=>Q(()=>[e.options.data],t=>{let n={rows:[],flatRows:[],rowsById:{}},r=function(t,i,a){i===void 0&&(i=0);let o=[];for(let c=0;c<t.length;c++){let l=Ox(e,e._getRowId(t[c],c,a),t[c],c,i,void 0,a?.id);if(n.flatRows.push(l),n.rowsById[l.id]=l,o.push(l),e.options.getSubRows){var s;l.originalSubRows=e.options.getSubRows(t[c],c),(s=l.originalSubRows)!=null&&s.length&&(l.subRows=r(l.originalSubRows,i+1,l))}}return o};return n.rows=r(t),n},$(e.options,`debugTable`,`getRowModel`,()=>e._autoResetPageIndex()))}function MS(){return e=>Q(()=>[e.getState().sorting,e.getPreSortedRowModel()],(t,n)=>{if(!n.rows.length||!(t!=null&&t.length))return n;let r=e.getState().sorting,i=[],a=r.filter(t=>e.getColumn(t.id)?.getCanSort()),o={};a.forEach(t=>{let n=e.getColumn(t.id);n&&(o[t.id]={sortUndefined:n.columnDef.sortUndefined,invertSorting:n.columnDef.invertSorting,sortingFn:n.getSortingFn()})});let s=e=>{let t=e.map(e=>({...e}));return t.sort((e,t)=>{for(let n=0;n<a.length;n+=1){let r=a[n],i=o[r.id],s=i.sortUndefined,c=r?.desc??!1,l=0;if(s){let n=e.getValue(r.id),i=t.getValue(r.id),a=n===void 0,o=i===void 0;if(a||o){if(s===`first`)return a?-1:1;if(s===`last`)return a?1:-1;l=a&&o?0:a?s:-s}}if(l===0&&(l=i.sortingFn(e,t,r.id)),l!==0)return c&&(l*=-1),i.invertSorting&&(l*=-1),l}return e.index-t.index}),t.forEach(e=>{var t;i.push(e),(t=e.subRows)!=null&&t.length&&(e.subRows=s(e.subRows))}),t};return{rows:s(n.rows),flatRows:i,rowsById:n.rowsById}},$(e.options,`debugTable`,`getSortedRowModel`,()=>e._autoResetPageIndex()))}function NS(){return!0}var PS=Symbol(`merge-proxy`),FS={get(e,t,n){return t===PS?n:e.get(t)},has(e,t){return e.has(t)},set:NS,deleteProperty:NS,getOwnPropertyDescriptor(e,t){return{configurable:!0,enumerable:!0,get(){return e.get(t)},set:NS,deleteProperty:NS}},ownKeys(e){return e.keys()}};function IS(e){return`value`in e?e.value:e}function LS(){var e=[...arguments];return new Proxy({get(t){for(let n=e.length-1;n>=0;n--){let r=IS(e[n])[t];if(r!==void 0)return r}},has(t){for(let n=e.length-1;n>=0;n--)if(t in IS(e[n]))return!0;return!1},keys(){let t=[];for(let n=0;n<e.length;n++)t.push(...Object.keys(IS(e[n])));return[...Array.from(new Set(t))]}},FS)}var RS=F({props:[`render`,`props`],setup:e=>()=>typeof e.render==`function`||typeof e.render==`object`?G(e.render,e.props):e.render});function zS(e){return LS(e,{data:N(e.data)})}function BS(e){let t=j(e.data),n=AS(LS({state:{},onStateChange:()=>{},renderFallbackValue:null,mergeOptions(e,n){return t?{...e,...n}:LS(e,n)}},t?zS(e):e));if(t){let t=un(e.data);Er(t,()=>{n.setState(e=>({...e,data:t.value}))},{immediate:!0})}let r=M(n.initialState);return Cr(()=>{n.setOptions(n=>{let i=new Proxy({},{get:(e,t)=>r.value[t]});return LS(n,t?zS(e):e,{state:LS(i,e.state??{}),onStateChange:t=>{t instanceof Function?r.value=t(r.value):r.value=t,e.onStateChange==null||e.onStateChange(t)}})})}),n}var VS=[`aria-label`],HS=F({__name:`SortHeaderButton`,props:{header:{}},setup(e){let t=e,n=W(()=>t.header.column.getIsSorted()),r=W(()=>n.value===`asc`?a_:n.value===`desc`?v_:d_),i=W(()=>{let e=t.header.column.columnDef.header;return typeof e==`string`?e:t.header.column.id}),a=W(()=>{let e=n.value===`asc`?`ascending`:n.value===`desc`?`descending`:`none`;return`Sort by ${i.value}, currently ${e}`});function o(){t.header.column.toggleSorting(n.value===`asc`)}return(t,i)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`button`,{type:`button`,"aria-label":a.value,class:`inline-flex items-center gap-1 rounded px-1.5 py-0.5 hover:text-foreground focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring`,onClick:o},[e.header.isPlaceholder?Ts(``,!0):(R(),B(N(RS),{key:0,render:e.header.column.columnDef.header,props:e.header.getContext()},null,8,[`render`,`props`])),H(s,{icon:r.value,class:O([`size-3 shrink-0`,n.value?`text-foreground`:`text-muted-foreground/60`]),"aria-hidden":`true`},null,8,[`icon`,`class`])],8,VS)}}}),US={"data-slot":`table-container`,class:`relative w-full overflow-x-auto`},WS=F({__name:`Table`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`div`,US,[V(`table`,{"data-slot":`table`,class:O(N(Yv)(`w-full caption-bottom text-sm`,t.class))},[I(e.$slots,`default`)],2)]))}}),GS=F({__name:`TableBody`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`tbody`,{"data-slot":`table-body`,class:O(N(Yv)(`[&_tr:last-child]:border-0`,t.class))},[I(e.$slots,`default`)],2))}}),KS=F({__name:`TableCell`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`td`,{"data-slot":`table-cell`,class:O(N(Yv)(`p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[I(e.$slots,`default`)],2))}}),qS=F({__name:`TableRow`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`tr`,{"data-slot":`table-row`,class:O(N(Yv)(`hover:bg-muted/50 data-[state=selected]:bg-muted border-b transition-colors has-aria-expanded:bg-muted/50`,t.class))},[I(e.$slots,`default`)],2))}}),JS={class:`flex items-center justify-center py-10`},YS=F({__name:`TableEmpty`,props:{class:{type:[Boolean,null,String,Object,Array]},colspan:{default:1}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(qS,null,{default:P(()=>[H(KS,ks({class:N(Yv)(`p-4 whitespace-nowrap align-middle text-sm text-foreground`,t.class)},N(n)),{default:P(()=>[V(`div`,JS,[I(e.$slots,`default`)])]),_:3},16,[`class`])]),_:3}))}}),XS=F({__name:`TableHead`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`th`,{"data-slot":`table-head`,class:O(N(Yv)(`text-foreground h-10 px-2 text-left align-middle font-medium whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[I(e.$slots,`default`)],2))}}),ZS=F({__name:`TableHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(R(),z(`thead`,{"data-slot":`table-header`,class:O(N(Yv)(`[&_tr]:border-b`,t.class))},[I(e.$slots,`default`)],2))}});function QS(e,t){t.value=typeof e==`function`?e(t.value):e}var $S=F({__name:`DataTable`,props:{columns:{},data:{},rowClass:{type:Function},emptyMessage:{}},setup(e){let t=e,n=M([]),r=BS({get data(){return t.data},get columns(){return t.columns},getCoreRowModel:jS(),getSortedRowModel:MS(),onSortingChange:e=>QS(e,n),state:{get sorting(){return n.value}}});function i(e){if(e===`asc`)return`ascending`;if(e===`desc`)return`descending`}return(t,n)=>(R(),B(N(WS),null,{default:P(()=>[H(N(ZS),null,{default:P(()=>[(R(!0),z(L,null,ma(N(r).getHeaderGroups(),e=>(R(),B(N(qS),{key:e.id},{default:P(()=>[(R(!0),z(L,null,ma(e.headers,e=>(R(),B(N(XS),{key:e.id,class:O(e.column.columnDef.meta?.align===`right`?`text-right`:void 0),"aria-sort":e.column.getCanSort()?i(e.column.getIsSorted())??`none`:void 0},{default:P(()=>[e.column.getCanSort()?(R(),B(HS,{key:0,header:e,class:`-mx-1.5`},null,8,[`header`])):e.isPlaceholder?Ts(``,!0):(R(),B(N(RS),{key:1,render:e.column.columnDef.header,props:e.getContext()},null,8,[`render`,`props`]))]),_:2},1032,[`class`,`aria-sort`]))),128))]),_:2},1024))),128))]),_:1}),H(N(GS),null,{default:P(()=>[N(r).getRowModel().rows.length===0?(R(),B(N(YS),{key:0,colspan:e.columns.length,class:`text-muted-foreground`},{default:P(()=>[U(k(e.emptyMessage??`none`),1)]),_:1},8,[`colspan`])):Ts(``,!0),(R(!0),z(L,null,ma(N(r).getRowModel().rows,t=>(R(),B(N(qS),{key:t.id,class:O(e.rowClass?.(t.original))},{default:P(()=>[(R(!0),z(L,null,ma(t.getVisibleCells(),e=>(R(),B(N(KS),{key:e.id,class:O(e.column.columnDef.meta?.align===`right`?`text-right tabular-nums`:void 0)},{default:P(()=>[H(N(RS),{render:e.column.columnDef.cell,props:e.getContext()},null,8,[`render`,`props`])]),_:2},1032,[`class`]))),128))]),_:2},1032,[`class`]))),128))]),_:1})]),_:1}))}}),eC=F({__name:`Badge`,props:{asChild:{type:Boolean},as:{},variant:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(r,i)=>(R(),B(N(nb),ks({"data-slot":`badge`,"data-variant":e.variant,class:N(Yv)(N(tC)({variant:e.variant}),t.class)},N(n)),{default:P(()=>[I(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),tC=C_(`h-5 gap-1 rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium transition-all has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&>svg]:size-3! group/badge inline-flex w-fit shrink-0 items-center justify-center overflow-hidden whitespace-nowrap focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none`,{variants:{variant:{default:`bg-primary text-primary-foreground [a]:hover:bg-primary/80`,secondary:`bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80`,destructive:`bg-destructive/10 [a]:hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 text-destructive dark:bg-destructive/20`,outline:`border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground`,ghost:`hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50`,link:`text-primary underline-offset-4 hover:underline`}},defaultVariants:{variant:`default`}});async function nC(e,t){if(navigator.clipboard?.writeText)try{return await navigator.clipboard.writeText(e),`copied`}catch{}if(!t)return`failed`;let n=document.createRange();n.selectNodeContents(t);let r=window.getSelection();return r?(r.removeAllRanges(),r.addRange(n),`selected`):`failed`}function rC(e,t){return`${e}/${t}`}function iC(e){return`$${(e/1e6).toFixed(4)}`}function aC(e){return e.toLocaleString(`en-US`)}function oC(e){let t=Math.abs(e);if(t<1e4)return aC(e);let n=e<0?`-`:``,[r,i]=t<1e6?[1e3,`k`]:t<1e9?[1e6,`M`]:[1e9,`B`],a=t/r,o=3-(Math.floor(a)>=100?3:Math.floor(a)>=10?2:1),s=10**o,c=(Math.floor(t*s/r)/s).toFixed(o);return o>0&&(c=c.replace(/0+$/,``).replace(/\.$/,``)),`${n}${c}${i}`}function sC(e){return e>0&&!(e&e-1)}function cC(e){return e<1024?`${e}`:sC(e)?e<1048576?`${Math.round(e/1024)}k`:`${Math.round(e/1048576)}M`:e<1e6?`${Math.round(e/1e3)}k`:`${Math.round(e/1e6)}M`}function lC(e){return`$${e.toFixed(2)}`}function uC(e,t){return e===0&&t===0?`free`:`in ${lC(e)} / out ${lC(t)} per MTok`}function dC(e){return e<1e3?`${Math.round(e)}ms`:`${(e/1e3).toFixed(1)}s`}function fC(e,t){if(!e||e===`0001-01-01T00:00:00Z`)return null;let n=new Date(e).getTime();return Number.isNaN(n)?null:Math.max(0,Math.round((t-n)/1e3))}function pC(e){let t=fC(e,Date.now());return t===null?``:` (${t}s ago)`}function mC(e,t=Date.now()){let n=fC(e,t);return n===null?``:`${n}s ago`}function hC(e){if(!e||e===`0001-01-01T00:00:00Z`)return``;let t=new Date(e).getTime();if(Number.isNaN(t))return``;let n=Math.round((t-Date.now())/1e3);return n<=0?``:`in ${n}s`}function gC(e){if(!e||e===`0001-01-01T00:00:00Z`)return`never`;let t=new Date(e);return Number.isNaN(t.getTime())?e:t.toLocaleString()}function _C(e,t){return e?pC(t)?`refreshed`:`pending`:`off`}function vC(e,t){switch(_C(e,t)){case`off`:return`discovery off`;case`pending`:return`pending`;case`refreshed`:return`refreshed${pC(t)}`}}function yC(e,t){switch(_C(e,t)){case`off`:return`discovery off`;case`pending`:return`pending`;case`refreshed`:return gC(t)}}function bC(e){if(!e)return`none`;let t=[];return e.requestsPerMinute&&t.push(`req/min ${e.requestsPerMinute}`),e.requestsPerDay&&t.push(`req/day ${e.requestsPerDay}`),e.tokensPerDay&&t.push(`tok/day ${e.tokensPerDay}`),e.tokensPerMonth&&t.push(`tok/month ${e.tokensPerMonth}`),e.costPerDayUSD&&t.push(`cost/day $${e.costPerDayUSD}`),e.costPerMonthUSD&&t.push(`cost/month $${e.costPerMonthUSD}`),t.length?t.join(`, `):`none`}function xC(e,t){switch(t){case`hour`:return`${e.slice(8,10)}:00`;case`day`:{let t=Number(e.slice(0,4)),n=Number(e.slice(4,6)),r=Number(e.slice(6,8));return new Date(t,n-1,r).toLocaleDateString(void 0,{month:`short`,day:`numeric`})}case`month`:{let t=Number(e.slice(0,4)),n=Number(e.slice(4,6));return new Date(t,n-1,1).toLocaleDateString(void 0,{month:`short`,year:`numeric`})}}}var SC=F({__name:`ModelChip`,props:{id:{},contextTokens:{},inputPerMTokUsd:{},outputPerMTokUsd:{}},setup(e){let t=e,n=si(`label`),r=M(`idle`),i;function a(){clearTimeout(i),i=setTimeout(()=>{r.value=`idle`},1500)}async function o(){let e=await nC(t.id,n.value??void 0);r.value=e,a()}let s={idle:g_,copied:u_,selected:u_,failed:h_},c=W(()=>({idle:`Copy ${t.id}`,copied:`Copied`,selected:`Selected — press Ctrl/Cmd+C`,failed:`Copy failed`})),l=W(()=>{let e=[];return t.inputPerMTokUsd!==void 0&&t.outputPerMTokUsd!==void 0&&e.push(uC(t.inputPerMTokUsd,t.outputPerMTokUsd)),t.contextTokens!==void 0&&e.push(`${cC(t.contextTokens)} context`),e.join(` · `)}),u=W(()=>{let e=c.value[r.value];return l.value?`${e} · ${l.value}`:e});return ta(()=>{clearTimeout(i)}),(t,n)=>{let i=ca(`FontAwesomeIcon`);return R(),B(N(eC),{as:`button`,type:`button`,variant:`secondary`,class:O([`cursor-pointer gap-1 font-mono text-xs font-normal transition-colors hover:bg-accent hover:text-accent-foreground`,r.value===`failed`?`text-destructive`:``]),title:u.value,"aria-label":u.value,onClick:o},{default:P(()=>[V(`span`,{ref:`label`,class:`select-text`},k(e.id),513),H(i,{icon:s[r.value],class:`size-2.5 shrink-0`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`class`,`title`,`aria-label`])}}});function CC(e,t){return!Number.isFinite(e)||e<=0?null:(e-(Number.isFinite(t)?t:0))/e}function wC(e){return e===null?`no-traffic`:e<.9?`severe`:e<.99?`degraded`:`healthy`}function TC(e,t){let n=CC(e,t);return n!==null&&n<.99}function EC(e){return e>=1?`100%`:`${Math.floor(e*100)}%`}function DC(e,t,n){return e===1?t:n}function OC(e,t){if(e<=0)return`no traffic in the last minute`;let n=CC(e,t),r=n===null?``:` (${EC(n)})`;return`${e} ${DC(e,`attempt`,`attempts`)}, ${t} ${DC(t,`failure`,`failures`)} in the last minute${r}`}function kC(e,t){if(e<=0)return`no traffic today`;let n=CC(e,t),r=n===null?``:` (${EC(n)})`;return`${e} ${DC(e,`attempt`,`attempts`)}, ${t} ${DC(t,`failure`,`failures`)} today${r}`}var AC={"aria-hidden":`true`},jC={class:`sr-only`},MC=F({__name:`ProviderRateBadge`,props:{attemptsDay:{},failuresDay:{},attemptsMinute:{},failuresMinute:{}},setup(e){let t=e,n=W(()=>CC(t.attemptsDay,t.failuresDay)),r=W(()=>wC(n.value)),i=W(()=>r.value===`no-traffic`?`no traffic`:EC(n.value)),a=W(()=>t.attemptsMinute===void 0||t.failuresMinute===void 0?kC(t.attemptsDay,t.failuresDay):OC(t.attemptsMinute,t.failuresMinute)),o=W(()=>r.value===`severe`?`destructive`:r.value===`healthy`?`secondary`:`outline`),s=W(()=>r.value===`degraded`?`border-status-warn/40 text-status-warn`:r.value===`no-traffic`?`text-muted-foreground`:``);return(e,t)=>(R(),B(N(eC),{as:`span`,variant:o.value,class:O([s.value,`font-normal tabular-nums`]),title:a.value},{default:P(()=>[V(`span`,AC,k(i.value),1),V(`span`,jC,k(a.value),1)]),_:1},8,[`variant`,`class`,`title`]))}}),NC=F({__name:`SearchInput`,props:{modelValue:{},placeholder:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=W(()=>n.modelValue.length>0);function a(e){r(`update:modelValue`,String(e))}function o(){r(`update:modelValue`,``)}return(t,r)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`div`,{class:O(N(Yv)(`relative`,n.class))},[H(s,{icon:N(r_),class:`pointer-events-none absolute top-1/2 left-2.5 size-3.5 -translate-y-1/2 text-muted-foreground`,"aria-hidden":`true`},null,8,[`icon`]),H(N(Qb),{"model-value":e.modelValue,type:`text`,placeholder:e.placeholder,"aria-label":e.placeholder,class:`pr-8 pl-8`,"onUpdate:modelValue":a},null,8,[`model-value`,`placeholder`,`aria-label`]),i.value?(R(),B(N(Wb),{key:0,type:`button`,variant:`ghost`,size:`icon-xs`,"aria-label":`Clear search`,class:`absolute top-1/2 right-1 -translate-y-1/2 text-muted-foreground hover:text-foreground`,onClick:o},{default:P(()=>[H(s,{icon:N(f_),class:`size-3.5`},null,8,[`icon`])]),_:1})):Ts(``,!0)],2)}}}),PC=F({__name:`Accordion`,props:{collapsible:{type:Boolean},disabled:{type:Boolean},dir:{},orientation:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},type:{},modelValue:{},defaultValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=qy(Cy(n,`class`),r);return(e,t)=>(R(),B(N(hb),ks({"data-slot":`accordion`},N(i),{class:N(Yv)(`flex w-full flex-col`,n.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`class`]))}}),FC=F({__name:`AccordionContent`,props:{forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(N(bb),ks({"data-slot":`accordion-content`},N(n),{class:`data-open:animate-accordion-down data-closed:animate-accordion-up text-sm overflow-hidden`}),{default:P(()=>[V(`div`,{class:O(N(Yv)(`pt-0 pb-2.5 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4`,t.class))},[I(e.$slots,`default`)],2)]),_:3},16))}}),IC=F({__name:`AccordionItem`,props:{disabled:{type:Boolean},value:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Ky(Cy(t,`class`));return(e,r)=>(R(),B(N(yb),ks({"data-slot":`accordion-item`},N(n),{class:N(Yv)(`not-last:border-b`,t.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`class`]))}}),LC=F({__name:`AccordionTrigger`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>{let i=ca(`FontAwesomeIcon`);return R(),B(N(xb),{class:`flex`},{default:P(()=>[H(N(Sb),ks({"data-slot":`accordion-trigger`},N(n),{class:N(Yv)(`focus-visible:ring-ring/50 focus-visible:border-ring focus-visible:after:border-ring **:data-[slot=accordion-trigger-icon]:text-muted-foreground rounded-lg py-2.5 text-left text-sm font-medium hover:underline focus-visible:ring-3 **:data-[slot=accordion-trigger-icon]:ml-auto **:data-[slot=accordion-trigger-icon]:size-4 group/accordion-trigger relative flex flex-1 items-start justify-between border border-transparent transition-all outline-none disabled:pointer-events-none disabled:opacity-50`,t.class)}),{default:P(()=>[I(e.$slots,`default`),I(e.$slots,`icon`,{},()=>[H(i,{icon:N(m_),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden`},null,8,[`icon`]),H(i,{icon:N(s_),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none hidden shrink-0 group-aria-expanded/accordion-trigger:inline`},null,8,[`icon`])])]),_:3},16,[`class`])]),_:3})}}});function RC(){let e=M(``),t=W(()=>e.value.trim().toLowerCase());return{query:e,normalized:t,hasQuery:W(()=>t.value.length>0)}}function zC(e,t,n){if(!t)return new Set(e.manuallyExpanded);let r=new Set(e.manuallyExpanded);for(let t of n)e.manuallyCollapsed.has(t)||r.add(t);return r}function BC(e,t,n){n?(e.manuallyExpanded.delete(t),e.manuallyCollapsed.add(t)):(e.manuallyCollapsed.delete(t),e.manuallyExpanded.add(t))}function VC(e){e.manuallyCollapsed.clear()}var HC={class:`flex flex-col gap-6`},UC={class:`grid gap-4 sm:grid-cols-3`},WC={class:`font-medium`},GC={key:0,class:`flex items-start gap-1.5 text-destructive`},KC={class:`font-medium`},qC={key:0,class:`text-muted-foreground`},JC={class:`font-medium`},YC={key:0,class:`text-muted-foreground`},XC={key:0,class:`py-6 text-center text-sm text-muted-foreground`},ZC={key:1,class:`py-6 text-center text-sm text-muted-foreground`},QC={class:`flex flex-1 flex-wrap items-center gap-x-3 gap-y-1 pr-2 text-left`},$C={class:`font-medium`},ew={class:`text-xs text-muted-foreground tabular-nums`},tw={class:`text-xs text-muted-foreground`},nw={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-3`},rw={class:`break-all`},iw={key:0},aw={key:1},ow={class:`text-destructive`},sw={key:0,class:`flex flex-wrap gap-1.5`},cw={key:0,title:`context window`,class:`text-xs text-muted-foreground tabular-nums`},lw={key:1,class:`text-sm text-muted-foreground`},uw={key:0,class:`text-xs text-muted-foreground`},dw=`Per-replica, in-process only — not a fleet-wide average across this deployment’s replicas.`,fw=F({__name:`ProvidersView`,setup(e){let t=sx(),n=W(()=>t.overview),r=Zt({manuallyExpanded:new Set,manuallyCollapsed:new Set}),{query:i,normalized:a,hasQuery:o}=RC();function s(e,t){return rC(e,t).toLowerCase().includes(a.value)}function c(e){return e.models.some(t=>s(e.name,t))}function l(e){return e.alias.toLowerCase().includes(a.value)||e.target.toLowerCase().includes(a.value)}let u=W(()=>{let e=n.value?.providers??[];return o.value?e.filter(c):e}),d=W(()=>{let e=n.value?.aliases??[];return o.value?e.filter(l):e}),f=W(()=>zC(r,o.value,u.value.map(e=>e.name)));function p(e){BC(r,e,f.value.has(e))}let m=W({get:()=>Array.from(f.value),set:e=>{let t=new Set(e);for(let e of f.value)t.has(e)||p(e);for(let e of t)f.value.has(e)||p(e)}});Er(i,e=>{e.trim()===``&&VC(r)});function h(e){return o.value?e.models.filter(t=>s(e.name,t)):e.models}let g={attemptsDay:0,failuresDay:0};function _(e,t){return e.modelRates?.[t]??g}function v(e,t){let n=_(e,t);return TC(n.attemptsDay,n.failuresDay)}let y={};function b(e,t){return e.modelMeta?.[t]??y}function x(e){switch(e){case`open`:return`destructive`;case`half-open`:return`secondary`;default:return}}function S(e){let t=hC(e.openUntil);return t?`${e.healthState} (${t})`:e.healthState}function C(e){return e===`open`?`text-destructive`:`text-muted-foreground`}function w(e){return e.latency?.streaming}function ee(e){return e.latency?.[`non-streaming`]}function te(e){return e.count===void 0?`no observations counted`:`${e.count} ${e.count===1?`observation`:`observations`} on this replica`}function T(e){return`Average time to first byte, the load-sensitive reading for streaming traffic. ${te(e)}. ${dw}`}function ne(e){return`Average total response time, including generation — not a load-sensitive signal like streaming ttfb, since this provider buffers the whole completion before sending anything. ${te(e)}. ${dw}`}function re(e){return e.provenance?.estimated}function ie(e){return e.provenance?.unbilled}function E(e){let t=e.requests===1?``:`s`;return`${e.requests} non-streaming response${t} carried no usage from the provider — prompt tokens were estimated from request body size instead (${e.tokens} tokens billed from the estimate), completion billed as zero. ${dw}`}function ae(e){let t=e.requests===1?``:`s`;return`${e.requests} streaming response${t} carried no usage from the provider — the request was counted but zero tokens were billed. If this keeps happening, this provider may be serving completions entirely free against every budget. ${dw}`}let oe=[{id:`alias`,header:`Alias`,accessorFn:e=>e.alias,cell:({row:e})=>G(SC,{id:e.original.alias,contextTokens:e.original.modelMeta?.contextTokens,inputPerMTokUsd:e.original.modelMeta?.inputPerMTokUsd,outputPerMTokUsd:e.original.modelMeta?.outputPerMTokUsd})},{id:`target`,header:`Target`,accessorFn:e=>e.target,cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},e.original.target)}],se=W(()=>n.value?.aliases.length?o.value?`no aliases match "${i.value}"`:`none`:`none configured`);return(e,t)=>{let r=ca(`FontAwesomeIcon`);return R(),z(`div`,HC,[V(`div`,UC,[H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.redis.configured?N(p_):N(c_),class:O([n.value?.redis.configured?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[2]||=U(` Redis `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`flex flex-col gap-1 text-sm`},{default:P(()=>[V(`p`,WC,k(n.value?.redis.configured?`Configured`:`Not configured`),1),n.value?.redis.lastErr?(R(),z(`p`,GC,[H(r,{icon:N(h_),class:`mt-0.5 size-3.5 shrink-0`},null,8,[`icon`]),V(`span`,null,k(n.value.redis.lastErr)+k(N(pC)(n.value.redis.lastErrAt)),1)])):Ts(``,!0)]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.cache.enabled?N(p_):N(c_),class:O([n.value?.cache.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[3]||=U(` Response cache `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`text-sm`},{default:P(()=>[V(`p`,KC,k(n.value?.cache.enabled?`Enabled`:`Disabled`),1),n.value?.cache.enabled?(R(),z(`p`,qC,`ttl `+k(n.value.cache.ttl),1)):Ts(``,!0)]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:P(()=>[H(r,{icon:n.value?.retry.enabled?N(p_):N(c_),class:O([n.value?.retry.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`])},null,8,[`icon`,`class`]),t[4]||=U(` Retry `,-1)]),_:1})]),_:1}),H(N(Jb),{class:`text-sm`},{default:P(()=>[V(`p`,JC,k(n.value?.retry.enabled?`Enabled`:`Disabled`),1),n.value?.retry.enabled?(R(),z(`p`,YC,` attempts `+k(n.value.retry.attempts)+`, backoff `+k(n.value.retry.backoff),1)):Ts(``,!0)]),_:1})]),_:1})]),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[5]||=[U(`Providers`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[6]||=[U(` Every configured upstream and its last discovery refresh. Search filters providers and aliases by model id. `,-1)]]),_:1}),H(NC,{modelValue:N(i),"onUpdate:modelValue":t[0]||=e=>j(i)?i.value=e:null,placeholder:`Search models or aliases...`,class:`mt-2 max-w-sm`},null,8,[`modelValue`])]),_:1}),H(N(Jb),null,{default:P(()=>[n.value?.providers.length?N(o)&&u.value.length===0?(R(),z(`p`,ZC,` no providers match "`+k(N(i))+`" `,1)):(R(),B(N(PC),{key:2,modelValue:m.value,"onUpdate:modelValue":t[1]||=e=>m.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:P(()=>[(R(!0),z(L,null,ma(u.value,e=>(R(),B(N(IC),{key:e.name,value:e.name},{default:P(()=>[H(N(LC),null,{default:P(()=>[V(`span`,QC,[V(`span`,$C,k(e.name),1),H(N(eC),{as:`span`,variant:`secondary`,class:`font-normal`},{default:P(()=>[U(k(e.type),1)]),_:2},1024),V(`span`,ew,k(e.modelCount)+` models`,1),H(MC,{"attempts-day":e.attemptsDay,"failures-day":e.failuresDay,"attempts-minute":e.attemptsMinute,"failures-minute":e.failuresMinute},null,8,[`attempts-day`,`failures-day`,`attempts-minute`,`failures-minute`]),e.healthState===`closed`?Ts(``,!0):(R(),B(N(eC),{key:0,as:`span`,variant:x(e.healthState),class:`font-normal`,title:e.healthState===`open`?`discovery is backing off after repeated failures`:`a discovery probe is deciding whether to recover`},{default:P(()=>[U(k(S(e)),1)]),_:2},1032,[`variant`,`title`])),w(e)?.avgTtfbMs===void 0?Ts(``,!0):(R(),B(N(eC),{key:1,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:T(w(e))},{default:P(()=>[U(` streaming ttfb `+k(N(dC)(w(e).avgTtfbMs)),1)]),_:2},1032,[`title`])),ee(e)?.avgDurationMs===void 0?Ts(``,!0):(R(),B(N(eC),{key:2,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:ne(ee(e))},{default:P(()=>[U(` non-streaming avg `+k(N(dC)(ee(e).avgDurationMs)),1)]),_:2},1032,[`title`])),re(e)?(R(),B(N(eC),{key:3,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:E(re(e))},{default:P(()=>[U(` estimated `+k(re(e).requests),1)]),_:2},1032,[`title`])):Ts(``,!0),ie(e)?(R(),B(N(eC),{key:4,as:`span`,variant:`destructive`,class:`font-normal tabular-nums`,title:ae(ie(e))},{default:P(()=>[U(` unbilled `+k(ie(e).requests),1)]),_:2},1032,[`title`])):Ts(``,!0),e.lastErr?(R(),B(r,{key:5,icon:N(h_),class:`size-3.5 shrink-0 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):Ts(``,!0),V(`span`,tw,k(N(vC)(e.discoveryEnabled,e.lastRefresh)),1)])]),_:2},1024),H(N(FC),null,{default:P(()=>[V(`dl`,nw,[V(`div`,null,[t[7]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Base URL`,-1),V(`dd`,rw,k(e.baseUrl),1)]),V(`div`,null,[t[8]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Last refresh`,-1),V(`dd`,null,k(N(yC)(e.discoveryEnabled,e.lastRefresh)),1)]),e.healthState===`closed`?Ts(``,!0):(R(),z(`div`,iw,[t[9]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Discovery health`,-1),V(`dd`,{class:O(C(e.healthState))},k(S(e)),3)])),e.lastErr?(R(),z(`div`,aw,[t[10]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Last error`,-1),V(`dd`,ow,k(e.lastErr),1)])):Ts(``,!0)]),h(e).length?(R(),z(`div`,sw,[(R(!0),z(L,null,ma(h(e),t=>(R(),z(`span`,{key:t,class:`inline-flex items-center gap-1`},[H(SC,{id:N(rC)(e.name,t),"context-tokens":b(e,t).contextTokens,"input-per-m-tok-usd":b(e,t).inputPerMTokUsd,"output-per-m-tok-usd":b(e,t).outputPerMTokUsd},null,8,[`id`,`context-tokens`,`input-per-m-tok-usd`,`output-per-m-tok-usd`]),b(e,t).contextTokens===void 0?Ts(``,!0):(R(),z(`span`,cw,k(N(cC)(b(e,t).contextTokens)),1)),v(e,t)?(R(),B(MC,{key:1,"attempts-day":_(e,t).attemptsDay,"failures-day":_(e,t).failuresDay},null,8,[`attempts-day`,`failures-day`])):Ts(``,!0)]))),128))])):(R(),z(`p`,lw,`no models known yet`))]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):(R(),z(`p`,XC,`none`))]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[11]||=[U(`Model aliases`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[12]||=[U(`Operator-defined alias → target model mappings.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:oe,data:d.value,"empty-message":se.value},null,8,[`data`,`empty-message`])]),_:1})]),_:1}),n.value?.version?(R(),z(`p`,uw,`Version: `+k(n.value.version),1)):Ts(``,!0)])}}}),pw=[`title`],mw={"aria-hidden":`true`},hw={class:`sr-only`},gw=F({__name:`CompactNumber`,props:{value:{}},setup(e){let t=e,n=W(()=>oC(t.value)),r=W(()=>aC(t.value));return(e,t)=>(R(),z(`span`,{title:r.value},[V(`span`,mw,k(n.value),1),V(`span`,hw,k(r.value),1)],8,pw))}});function _w(e,t,n){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>G(gw,{value:n(e.original)})}}var vw=`not observed yet — no traffic and probes disabled or not yet run`;function yw(e){let t=mC(e.lastCheck);return t?`unhealthy (${t})`:`unhealthy`}function bw(e){let t=e.consecutiveFailures===1?`failure`:`failures`,n=e.source?` via ${e.source}`:``,r=`${e.consecutiveFailures} consecutive ${t}${n}`;return e.lastError?`${r}: ${e.lastError}`:r}function xw(e){let t=mC(e.lastCheck);return t?e.source?`${t} via ${e.source}`:t:e.source?`via ${e.source}`:``}function Sw(e){if(e.consecutiveFailures<=0&&!e.lastError)return vw;let t=e.consecutiveFailures===1?`failure`:`failures`,n=e.source?` via ${e.source}`:``,r=`${e.consecutiveFailures} ${t} so far${n}`;return e.lastError?`${r}: ${e.lastError}`:r}function Cw(e){if(e.state===`unhealthy`)return G(eC,{as:`span`,variant:`destructive`,class:`font-normal`,title:bw(e)},()=>yw(e));if(e.state===`healthy`){let t=e.latencyMs===void 0?``:` · ${dC(e.latencyMs)}`;return G(`span`,{class:`text-muted-foreground`,title:xw(e)},`healthy${t}`)}return G(eC,{as:`span`,variant:`outline`,class:`font-normal`,title:Sw(e)},()=>`unknown`)}function ww(){return[{id:`name`,header:`Name`,accessorFn:e=>e.name,cell:({row:e})=>G(`span`,{class:`font-medium`},e.original.name)},{id:`url`,header:`URL`,accessorFn:e=>e.url,cell:({row:e})=>G(`span`,{class:`block max-w-xs truncate text-muted-foreground`,title:e.original.url},e.original.url)},{id:`health`,header:`Health`,enableSorting:!1,accessorFn:e=>e.health.state,cell:({row:e})=>Cw(e.original.health)},{id:`access`,header:`Access`,enableSorting:!1,accessorFn:e=>(e.access??[]).join(`, `),cell:({row:e})=>{let t=e.original.access;return t?.length?G(`div`,{class:`flex flex-wrap gap-1.5`},t.map(e=>G(eC,{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},()=>e))):G(`span`,{class:`text-muted-foreground`},`All groups`)}},_w(`reqMin`,`req/min`,e=>e.counters.requestsPerMinute),_w(`reqDay`,`req/day`,e=>e.counters.requestsPerDay),_w(`reqMonth`,`req/month`,e=>e.counters.requestsPerMonth)]}var Tw={class:`flex flex-col gap-6`},Ew=F({__name:`TargetsView`,setup(e){let t=sx(),n=W(()=>t.targets),{query:r,normalized:i,hasQuery:a}=RC();function o(e){return e.name.toLowerCase().includes(i.value)}let s=W(()=>{let e=n.value?.mcpServers??[];return a.value?e.filter(o):e}),c=W(()=>{let e=n.value?.agents??[];return a.value?e.filter(o):e});function l(e,t){return e?a.value&&t===0?`no targets match "${r.value}"`:`none`:`none configured`}let u=W(()=>l(n.value?.mcpServers.length??0,s.value.length)),d=W(()=>l(n.value?.agents.length??0,c.value.length)),f=ww();return(e,t)=>(R(),z(`div`,Tw,[H(NC,{modelValue:N(r),"onUpdate:modelValue":t[0]||=e=>j(r)?r.value=e:null,placeholder:`Filter MCP servers or agents`,class:`max-w-sm`},null,8,[`modelValue`]),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[1]||=[U(`MCP servers`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[2]||=[U(`Configured MCP proxy targets, the groups allowed to reach them, and their request counters.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:N(f),data:s.value,"empty-message":u.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[3]||=[U(`Agents`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[4]||=[U(`Configured A2A agent proxy targets, the groups allowed to reach them, and their request counters.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H($S,{columns:N(f),data:c.value,"empty-message":d.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1})]))}}),Dw=F({__name:`Tabs`,props:{defaultValue:{},orientation:{},dir:{},activationMode:{},modelValue:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=qy(Cy(n,`class`),r);return(e,t)=>(R(),B(N(Rb),ks({"data-slot":`tabs`,"data-orientation":N(i).orientation||`horizontal`},N(i),{class:N(Yv)(`gap-2 group/tabs flex data-horizontal:flex-col`,n.class)}),{default:P(t=>[I(e.$slots,`default`,xe(Ss(t)))]),_:3},16,[`data-orientation`,`class`]))}}),Ow=F({__name:`TabsContent`,props:{value:{},forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Cy(t,`class`);return(e,r)=>(R(),B(N(Vb),ks({"data-slot":`tabs-content`,class:N(Yv)(`text-sm flex-1 outline-none`,t.class)},N(n)),{default:P(()=>[I(e.$slots,`default`)]),_:3},16,[`class`]))}}),kw=F({__name:`TabsList`,props:{loop:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]},variant:{default:`default`}},setup(e){let t=e,n=Cy(t,`class`,`variant`);return(r,i)=>(R(),B(N(Hb),ks({"data-slot":`tabs-list`,"data-variant":e.variant},N(n),{class:N(Yv)(N(jw)({variant:e.variant}),t.class)}),{default:P(()=>[I(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),Aw=F({__name:`TabsTrigger`,props:{value:{},disabled:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Ky(Cy(t,`class`));return(e,r)=>(R(),B(N(Ub),ks({"data-slot":`tabs-trigger`,class:N(Yv)(`gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg:not([class*=size-])]:size-4 has-data-[icon=inline-end]:pr-1 has-data-[icon=inline-start]:pl-1 relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center whitespace-nowrap text-foreground/60 transition-all group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 dark:text-muted-foreground dark:hover:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0`,`group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent`,`data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground`,`after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100`,t.class)},N(n)),{default:P(()=>[I(e.$slots,`default`)]),_:3},16,[`class`]))}}),jw=C_(`rounded-lg p-0.75 group-data-horizontal/tabs:h-8 data-[variant=line]:rounded-none group/tabs-list inline-flex w-fit items-center justify-center text-muted-foreground group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col`,{variants:{variant:{default:`bg-muted`,line:`gap-1 bg-transparent`}},defaultVariants:{variant:`default`}});function Mw(e,t,n,r=String,i=!0){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>{if(e.original.storeDown)return`?`;let t=n(e.original);return i?G(gw,{value:t}):r(t)}}}function Nw(e,t,n){return[{id:`id`,header:e,accessorFn:e=>e.id,cell:({row:e})=>G(`span`,{class:`font-medium`},e.original.id)},{id:`secondary`,header:t,accessorFn:n,cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},n(e.original))},{id:`limits`,header:`Limits`,accessorFn:e=>bC(e.limits),cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},bC(e.original.limits))},Mw(`reqMin`,`req/min`,e=>e.requestsPerMinute),Mw(`reqDay`,`req/day`,e=>e.requestsPerDay),Mw(`tokInDay`,`tokIn/day`,e=>e.tokensInPerDay),Mw(`tokOutDay`,`tokOut/day`,e=>e.tokensOutPerDay),Mw(`tokInMonth`,`tokIn/month`,e=>e.tokensInPerMonth),Mw(`tokOutMonth`,`tokOut/month`,e=>e.tokensOutPerMonth),Mw(`costDay`,`cost/day`,e=>e.costPerDayMicroUsd,iC,!1),Mw(`costMonth`,`cost/month`,e=>e.costPerMonthMicroUsd,iC,!1)]}var Pw=F({__name:`UsageTable`,props:{idLabel:{},entries:{},secondaryColumnLabel:{},secondaryValue:{type:Function},emptyMessage:{}},setup(e){let t=e,n=W(()=>Nw(t.idLabel,t.secondaryColumnLabel,t.secondaryValue));return(t,r)=>(R(),B($S,{columns:n.value,data:e.entries,"empty-message":e.emptyMessage,"row-class":e=>e.storeDown?`bg-destructive/10`:void 0},null,8,[`columns`,`data`,`empty-message`,`row-class`]))}});function Fw(e,t){return e.id.toLowerCase().includes(t)}function Iw(e,t){return e.id.toLowerCase().includes(t)}function Lw(e,t){return t.filter(t=>t.groupName===e.id)}function Rw(e,t,n){return Lw(e,t).filter(e=>Fw(e,n))}function zw(e,t,n){return Iw(e,n)||Rw(e,t,n).length>0}var Bw={class:`flex flex-col gap-6`},Vw={class:`text-lg font-semibold tabular-nums`},Hw={class:`text-lg font-semibold tabular-nums`},Uw={class:`text-lg font-semibold tabular-nums`},Ww={class:`text-lg font-semibold tabular-nums`},Gw={key:0,class:`mb-3 flex flex-wrap gap-x-4 gap-y-1 text-xs font-medium text-muted-foreground`},Kw={class:`flex flex-1 flex-wrap items-center gap-x-4 gap-y-1 pr-2 text-left`},qw={class:`font-medium`},Jw={class:`text-xs text-muted-foreground tabular-nums`},Yw={class:`text-xs text-muted-foreground tabular-nums`},Xw={class:`text-xs text-muted-foreground tabular-nums`},Zw={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},Qw={key:0,class:`flex flex-wrap gap-1.5`},$w={key:1,class:`text-muted-foreground`},eT={key:0,class:`flex flex-wrap gap-1.5`},tT={key:1,class:`text-muted-foreground`},nT={key:0,class:`flex flex-wrap gap-1.5`},rT={key:1,class:`text-muted-foreground`},iT={key:0,class:`flex flex-wrap gap-1.5`},aT={key:1,class:`text-muted-foreground`},oT={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},sT={class:`tabular-nums`},cT={class:`tabular-nums`},lT={class:`tabular-nums`},uT={class:`tabular-nums`},dT={class:`tabular-nums`},fT={class:`tabular-nums`},pT={key:2,class:`py-6 text-center text-sm text-muted-foreground`},mT=`Glob pattern — matches like a shell wildcard (*, ?, [...])`,hT=F({__name:`UsageView`,setup(e){let t=sx(),n=W(()=>t.usage),r=W(()=>{let e={};for(let n of t.overview?.groups??[])e[n.name]=n.memberCount;return e});function i(e){return e.groupName??``}function a(e){let t=r.value[e.id];return t===void 0?``:String(t)}let{query:o,normalized:s,hasQuery:c}=RC(),l=W(()=>{let e=n.value?.groups??[];if(!c.value)return e;let t=n.value?.users??[];return e.filter(e=>zw(e,t,s.value))}),u=W(()=>c.value?l.value.filter(e=>!Iw(e,s.value)).map(e=>e.id):[]);function d(e){let t=n.value?.users??[];return!c.value||Iw(e,s.value)?Lw(e,t):Rw(e,t,s.value)}let f=W(()=>n.value?.groups.length?c.value?`no groups match "${o.value}"`:`none`:`none configured`),p=W(()=>{let e=n.value?.users??[];if(!c.value)return e;let t=n.value?.groups??[],r=new Set(t.filter(e=>Iw(e,s.value)).map(e=>e.id));return e.filter(e=>Fw(e,s.value)||e.groupName!==void 0&&r.has(e.groupName))}),m=W(()=>n.value?.users.length?c.value?`no users match "${o.value}"`:`none`:`none configured`),h=Nw(`Name`,`Members`,a),g=M([]),_=BS({get data(){return l.value},get columns(){return h},getCoreRowModel:jS(),getSortedRowModel:MS(),onSortingChange:e=>QS(e,g),state:{get sorting(){return g.value}}}),v=W(()=>_.getRowModel().rows),y=new Set([`id`,`secondary`,`reqDay`,`costDay`]),b=W(()=>_.getHeaderGroups()[0].headers.filter(e=>y.has(e.column.id))),x=Zt({manuallyExpanded:new Set,manuallyCollapsed:new Set}),S=W(()=>zC(x,c.value,u.value));function C(e){BC(x,e,S.value.has(e))}let w=W({get:()=>Array.from(S.value),set:e=>{let t=new Set(e);for(let e of S.value)t.has(e)||C(e);for(let e of t)S.value.has(e)||C(e)}});Er(o,e=>{e.trim()===``&&VC(x)});function ee(e){return/[*?[]/.test(e)}return(e,t)=>(R(),z(`div`,Bw,[H(NC,{modelValue:N(o),"onUpdate:modelValue":t[0]||=e=>j(o)?o.value=e:null,placeholder:`Filter users or groups`,class:`max-w-sm`},null,8,[`modelValue`]),n.value?(R(),B(N(qb),{key:0},{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[2]||=[U(`Total`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[3]||=[U(`Usage summed across every user and group combined.`,-1)]]),_:1})]),_:1}),H(N(Jb),{class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-4`},{default:P(()=>[V(`div`,null,[t[4]||=V(`p`,{class:`text-muted-foreground`},`Requests/day`,-1),V(`p`,Vw,[H(gw,{value:n.value.total.requestsPerDay},null,8,[`value`])])]),V(`div`,null,[t[5]||=V(`p`,{class:`text-muted-foreground`},`Tokens in/day`,-1),V(`p`,Hw,[H(gw,{value:n.value.total.tokensInPerDay},null,8,[`value`])])]),V(`div`,null,[t[6]||=V(`p`,{class:`text-muted-foreground`},`Tokens out/day`,-1),V(`p`,Uw,[H(gw,{value:n.value.total.tokensOutPerDay},null,8,[`value`])])]),V(`div`,null,[t[7]||=V(`p`,{class:`text-muted-foreground`},`Cost/day`,-1),V(`p`,Ww,k(N(iC)(n.value.total.costPerDayMicroUsd)),1)])]),_:1})]),_:1})):Ts(``,!0),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[8]||=[U(`Groups`,-1)]]),_:1}),H(N(Yb),null,{default:P(()=>[...t[9]||=[U(`Expand a group to see its member users' own usage.`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[v.value.length?(R(),z(`div`,Gw,[(R(!0),z(L,null,ma(b.value,e=>(R(),B(HS,{key:e.id,header:e},null,8,[`header`]))),128))])):Ts(``,!0),v.value.length?(R(),B(N(PC),{key:1,modelValue:w.value,"onUpdate:modelValue":t[1]||=e=>w.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:P(()=>[(R(!0),z(L,null,ma(v.value,e=>(R(),B(N(IC),{key:e.original.id,value:e.original.id},{default:P(()=>[H(N(LC),null,{default:P(()=>[V(`span`,Kw,[V(`span`,qw,k(e.original.id),1),V(`span`,Jw,k(a(e.original)||`0`)+` members`,1),V(`span`,Yw,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(gw,{key:1,value:e.original.requestsPerDay},null,8,[`value`])),t[10]||=U(` req/day `,-1)]),V(`span`,Xw,k(e.original.storeDown?`?`:N(iC)(e.original.costPerDayMicroUsd))+`/day `,1)])]),_:2},1024),H(N(FC),null,{default:P(()=>[V(`dl`,Zw,[V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:mT},`Providers`),V(`dd`,null,[e.original.providers?.length?(R(),z(`div`,Qw,[(R(!0),z(L,null,ma(e.original.providers,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,$w,`All providers`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:mT},`Models`),V(`dd`,null,[e.original.models?.length?(R(),z(`div`,eT,[(R(!0),z(L,null,ma(e.original.models,e=>(R(),z(L,{key:e},[ee(e)?(R(),B(N(eC),{key:1,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024)):(R(),B(SC,{key:0,id:e},null,8,[`id`]))],64))),128))])):(R(),z(`span`,tT,`All models`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:mT},`MCP servers`),V(`dd`,null,[e.original.mcpServers?.length?(R(),z(`div`,nT,[(R(!0),z(L,null,ma(e.original.mcpServers,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,rT,`All MCP servers`))])]),V(`div`,null,[V(`dt`,{class:`text-xs text-muted-foreground`,title:mT},`Agents`),V(`dd`,null,[e.original.agents?.length?(R(),z(`div`,iT,[(R(!0),z(L,null,ma(e.original.agents,e=>(R(),B(N(eC),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:P(()=>[U(k(e),1)]),_:2},1024))),128))])):(R(),z(`span`,aT,`All agents`))])])]),V(`dl`,oT,[V(`div`,null,[t[11]||=V(`dt`,{class:`text-xs text-muted-foreground`},`Limits`,-1),V(`dd`,null,k(N(bC)(e.original.limits)),1)]),V(`div`,null,[t[12]||=V(`dt`,{class:`text-xs text-muted-foreground`},`req/min`,-1),V(`dd`,sT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(gw,{key:1,value:e.original.requestsPerMinute},null,8,[`value`]))])]),V(`div`,null,[t[13]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/day`,-1),V(`dd`,cT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(gw,{key:1,value:e.original.tokensInPerDay},null,8,[`value`]))])]),V(`div`,null,[t[14]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/day`,-1),V(`dd`,lT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(gw,{key:1,value:e.original.tokensOutPerDay},null,8,[`value`]))])]),V(`div`,null,[t[15]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/month`,-1),V(`dd`,uT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(gw,{key:1,value:e.original.tokensInPerMonth},null,8,[`value`]))])]),V(`div`,null,[t[16]||=V(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/month`,-1),V(`dd`,dT,[e.original.storeDown?(R(),z(L,{key:0},[U(`?`)],64)):(R(),B(gw,{key:1,value:e.original.tokensOutPerMonth},null,8,[`value`]))])]),V(`div`,null,[t[17]||=V(`dt`,{class:`text-xs text-muted-foreground`},`cost/month`,-1),V(`dd`,fT,k(e.original.storeDown?`?`:N(iC)(e.original.costPerMonthMicroUsd)),1)])]),t[18]||=V(`p`,{class:`mb-1.5 text-xs font-medium text-muted-foreground`},`Members`,-1),H(Pw,{"id-label":`Name`,"secondary-column-label":`Group`,entries:d(e.original),"secondary-value":i},null,8,[`entries`])]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):(R(),z(`p`,pT,k(f.value),1))]),_:1})]),_:1}),H(N(qb),null,{default:P(()=>[H(N(Xb),null,{default:P(()=>[H(N(Zb),null,{default:P(()=>[...t[19]||=[U(`Users`,-1)]]),_:1})]),_:1}),H(N(Jb),null,{default:P(()=>[H(Pw,{"id-label":`Name`,"secondary-column-label":`Group`,entries:p.value,"secondary-value":i,"empty-message":m.value},null,8,[`entries`,`empty-message`])]),_:1})]),_:1})]))}});function gT(e,t,n){let r=e.startsWith(`#`)?e.slice(1):e;return t.includes(r)?r:n}function _T(e){return`#${e}`}function vT({validTabs:e,defaultTab:t}){let n=typeof window<`u`,r=M(n?gT(window.location.hash,e,t):t);Er(r,e=>{if(!n)return;let t=_T(e);window.location.hash!==t&&window.history.replaceState(null,``,t)});function i(){r.value=gT(window.location.hash,e,t)}return n&&(Zi(()=>window.addEventListener(`hashchange`,i)),ta(()=>window.removeEventListener(`hashchange`,i))),r}var yT=(function(){let e=typeof document<`u`&&document.createElement(`link`).relList;return e&&e.supports&&e.supports(`modulepreload`)?`modulepreload`:`preload`})(),bT=function(e){return`/admin/`+e},xT={},ST=function(e,t,n){let r=Promise.resolve();if(t&&t.length>0){let e=document.getElementsByTagName(`link`),i=document.querySelector(`meta[property=csp-nonce]`),a=i?.nonce||i?.getAttribute(`nonce`);function o(e){return Promise.all(e.map(e=>Promise.resolve(e).then(e=>({status:`fulfilled`,value:e}),e=>({status:`rejected`,reason:e}))))}function s(e){return import.meta.resolve?import.meta.resolve(e):new URL(e,import.meta.url).href}r=o(t.map(t=>{if(t=bT(t,n),t=s(t),t in xT)return;xT[t]=!0;let r=t.endsWith(`.css`);for(let n=e.length-1;n>=0;n--){let i=e[n];if(i.href===t&&(!r||i.rel===`stylesheet`))return}let i=document.createElement(`link`);if(i.rel=r?`stylesheet`:yT,r||(i.as=`script`),i.crossOrigin=``,i.href=t,a&&i.setAttribute(`nonce`,a),document.head.appendChild(i),r)return new Promise((e,n)=>{i.addEventListener(`load`,e),i.addEventListener(`error`,()=>n(Error(`Unable to preload CSS for ${t}`)))})}))}function i(e){let t=new Event(`vite:preloadError`,{cancelable:!0});if(t.payload=e,window.dispatchEvent(t),!t.defaultPrevented)throw e}return r.then(t=>{for(let e of t||[])e.status===`rejected`&&i(e.reason);return e().catch(i)})},CT={class:`flex w-full flex-col gap-6 px-4 py-8 sm:px-6 lg:px-8`},wT={class:`flex flex-col gap-1`},TT={class:`flex items-center justify-between gap-2`},ET={class:`flex items-center gap-1.5 text-sm text-muted-foreground`},DT=`https://github.com/lukaszraczylo/traefik-llmgateway`,OT=mu(F({__name:`App`,setup(e){let t=Li(()=>ST(()=>import(`./ChartsView-DQ1IeOcb.js`),[])),n=rx(),r=sx(),i=vT({validTabs:[`providers`,`usage`,`charts`,`targets`],defaultTab:`providers`}),a=W(()=>r.error?`refresh failed: ${r.error}`:r.lastUpdated?`last updated ${r.lastUpdated.toLocaleTimeString()}`:`loading...`);return Zi(()=>{r.startPolling()}),(e,o)=>{let s=ca(`FontAwesomeIcon`);return R(),z(`div`,CT,[V(`header`,wT,[V(`div`,TT,[o[1]||=V(`h1`,{class:`text-xl font-semibold tracking-tight`},`LLM Gateway — Admin`,-1),H(N(Wb),{as:`a`,href:DT,target:`_blank`,rel:`noopener noreferrer`,variant:`ghost`,size:`icon`,"aria-label":`GitHub repository`,class:`text-muted-foreground hover:text-foreground`},{default:P(()=>[H(s,{icon:N(n_),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`])]),_:1})]),V(`p`,ET,[N(r).error?(R(),B(s,{key:0,icon:N(l_),class:`size-3.5 text-destructive`},null,8,[`icon`])):Ts(``,!0),V(`span`,{class:O(N(r).error?`text-destructive`:void 0)},k(a.value),3)])]),N(n).isAuthenticated?(R(),B(N(Dw),{key:1,modelValue:N(i),"onUpdate:modelValue":o[0]||=e=>j(i)?i.value=e:null},{default:P(()=>[H(N(kw),null,{default:P(()=>[H(N(Aw),{value:`providers`},{default:P(()=>[...o[2]||=[U(`Providers`,-1)]]),_:1}),H(N(Aw),{value:`usage`},{default:P(()=>[...o[3]||=[U(`Usage`,-1)]]),_:1}),H(N(Aw),{value:`charts`},{default:P(()=>[...o[4]||=[U(`Charts`,-1)]]),_:1}),H(N(Aw),{value:`targets`},{default:P(()=>[...o[5]||=[U(`MCP & Agents`,-1)]]),_:1})]),_:1}),H(N(Ow),{value:`providers`},{default:P(()=>[H(fw)]),_:1}),H(N(Ow),{value:`usage`},{default:P(()=>[H(hT)]),_:1}),H(N(Ow),{value:`charts`},{default:P(()=>[H(N(t))]),_:1}),H(N(Ow),{value:`targets`},{default:P(()=>[H(Ew)]),_:1})]),_:1},8,[`modelValue`])):(R(),B(gx,{key:0}))])}}}));OT.use(Vg()),OT.component(`FontAwesomeIcon`,Cg),OT.mount(`#app`);export{Vr as $,ky as A,Zt as At,Ty as B,ge as Bt,qy as C,wr as Ct,Vy as D,on as Dt,Uy as E,Fe as Et,by as F,yn as Ft,Yv as G,sy as H,fy as I,mn as It,s_ as J,u_ as K,gy as L,N as Lt,Fy as M,en as Mt,Iy as N,un as Nt,Ny as O,j as Ot,dy as P,A as Pt,L as Q,Cy as R,O as Rt,Yy as S,Cr as St,Gy as T,nc as Tt,oy as U,cy as V,k as Vt,ay as W,Cg as X,t_ as Y,iu as Z,Jb as _,ma as _t,Dw as a,U as at,nb as b,ic as bt,xC as c,Ss as ct,sx as d,ks as dt,W as et,ix as f,Qn as ft,Xb as g,R as gt,Zb as h,ta as ht,kw as i,z as it,Ay as j,M as jt,Oy as k,Ie as kt,oC as l,G as lt,rx as m,Zi as mt,Fw as n,B as nt,RC as o,H as ot,ax as p,ea as pt,m_ as q,Aw as r,Ts as rt,NC as s,F as st,zw as t,V as tt,aC as u,Pa as ut,qb as v,I as vt,Ky as w,P as wt,$y as x,Er as xt,wb as y,ua as yt,wy as z,xe as zt};", ), }, } diff --git a/webui/src/lib/format.spec.ts b/webui/src/lib/format.spec.ts index ffc4b13..160ffd5 100644 --- a/webui/src/lib/format.spec.ts +++ b/webui/src/lib/format.spec.ts @@ -1,8 +1,6 @@ import { describe, expect, it } from 'vitest' -import { formatCompactCount, formatContextWindow, formatElapsedAgo, formatLatencyMs, formatModelCostHover, formatUntil, refreshDetailLabel, refreshLabel } from './format' - -const ZERO_TIME = '0001-01-01T00:00:00Z' +import { formatCompactCount, formatContextWindow, formatElapsedAgo, formatLatencyMs, formatModelCostHover, formatUntil, refreshDetailLabel, refreshLabel, ZERO_TIME } from './format' describe('refreshLabel', () => { it('reads "discovery off" when discovery is disabled, regardless of lastRefresh', () => { diff --git a/webui/src/lib/format.ts b/webui/src/lib/format.ts index c2fca51..23efce6 100644 --- a/webui/src/lib/format.ts +++ b/webui/src/lib/format.ts @@ -1,6 +1,7 @@ import type { HistoryWindow, LimitsConfig } from '@/types/api' -const ZERO_TIME = '0001-01-01T00:00:00Z' +/** ZERO_TIME is Go's zero time.Time value in its default JSON (RFC 3339) encoding — the unset-timestamp sentinel every admin API "never happened yet" field marshals as, and every formatter/test below treats as absent. */ +export const ZERO_TIME = '0001-01-01T00:00:00Z' /** * routableModelId joins a provider name and one of its own model ids into