traefik-llmgateway/admin_assets_gen.go

// Code generated by webui/generate.mjs; DO NOT EDIT.
//
// Source: webui/dist/ (vite build output), digest bddab0473d8a86fb.
// Regenerate via `make admin-ui` after any webui/ source change.
//
// Every asset body below is base64-encoded and decoded once at package-var
// initialization (encoding/base64, stdlib — Yaegi-safe). See generate.mjs's
// own header comment for why base64 was chosen over a raw-string literal.

package traefikllmgateway

import "encoding/base64"

// adminAsset is one baked static file: its HTTP Content-Type and decoded body.
type adminAsset struct {
	contentType string
	body        []byte
}

// decodeAdminAsset base64-decodes one embedded asset body. Every literal
// passed to it below was produced by this exact encoding (base64.StdEncoding)
// in webui/generate.mjs, so a decode error here can only mean this generated
// file is corrupt — a build-time invariant violation, not a reachable runtime
// condition — so it panics rather than threading an error return through
// every var initializer below.
func decodeAdminAsset(encoded string) []byte {
	data, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		panic("admin_assets_gen.go: corrupt embedded asset: " + err.Error())
	}
	return data
}

// 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+CiAgICA8c2NyaXB0IHR5cGU9Im1vZHVsZSIgY3Jvc3NvcmlnaW4gc3JjPSIvYWRtaW4vYXNzZXRzL2luZGV4LWR5d1M4T3BULmpzIj48L3NjcmlwdD4KICAgIDxsaW5rIHJlbD0ibW9kdWxlcHJlbG9hZCIgY3Jvc3NvcmlnaW4gaHJlZj0iL2FkbWluL2Fzc2V0cy9Ta2VsZXRvbi1CMHppQjZPZC5qcyI+CiAgICA8bGluayByZWw9Im1vZHVsZXByZWxvYWQiIGNyb3Nzb3JpZ2luIGhyZWY9Ii9hZG1pbi9hc3NldHMvdXNlSWQtQjlkSnVtb0kuanMiPgogICAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBjcm9zc29yaWdpbiBocmVmPSIvYWRtaW4vYXNzZXRzL2luZGV4LUJENWJCaXNPLmNzcyI+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPGRpdiBpZD0iYXBwIj48L2Rpdj4KICA8L2JvZHk+CjwvaHRtbD4K",
)

// adminAssets maps each hashed filename under /admin/assets/ (admin.go's
// serveAdminAsset) to its content.
var adminAssets = map[string]adminAsset{
	"ClampedRangeNotice-D2walnXf.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"aW1wb3J0e0ZyIGFzIGUsU2kgYXMgdCxfbiBhcyBuLGdpIGFzIHIsaG4gYXMgaSxpbiBhcyBhLG1uIGFzIG8sbnIgYXMgcyxvbiBhcyBjLHMgYXMgbCxzbiBhcyB1fWZyb20iLi9Ta2VsZXRvbi1CMHppQjZPZC5qcyI7aW1wb3J0e2cgYXMgZCxoIGFzIGZ9ZnJvbSIuL2luZGV4LWR5d1M4T3BULmpzIjt2YXIgcD1uKHtfX25hbWU6YENsYW1wZWRSYW5nZU5vdGljZWAscHJvcHM6e3dpbmRvdzp7fSxzcGFuOnt9fSxzZXR1cChuKXtsZXQgcD1uLG09YSgoKT0+bChwLndpbmRvdyxwLnNwYW4pKTtyZXR1cm4obixhKT0+bS52YWx1ZT8ocygpLGMocihkKSx7a2V5OjAsdmFyaWFudDpgd2FybmB9LHtkZWZhdWx0OmUoKCk9PltpKHIoZiksbnVsbCx7ZGVmYXVsdDplKCgpPT5bbyh0KG0udmFsdWUpLDEpXSksXzoxfSldKSxfOjF9KSk6dShgYCwhMCl9fSk7ZXhwb3J0e3AgYXMgdH07",
		),
	},
	"CompactNumber-pr8cJ4cv.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"aW1wb3J0e1NpIGFzIGUsX24gYXMgdCxhbiBhcyBuLGNuIGFzIHIsaW4gYXMgaSxuciBhcyBhfWZyb20iLi9Ta2VsZXRvbi1CMHppQjZPZC5qcyI7aW1wb3J0e2MgYXMgbyxpIGFzIHN9ZnJvbSIuL2JhZGdlLURVaUJURHlBLmpzIjt2YXIgYz1bYHRpdGxlYF0sbD17ImFyaWEtaGlkZGVuIjpgdHJ1ZWB9LHU9e2NsYXNzOmBzci1vbmx5YH0sZD10KHtfX25hbWU6YENvbXBhY3ROdW1iZXJgLHByb3BzOnt2YWx1ZTp7fX0sc2V0dXAodCl7bGV0IGQ9dCxmPWkoKCk9PnMoZC52YWx1ZSkpLHA9aSgoKT0+byhkLnZhbHVlKSk7cmV0dXJuKHQsaSk9PihhKCkscihgc3BhbmAse3RpdGxlOnAudmFsdWV9LFtuKGBzcGFuYCxsLGUoZi52YWx1ZSksMSksbihgc3BhbmAsdSxlKHAudmFsdWUpLDEpXSw4LGMpKX19KTtleHBvcnR7ZCBhcyB0fTs=",
		),
	},
	"ConfigPage-7IYcafPw.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{C as e,E as t,Er as n,Fr as r,Ft as i,Jt as a,Lr as o,S as s,Si as c,T as l,X as u,Xn as d,_ as f,_n as p,_t as m,an as h,b as g,cn as _,cr as v,er as y,g as b,gi as x,hn as S,ii as C,in as w,it as T,mn as E,mt as D,n as O,nr as k,oi as A,on as j,sn as M,t as N,ur as ee,w as P,x as F,y as te,yi as ne}from"./Skeleton-B0ziB6Od.js";import{n as re,r as ie,t as ae}from"./tabs-YlhnHpK-.js";import{a as I,c as oe,g as L,h as R,i as z,m as se,n as B,o as V,r as H,s as U}from"./index-dywS8OpT.js";import{t as ce}from"./clipboard-B73fZ0c1.js";import{t as le}from"./ErrorState-ym6eSlj2.js";import{t as ue}from"./consumers-CQtEJ9K7.js";var de={class:`flex flex-col gap-1.5`},fe={class:`flex items-center justify-between gap-2`},pe={key:0,class:`text-xs font-medium text-muted-foreground`},W=p({__name:`SnippetBlock`,props:{text:{},label:{}},setup(e){let i=e,a=n(`pre`),o=A(`idle`),s,l=f();async function d(){o.value=await ce(i.text,a.value??void 0),o.value===`failed`&&l.push({kind:`error`,message:`Could not copy the snippet.`}),clearTimeout(s),s=setTimeout(()=>{o.value=`idle`},1500)}let p={idle:`Copy`,copied:`Copied`,selected:`Selected — press ⌘/Ctrl+C`,failed:`Copy failed`};return y(()=>clearTimeout(s)),(n,i)=>{let a=ee(`FontAwesomeIcon`);return k(),_(`div`,de,[h(`div`,fe,[e.label?(k(),_(`span`,pe,c(e.label),1)):M(``,!0),S(x(t),{type:`button`,variant:`outline`,size:`sm`,class:`ml-auto`,onClick:d},{default:r(()=>[S(a,{icon:o.value===`idle`?x(T):o.value===`failed`?x(D):x(u),class:ne([`size-3.5`,o.value===`failed`?`text-destructive`:void 0]),"aria-hidden":`true`},null,8,[`icon`,`class`]),E(` `+c(p[o.value]),1)]),_:1})]),h(`pre`,{ref:`pre`,class:`overflow-x-auto rounded-md border bg-muted p-3 font-mono text-xs select-text whitespace-pre`},c(e.text),513)])}}}),me=`  `,he=/^[A-Za-z_][A-Za-z0-9._-]*$/,ge=new Set([`true`,`false`,`yes`,`no`,`y`,`n`,`on`,`off`,`null`,`nil`,`nan`,`inf`]);function _e(e){return!he.test(e)||ge.has(e.toLowerCase())}function ve(e){return _e(e)}var ye=RegExp(`[\\u007f\\u0080-\\u009f\u2028\u2029]`,`g`);function be(e){return e.replace(ye,e=>{let t=e.codePointAt(0);return t<=255?`\\x${t.toString(16).padStart(2,`0`)}`:`\\u${t.toString(16).padStart(4,`0`)}`})}function G(e){return ve(e)?be(JSON.stringify(e)):e}function K(e){return e===null?`null`:typeof e==`boolean`||typeof e==`number`?String(e):_e(e)?be(JSON.stringify(e)):e}function xe(e){return e.length===0?`[]`:`[${e.map(e=>K(e)).join(`, `)}]`}function Se(e){return e.length===0?`{}`:`{ ${e.map(([e,t])=>`${G(e)}: ${K(t)}`).join(`, `)} }`}function Ce(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function q(e){return e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`}function we(e,t){let n=me.repeat(t),r=[];for(let[i,a]of Object.entries(e)){if(a===void 0)continue;let e=`${n}${G(i)}:`;if(q(a))r.push(`${e} ${K(a)}`);else if(Array.isArray(a)){if(a.every(q))r.push(`${e} ${xe(a)}`);else{r.push(e);for(let e of a)r.push(`${n}${me}- ${q(e)?K(e):JSON.stringify(e)}`)}}else Ce(a)&&(Object.keys(a).filter(e=>a[e]!==void 0).length===0?r.push(`${e} {}`):(r.push(e),r.push(...we(a,t+1))))}return r}function Te(e,t=0){return we(e,t).join(`
`)}function Ee(e,t){let n=t,r=[`spec`,`plugin`,`llmgateway`,...e];for(let e=r.length-1;e>=0;e--)n={[r[e]]:n};return Te(n)}function J(e){if(e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`)return e;if(Array.isArray(e))return e.map(J);if(typeof e==`object`){let t={};for(let[n,r]of Object.entries(e))t[n]=J(r);return t}return String(e)}var De=/^[a-zA-Z0-9._-]+$/;function Oe(e){return De.test(e)}function Y(e){return e.trim()!==``}function X(e){return Number.isFinite(e)&&e>=0}function ke(e){return Number.isInteger(e)&&e>=0}function Ae(e,t){return t.length>0&&e.length===0?`A personal grant naming models needs at least one provider too — an empty providers list means EVERY configured provider (not none), so this would silently widen access far beyond what was typed (auth.go rejects it).`:null}var je=[`requestsPerMinute`,`requestsPerDay`,`tokensPerDay`,`tokensPerMonth`,`costPerDayUSD`,`costPerMonthUSD`];function Z(e){let t=[];for(let n of je){let r=e[n];r&&t.push([n,r])}return t}function Me(e,t){let n={};for(let[e,r]of Z(t))n[e]=r;return Ee([`groups`,e],{limits:n})}function Q(e){return JSON.stringify(e)}function $(e){return`[${e.map(Q).join(`, `)}]`}function Ne(e){return`{${Z(e).map(([e,t])=>`${Q(e)}: ${t}`).join(`, `)}}`}function Pe(e){return`"limits": ${Ne(e)}`}function Fe(e,t){return Ee([`groups`,e],{providers:t.providers,models:t.models,mcpServers:t.mcpServers,agents:t.agents})}function Ie(e){let t=[];return e.providers.length>0&&t.push(`"providers": ${$(e.providers)}`),e.models.length>0&&t.push(`"models": ${$(e.models)}`),t.join(`, `)}function Le(e,t){let n=[];t.contextTokens!==void 0&&n.push([`contextTokens`,t.contextTokens]),t.free!==void 0&&n.push([`free`,t.free]);let r=Se(n);return[`spec:`,`  plugin:`,`    llmgateway:`,`      modelMeta:`,`        ${JSON.stringify(e)}: ${r}`].join(`
`)}function Re(e,t){let n=Se([[`inputPerM`,t.inputPerM],[`outputPerM`,t.outputPerM]]);return[`spec:`,`  plugin:`,`    llmgateway:`,`      pricing:`,`        ${G(e)}: ${n}`].join(`
`)}var ze=`sk-llmgw-REPLACE_ME`;function Be(){let e=crypto.getRandomValues(new Uint8Array(32)),t=``;for(let n of e)t+=String.fromCharCode(n);return`sk-llmgw-${btoa(t).replace(/\+/g,`-`).replace(/\//g,`_`).replace(/=+$/,``)}`}function Ve(e){let t=[`"name": ${Q(e.name)}`,`"apiKey": ${Q(e.apiKey)}`];return e.group&&t.push(`"group": ${Q(e.group)}`),e.groups&&e.groups.length>0&&t.push(`"groups": ${$(e.groups)}`),e.providers&&e.providers.length>0&&t.push(`"providers": ${$(e.providers)}`),e.models&&e.models.length>0&&t.push(`"models": ${$(e.models)}`),e.limits&&Z(e.limits).length>0&&t.push(`"limits": ${Ne(e.limits)}`),e.admin&&t.push(`"admin": ${K(!0)}`),`{${t.join(`, `)}}`}var He={class:`flex flex-col gap-4`},Ue={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},We={class:`flex flex-col gap-1`},Ge={class:`flex flex-col gap-1`},Ke={id:`grant-target-name-label`,class:`text-xs font-medium text-muted-foreground`},qe={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},Je={class:`flex flex-col gap-1`},Ye={class:`flex flex-col gap-1`},Xe={class:`flex flex-col gap-1`},Ze={class:`flex flex-col gap-1`},Qe={key:2,class:`text-sm text-muted-foreground`},$e=p({__name:`GrantForm`,props:{groupNames:{},userNames:{}},setup(e){let t=e,n=A(`group`),i=A(``),o=A(``),s=A(``),l=A(``),u=A(``);function d(e){let t=new Set;for(let n of e.split(`,`)){let e=n.trim();e&&t.add(e)}return Array.from(t)}let f=w(()=>d(o.value)),p=w(()=>d(s.value)),m=w(()=>d(l.value)),g=w(()=>d(u.value)),y=w(()=>n.value===`group`?t.groupNames:t.userNames),b=w(()=>n.value===`group`?Oe(i.value.trim()):Y(i.value)),C=w(()=>n.value===`user`?Ae(f.value,p.value):null),T=w(()=>f.value.length===0&&p.value.length===0&&m.value.length===0&&g.value.length===0),D=w(()=>!b.value||C.value||T.value?null:n.value===`group`?Fe(i.value.trim(),{providers:f.value,models:p.value,mcpServers:m.value,agents:g.value}):Ie({providers:f.value,models:p.value})||null);return(e,t)=>(k(),_(`div`,He,[h(`div`,Ue,[h(`div`,We,[t[8]||=h(`label`,{id:`grant-target-kind-label`,class:`text-xs font-medium text-muted-foreground`},`Target`,-1),S(x(V),{"model-value":n.value,"onUpdate:modelValue":t[0]||=e=>n.value=e},{default:r(()=>[S(x(H),{"aria-labelledby":`grant-target-kind-label`},{default:r(()=>[S(x(B))]),_:1}),S(x(I),null,{default:r(()=>[S(x(z),{value:`group`},{default:r(()=>[...t[6]||=[E(`Group`,-1)]]),_:1}),S(x(z),{value:`user`},{default:r(()=>[...t[7]||=[E(`User (personal grant, existing users.json entry)`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`])]),h(`div`,Ge,[h(`label`,Ke,c(n.value===`group`?`Group name`:`User name`),1),S(x(V),{"model-value":i.value,"onUpdate:modelValue":t[1]||=e=>i.value=String(e)},{default:r(()=>[S(x(H),{"aria-labelledby":`grant-target-name-label`},{default:r(()=>[S(x(B),{placeholder:`Select…`})]),_:1}),S(x(I),null,{default:r(()=>[(k(!0),_(a,null,v(y.value,e=>(k(),j(x(z),{key:e,value:e},{default:r(()=>[E(c(e),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),h(`div`,qe,[h(`div`,Je,[t[9]||=h(`label`,{for:`grant-providers`,class:`text-xs font-medium text-muted-foreground`},`Providers (comma-separated, empty = all)`,-1),S(x(U),{id:`grant-providers`,modelValue:o.value,"onUpdate:modelValue":t[2]||=e=>o.value=e,placeholder:`anthropic, openai`},null,8,[`modelValue`])]),h(`div`,Ye,[t[10]||=h(`label`,{for:`grant-models`,class:`text-xs font-medium text-muted-foreground`},`Models (comma-separated, empty = all)`,-1),S(x(U),{id:`grant-models`,modelValue:s.value,"onUpdate:modelValue":t[3]||=e=>s.value=e,placeholder:`anthropic/claude-sonnet-5`},null,8,[`modelValue`])]),n.value===`group`?(k(),_(a,{key:0},[h(`div`,Xe,[t[11]||=h(`label`,{for:`grant-mcp`,class:`text-xs font-medium text-muted-foreground`},`MCP servers (comma-separated, empty = all)`,-1),S(x(U),{id:`grant-mcp`,modelValue:l.value,"onUpdate:modelValue":t[4]||=e=>l.value=e,placeholder:`fetch, weather`},null,8,[`modelValue`])]),h(`div`,Ze,[t[12]||=h(`label`,{for:`grant-agents`,class:`text-xs font-medium text-muted-foreground`},`Agents (comma-separated, empty = all)`,-1),S(x(U),{id:`grant-agents`,modelValue:u.value,"onUpdate:modelValue":t[5]||=e=>u.value=e,placeholder:`agentkit`},null,8,[`modelValue`])])],64)):M(``,!0)]),C.value?(k(),j(x(L),{key:0,variant:`destructive`},{default:r(()=>[S(x(R),null,{default:r(()=>[E(c(C.value),1)]),_:1})]),_:1})):M(``,!0),D.value?(k(),j(W,{key:1,label:n.value===`group`?`Paste into middleware.yaml`:`Merge into ${i.value}’s users.json line`,text:D.value},null,8,[`label`,`text`])):(k(),_(`p`,Qe,`Pick a target and at least one list to build a snippet.`))]))}}),et={class:`flex flex-col gap-4`},tt={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},nt={class:`flex flex-col gap-1`},rt={class:`flex flex-col gap-1`},it={id:`limits-target-name-label`,class:`text-xs font-medium text-muted-foreground`},at={class:`grid grid-cols-1 gap-3 sm:grid-cols-3`},ot=[`for`],st={key:0},ct={key:1},lt={key:2,class:`text-sm text-muted-foreground`},ut=p({__name:`LimitsForm`,props:{groupNames:{},userNames:{}},setup(e){let t=e,n=A(`group`),i=A(``),o=new Set([`requestsPerMinute`,`requestsPerDay`,`tokensPerDay`,`tokensPerMonth`]);function s(e,t){return o.has(e)?ke(t):X(t)}let l=[{key:`requestsPerMinute`,label:`Requests/minute`},{key:`requestsPerDay`,label:`Requests/day`},{key:`tokensPerDay`,label:`Tokens/day (in+out)`},{key:`tokensPerMonth`,label:`Tokens/month (in+out)`},{key:`costPerDayUSD`,label:`Cost/day (USD)`},{key:`costPerMonthUSD`,label:`Cost/month (USD)`}],u=C({requestsPerMinute:``,requestsPerDay:``,tokensPerDay:``,tokensPerMonth:``,costPerDayUSD:``,costPerMonthUSD:``}),d=w(()=>n.value===`group`?t.groupNames:t.userNames),f=w(()=>l.filter(({key:e})=>u[e].trim()!==``&&!s(e,Number(u[e]))).map(e=>e.label)),p=w(()=>l.filter(({key:e})=>o.has(e)&&u[e].trim()!==``&&!s(e,Number(u[e]))).map(e=>e.label)),m=w(()=>l.filter(({key:e})=>!o.has(e)&&u[e].trim()!==``&&!s(e,Number(u[e]))).map(e=>e.label)),g=w(()=>{let e={};for(let{key:t}of l){let n=Number(u[t]);u[t].trim()!==``&&s(t,n)&&n>0&&(e[t]=n)}return e}),y=w(()=>n.value===`group`?Oe(i.value.trim()):Y(i.value)),b=w(()=>!y.value||f.value.length>0||Object.keys(g.value).length===0?null:n.value===`group`?Me(i.value.trim(),g.value):Pe(g.value));return(e,t)=>(k(),_(`div`,et,[h(`div`,tt,[h(`div`,nt,[t[4]||=h(`label`,{id:`limits-target-kind-label`,class:`text-xs font-medium text-muted-foreground`},`Target`,-1),S(x(V),{"model-value":n.value,"onUpdate:modelValue":t[0]||=e=>n.value=e},{default:r(()=>[S(x(H),{"aria-labelledby":`limits-target-kind-label`},{default:r(()=>[S(x(B))]),_:1}),S(x(I),null,{default:r(()=>[S(x(z),{value:`group`},{default:r(()=>[...t[2]||=[E(`Group`,-1)]]),_:1}),S(x(z),{value:`user`},{default:r(()=>[...t[3]||=[E(`User (existing users.json entry)`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`])]),h(`div`,rt,[h(`label`,it,c(n.value===`group`?`Group name`:`User name`),1),S(x(V),{"model-value":i.value,"onUpdate:modelValue":t[1]||=e=>i.value=String(e)},{default:r(()=>[S(x(H),{"aria-labelledby":`limits-target-name-label`},{default:r(()=>[S(x(B),{placeholder:`Select…`})]),_:1}),S(x(I),null,{default:r(()=>[(k(!0),_(a,null,v(d.value,e=>(k(),j(x(z),{key:e,value:e},{default:r(()=>[E(c(e),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),h(`div`,at,[(k(),_(a,null,v(l,e=>h(`div`,{key:e.key,class:`flex flex-col gap-1`},[h(`label`,{for:`limits-${e.key}`,class:`text-xs font-medium text-muted-foreground`},c(e.label),9,ot),S(x(U),{id:`limits-${e.key}`,modelValue:u[e.key],"onUpdate:modelValue":t=>u[e.key]=t,type:`number`,min:`0`,step:x(o).has(e.key)?`1`:`any`,placeholder:`unset`},null,8,[`id`,`modelValue`,`onUpdate:modelValue`,`step`])])),64))]),f.value.length?(k(),j(x(L),{key:0,variant:`destructive`},{default:r(()=>[S(x(R),null,{default:r(()=>[p.value.length?(k(),_(`p`,st,`Enter a non-negative whole number for: `+c(p.value.join(`, `))+`.`,1)):M(``,!0),m.value.length?(k(),_(`p`,ct,`Enter a non-negative number for: `+c(m.value.join(`, `))+`.`,1)):M(``,!0)]),_:1})]),_:1})):M(``,!0),b.value?(k(),j(W,{key:1,label:n.value===`group`?`Paste into middleware.yaml`:`Merge into ${i.value}’s users.json line`,text:b.value},null,8,[`label`,`text`])):(k(),_(`p`,lt,`Pick a target and at least one limit to build a snippet.`))]))}}),dt={class:`flex flex-col gap-4`},ft={class:`flex flex-col gap-1`},pt={class:`grid grid-cols-1 gap-3 sm:grid-cols-2 sm:items-end`},mt={class:`flex flex-col gap-1`},ht={class:`flex items-center gap-2 pb-1.5 text-sm`},gt={key:2,class:`text-sm text-muted-foreground`},_t=p({__name:`ModelMetaForm`,setup(e){let t=A(``),n=A(``),a=A(!1),s=w(()=>t.value.trim()!==``),c=w(()=>Number(n.value)),l=w(()=>n.value.trim()!==``),u=w(()=>!l.value||ke(c.value)&&c.value>0),d=w(()=>!s.value||!u.value||!l.value&&!a.value?null:Le(t.value.trim(),{contextTokens:l.value?c.value:void 0,free:a.value||void 0}));return(e,s)=>(k(),_(`div`,dt,[h(`div`,ft,[s[3]||=h(`label`,{for:`modelmeta-model-id`,class:`text-xs font-medium text-muted-foreground`},`Model id (provider/model)`,-1),S(x(U),{id:`modelmeta-model-id`,modelValue:t.value,"onUpdate:modelValue":s[0]||=e=>t.value=e,placeholder:`gx10/current`,class:`font-mono`},null,8,[`modelValue`])]),h(`div`,pt,[h(`div`,mt,[s[4]||=h(`label`,{for:`modelmeta-context`,class:`text-xs font-medium text-muted-foreground`},`Context window (tokens)`,-1),S(x(U),{id:`modelmeta-context`,modelValue:n.value,"onUpdate:modelValue":s[1]||=e=>n.value=e,type:`number`,min:`1`,step:`1`,placeholder:`131072`},null,8,[`modelValue`])]),h(`label`,ht,[o(h(`input`,{id:`modelmeta-free`,"onUpdate:modelValue":s[2]||=e=>a.value=e,type:`checkbox`,class:`size-4 rounded border-input`},null,512),[[i,a.value]]),s[5]||=E(` Free (billed as $0 regardless of any resolved price) `,-1)])]),l.value&&!u.value?(k(),j(x(L),{key:0,variant:`destructive`},{default:r(()=>[S(x(R),null,{default:r(()=>[...s[6]||=[E(`Context window must be a positive whole number of tokens.`,-1)]]),_:1})]),_:1})):M(``,!0),d.value?(k(),j(W,{key:1,label:`Paste into middleware.yaml`,text:d.value},null,8,[`text`])):(k(),_(`p`,gt,`Enter a model id and set a context window and/or free to build a snippet.`))]))}}),vt={class:`flex flex-col gap-4`},yt={class:`flex flex-col gap-1`},bt={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},xt={class:`flex flex-col gap-1`},St={class:`flex flex-col gap-1`},Ct={key:2,class:`text-sm text-muted-foreground`},wt=p({__name:`PricingForm`,setup(e){let t=A(``),n=A(``),i=A(``),o=w(()=>t.value.trim()!==``),s=w(()=>Number(n.value)),l=w(()=>Number(i.value)),u=w(()=>n.value.trim()!==``&&X(s.value)),d=w(()=>i.value.trim()!==``&&X(l.value)),f=w(()=>{let e=[];return n.value.trim()!==``&&!u.value&&e.push(`Input price/MTok must be a non-negative number.`),i.value.trim()!==``&&!d.value&&e.push(`Output price/MTok must be a non-negative number.`),(u.value&&!d.value||!u.value&&d.value)&&e.push(`Set both input and output price/MTok — a one-sided override has no billing meaning.`),e}),p=w(()=>!o.value||!u.value||!d.value?null:Re(t.value.trim(),{inputPerM:s.value,outputPerM:l.value}));return(e,o)=>(k(),_(`div`,vt,[h(`div`,yt,[o[3]||=h(`label`,{for:`pricing-model-id`,class:`text-xs font-medium text-muted-foreground`},`Model id (provider/model)`,-1),S(x(U),{id:`pricing-model-id`,modelValue:t.value,"onUpdate:modelValue":o[0]||=e=>t.value=e,placeholder:`openai/gpt-4`,class:`font-mono`},null,8,[`modelValue`])]),h(`div`,bt,[h(`div`,xt,[o[4]||=h(`label`,{for:`pricing-input`,class:`text-xs font-medium text-muted-foreground`},`Input price / MTok (USD)`,-1),S(x(U),{id:`pricing-input`,modelValue:n.value,"onUpdate:modelValue":o[1]||=e=>n.value=e,type:`number`,min:`0`,step:`any`,placeholder:`0.50`},null,8,[`modelValue`])]),h(`div`,St,[o[5]||=h(`label`,{for:`pricing-output`,class:`text-xs font-medium text-muted-foreground`},`Output price / MTok (USD)`,-1),S(x(U),{id:`pricing-output`,modelValue:i.value,"onUpdate:modelValue":o[2]||=e=>i.value=e,type:`number`,min:`0`,step:`any`,placeholder:`1.50`},null,8,[`modelValue`])])]),f.value.length?(k(),j(x(L),{key:0,variant:`destructive`},{default:r(()=>[S(x(R),null,{default:r(()=>[(k(!0),_(a,null,v(f.value,(e,t)=>(k(),_(`p`,{key:t},c(e),1))),128))]),_:1})]),_:1})):M(``,!0),p.value?(k(),j(W,{key:1,label:`Paste into middleware.yaml`,text:p.value},null,8,[`text`])):(k(),_(`p`,Ct,`Enter a model id and both prices to build a snippet.`))]))}}),Tt={class:`flex flex-col gap-4`},Et={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},Dt={class:`flex flex-col gap-1`},Ot={class:`flex flex-col gap-1`},kt={class:`flex flex-col gap-1`},At={class:`flex gap-2`},jt={key:0,class:`text-xs text-muted-foreground`},Mt={class:`flex flex-col gap-1`},Nt={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},Pt={class:`flex flex-col gap-1`},Ft={class:`flex flex-col gap-1`},It={class:`flex items-center gap-2 text-sm`},Lt={key:2,class:`text-sm text-muted-foreground`},Rt=p({__name:`UserForm`,props:{groupNames:{}},setup(e){let n=e,s=A(``),l=A(ze),u=A(``),d=A(``),p=A(``),m=A(``),g=A(!1),y=f();function b(){try{l.value=Be(),y.push({kind:`success`,message:`Generated a new API key.`})}catch(e){y.push({kind:`error`,message:e instanceof Error?`Could not generate an API key: ${e.message}`:`Could not generate an API key.`})}}function C(e){let t=new Set;for(let n of e.split(`,`)){let e=n.trim();e&&t.add(e)}return Array.from(t)}let T=w(()=>C(d.value)),D=w(()=>C(p.value)),O=w(()=>C(m.value)),N=w(()=>Y(s.value)),ee=w(()=>u.value!==``),P=w(()=>l.value.trim()!==``&&l.value!==`sk-llmgw-REPLACE_ME`),F=w(()=>Ae(D.value,O.value)),te=w(()=>{if(!N.value||!ee.value||!P.value||F.value)return null;let e=T.value.length>0?[u.value,...T.value]:null;return Ve({name:s.value.trim(),apiKey:l.value.trim(),group:e?void 0:u.value,groups:e??void 0,providers:D.value,models:O.value,admin:g.value})});return(e,f)=>(k(),_(`div`,Tt,[h(`div`,Et,[h(`div`,Dt,[f[7]||=h(`label`,{for:`user-name`,class:`text-xs font-medium text-muted-foreground`},`Name`,-1),S(x(U),{id:`user-name`,modelValue:s.value,"onUpdate:modelValue":f[0]||=e=>s.value=e,placeholder:`alice`},null,8,[`modelValue`])]),h(`div`,Ot,[f[8]||=h(`label`,{id:`user-group-label`,class:`text-xs font-medium text-muted-foreground`},`Primary group`,-1),S(x(V),{"model-value":u.value,"onUpdate:modelValue":f[1]||=e=>u.value=String(e)},{default:r(()=>[S(x(H),{"aria-labelledby":`user-group-label`},{default:r(()=>[S(x(B),{placeholder:`Select…`})]),_:1}),S(x(I),null,{default:r(()=>[(k(!0),_(a,null,v(n.groupNames,e=>(k(),j(x(z),{key:e,value:e},{default:r(()=>[E(c(e),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),h(`div`,kt,[f[10]||=h(`label`,{for:`user-api-key`,class:`text-xs font-medium text-muted-foreground`},`API key`,-1),h(`div`,At,[S(x(U),{id:`user-api-key`,modelValue:l.value,"onUpdate:modelValue":f[2]||=e=>l.value=e,class:`font-mono`},null,8,[`modelValue`]),S(x(t),{type:`button`,variant:`outline`,size:`sm`,onClick:b},{default:r(()=>[...f[9]||=[E(`Generate`,-1)]]),_:1})]),l.value===x(`sk-llmgw-REPLACE_ME`)?(k(),_(`p`,jt,`Still the placeholder — click Generate for a real key.`)):M(``,!0)]),h(`div`,Mt,[f[11]||=h(`label`,{for:`user-extra-groups`,class:`text-xs font-medium text-muted-foreground`},`Additional groups (comma-separated, optional)`,-1),S(x(U),{id:`user-extra-groups`,modelValue:d.value,"onUpdate:modelValue":f[3]||=e=>d.value=e,placeholder:`friends`},null,8,[`modelValue`])]),h(`div`,Nt,[h(`div`,Pt,[f[12]||=h(`label`,{for:`user-providers`,class:`text-xs font-medium text-muted-foreground`},`Personal grant: providers (optional)`,-1),S(x(U),{id:`user-providers`,modelValue:p.value,"onUpdate:modelValue":f[4]||=e=>p.value=e,placeholder:`gx10`},null,8,[`modelValue`])]),h(`div`,Ft,[f[13]||=h(`label`,{for:`user-models`,class:`text-xs font-medium text-muted-foreground`},`Personal grant: models (optional)`,-1),S(x(U),{id:`user-models`,modelValue:m.value,"onUpdate:modelValue":f[5]||=e=>m.value=e,placeholder:`gx10/current`},null,8,[`modelValue`])])]),h(`label`,It,[o(h(`input`,{"onUpdate:modelValue":f[6]||=e=>g.value=e,type:`checkbox`,class:`size-4 rounded border-input`},null,512),[[i,g.value]]),f[14]||=E(` Admin (full access to /admin/api/*) `,-1)]),F.value?(k(),j(x(L),{key:0,variant:`destructive`},{default:r(()=>[S(x(R),null,{default:r(()=>[E(c(F.value),1)]),_:1})]),_:1})):M(``,!0),te.value?(k(),j(W,{key:1,label:`Add as a new line in users.json`,text:te.value},null,8,[`text`])):(k(),_(`p`,Lt,`Fill in a name, group, and a real (generated) API key to build a snippet.`))]))}}),zt={class:`flex flex-col gap-4`},Bt=p({__name:`ChangeHelper`,props:{groupNames:{},userNames:{}},setup(e){let t=[`limits`,`grant`,`pricing`,`model`,`user`],n={limits:`Limits`,grant:`Access grant`,pricing:`Pricing`,model:`Model metadata`,user:`New user`},i=e,o=O(),s=w(()=>{let e=o.params.helper;return t.includes(e??``)?e:`limits`});function l(e){typeof e!=`string`||!t.includes(e)||o.goTo(`config`,{...o.params,helper:e})}return(e,o)=>(k(),_(`div`,zt,[S(x(ie),{"model-value":s.value,"onUpdate:modelValue":l},{default:r(()=>[S(x(re),null,{default:r(()=>[(k(),_(a,null,v(t,e=>S(x(ae),{key:e,value:e},{default:r(()=>[E(c(n[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`]),s.value===`limits`?(k(),j(ut,{key:0,"group-names":i.groupNames,"user-names":i.userNames},null,8,[`group-names`,`user-names`])):s.value===`grant`?(k(),j($e,{key:1,"group-names":i.groupNames,"user-names":i.userNames},null,8,[`group-names`,`user-names`])):s.value===`pricing`?(k(),j(wt,{key:2})):s.value===`model`?(k(),j(_t,{key:3})):(k(),j(Rt,{key:4,"group-names":i.groupNames},null,8,[`group-names`]))]))}}),Vt={class:`flex flex-col gap-4`},Ht=p({__name:`ConfigTree`,props:{config:{},warnings:{}},setup(e){let t=e,n=w(()=>Te(J(t.config)));return(t,i)=>(k(),_(`div`,Vt,[(k(!0),_(a,null,v(e.warnings,(e,t)=>(k(),j(x(L),{key:t,variant:`warn`},{default:r(()=>[S(x(se),null,{default:r(()=>[...i[0]||=[E(`Config warning`,-1)]]),_:1}),S(x(R),null,{default:r(()=>[E(c(e),1)]),_:2},1024)]),_:2},1024))),128)),S(W,{label:`Redacted running config (read-only)`,text:n.value},null,8,[`text`])]))}}),Ut=m(`config`,{state:()=>({data:null,loading:!1,error:``}),actions:{async fetchConfig(){if(F().isAuthenticated){this.loading=!0;try{this.data=await g(`/admin/api/config`),this.error=``}catch(e){if(e instanceof te&&(e.status===401||e.status===403))return;this.error=e instanceof Error?e.message:String(e)}finally{this.loading=!1}}},async ensureConfig(){this.loading||this.data||await this.fetchConfig()}}}),Wt={class:`flex flex-col gap-6`},Gt=p({__name:`ConfigPage`,setup(t){let n=Ut(),i=b(),a=ue();d(()=>{n.ensureConfig(),a.ensureConsumers()});let o=w(()=>(i.overview?.groups??[]).map(e=>e.name)),c=w(()=>(a.data?.users??[]).map(e=>e.name));return(t,i)=>(k(),_(`div`,Wt,[x(n).error&&!x(n).data?(k(),j(x(l),{key:0},{default:r(()=>[S(x(e),null,{default:r(()=>[S(x(s),null,{default:r(()=>[...i[0]||=[E(`Config`,-1)]]),_:1})]),_:1}),S(x(P),null,{default:r(()=>[S(le,{message:x(n).error,"on-retry":x(n).fetchConfig},null,8,[`message`,`on-retry`])]),_:1})]),_:1})):x(n).loading&&!x(n).data?(k(),j(x(l),{key:1},{default:r(()=>[S(x(P),{class:`flex flex-col gap-1.5`},{default:r(()=>[S(x(N),{class:`h-3 w-56`}),S(x(N),{class:`h-64 w-full rounded-md`})]),_:1})]),_:1})):x(n).data?(k(),j(Ht,{key:2,config:x(n).data.config,warnings:x(n).data.warnings},null,8,[`config`,`warnings`])):M(``,!0),S(x(l),null,{default:r(()=>[S(x(e),null,{default:r(()=>[S(x(s),null,{default:r(()=>[...i[1]||=[E(`Change helper`,-1)]]),_:1}),S(x(oe),null,{default:r(()=>[...i[2]||=[E(`Build a paste-ready snippet for middleware.yaml or users.json — nothing here writes to the running config.`,-1)]]),_:1})]),_:1}),S(x(P),null,{default:r(()=>[S(Bt,{"group-names":o.value,"user-names":c.value},null,8,[`group-names`,`user-names`])]),_:1})]),_:1})]))}});export{Gt as default};",
		),
	},
	"ConsumersPage-i8sZV9MX.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{Ar as e,C as t,E as n,Fr as r,Jt as i,K as a,On as o,Qr as s,S as c,Si as l,T as u,W as d,X as f,Xn as p,_n as m,an as h,cn as g,cr as _,er as ee,g as te,gi as v,hn as y,ht as b,ii as x,in as S,mn as C,mt as w,n as ne,nr as T,oi as E,on as D,sn as O,ur as re,w as k,xi as A,yi as j}from"./Skeleton-B0ziB6Od.js";import{a as ie,c as ae,i as M,n as N,o as P,r as F,s as I,t as L}from"./search-expand-CHd4FWZZ.js";import{n as oe,r as R,t as z}from"./tabs-YlhnHpK-.js";import{c as B,g as se,h as ce,m as V,t as H}from"./index-dywS8OpT.js";import{t as U}from"./ErrorState-ym6eSlj2.js";import{t as le}from"./consumers-CQtEJ9K7.js";import{_ as W,c as G,f as K,o as q,r as ue,t as J,u as Y,v as de}from"./badge-DUiBTDyA.js";import{a as fe,c as X,d as pe,f as me,i as he,l as ge,n as _e,o as ve,r as ye,s as be,t as xe,u as Se}from"./DataTable-CQxRVDSY.js";import{t as Z}from"./CompactNumber-pr8cJ4cv.js";import{a as Ce,c as we,i as Q,n as Te,o as Ee,r as De,s as Oe,t as ke}from"./TryLongerRangeButton-CjkUnaOz.js";import{a as Ae,i as je,o as Me,r as Ne,s as Pe}from"./burndown-Bz44x7-d.js";import{n as Fe,t as Ie}from"./useSearchQuery-bQZP4TsZ.js";import{t as Le}from"./SkeletonList-Cmqz3hfa.js";import{t as Re}from"./EntityLink-Dg93KGVT.js";import{t as ze}from"./ClampedRangeNotice-D2walnXf.js";import{n as Be,t as Ve}from"./TimeSeriesChart-BFcT6woA.js";import{t as He}from"./events-PUxhEega.js";function Ue(e,t){t.value=typeof e==`function`?e(t.value):e}function We(e,t){if(!e.allowedProviders.includes(t))return{allowed:!1};let n=e.modelAccess[t];if(!n)return{allowed:!0};let r=n.allowed===0&&n.total>0||void 0;return{allowed:!0,detail:`${n.allowed}/${n.total} models`,zero:r}}function Ge(e,t){return t.access===void 0||t.access===null?{allowed:!0}:{allowed:t.access.includes(e.name)}}var Ke=[`models`,`mcp`,`agents`],qe={models:`Models`,mcp:`MCP servers`,agents:`Agents`};function Je(e){return Ke.includes(e??``)?e:`models`}function Ye(e,t,n,r){return e.map(e=>({group:e.name,providers:Object.fromEntries(t.map(t=>[t,We(e,t)])),mcpServers:Object.fromEntries(n.map(t=>[t.name,Ge(e,t)])),agents:Object.fromEntries(r.map(t=>[t.name,Ge(e,t)]))}))}function Xe(e,t,n){return e?t===0?`empty`:`ready`:n?`error`:`loading`}var Ze={key:0,"aria-hidden":`true`,class:`ml-1 text-xs text-muted-foreground`},Qe={class:`sr-only`},$e=m({__name:`AccessMatrix`,props:{kind:{}},emits:[`update:kind`],setup(e,{emit:a}){let o=e,s=a,d=le(),m=te(),ee=ne();p(()=>{d.ensureConsumers()});let x=S(()=>(m.overview?.providers??[]).map(e=>e.name)),E=S(()=>m.targets?.mcpServers??[]),A=S(()=>m.targets?.agents??[]),ie={models:`providers`,mcp:`mcpServers`,agents:`agents`},ae={models:`Which groups can reach which providers, and how many of each provider's models.`,mcp:`Which groups can reach which MCP servers.`,agents:`Which groups can reach which agents.`},M={models:`No providers configured.`,mcp:`No MCP servers configured.`,agents:`No agents configured.`},N=S(()=>{let e=ie[o.kind];return o.kind===`models`?x.value.map(t=>({key:t,label:t,section:e})):(o.kind===`mcp`?E.value:A.value).map(t=>({key:t.name,label:t.name,section:e}))}),P=S(()=>Ye(d.data?.groups??[],x.value,E.value,A.value)),F=S(()=>o.kind===`models`?m.overview!==null:m.targets!==null),I=S(()=>Xe(F.value,N.value.length,m.error)),L=S(()=>W({loading:d.loading,hasData:d.data!==null,error:d.error})),se=S(()=>L.value===`ready`&&P.value.length===0),ce={allowed:!1};function V(e,t){return e[t.section][t.key]??ce}function H(e){typeof e!=`string`||!Ke.includes(e)||s(`update:kind`,e)}function G(e){return e.allowed?e.zero?`Allowed, but ${e.detail} reachable — the model grant matches none of this provider's models`:e.detail?`Allowed, ${e.detail}`:`Allowed`:`Not allowed`}function K(e){return e.allowed?e.zero?w:f:b}function q(e){return e.allowed?e.zero?`text-status-warn`:`text-chart-requests`:`text-muted-foreground/40`}return(e,a)=>{let s=re(`FontAwesomeIcon`);return T(),D(v(u),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(c),null,{default:r(()=>[...a[1]||=[C(`Access matrix`,-1)]]),_:1}),y(v(B),null,{default:r(()=>[C(l(ae[o.kind]),1)]),_:1}),y(v(R),{"model-value":o.kind,"onUpdate:modelValue":H},{default:r(()=>[y(v(oe),null,{default:r(()=>[(T(!0),g(i,null,_(v(Ke),e=>(T(),D(v(z),{key:e,value:e},{default:r(()=>[C(l(v(qe)[e]),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])]),_:1}),L.value===`error`?(T(),D(v(k),{key:0},{default:r(()=>[y(U,{message:v(d).error,"on-retry":v(d).fetchConsumers},null,8,[`message`,`on-retry`])]),_:1})):L.value===`skeleton`?(T(),D(v(k),{key:1},{default:r(()=>[y(ve,{rows:4,cols:4})]),_:1})):se.value?(T(),D(v(k),{key:2},{default:r(()=>[y(de,{title:`No groups configured.`,description:`Grant a group access from the Config page's change helper.`},{default:r(()=>[y(v(n),{type:`button`,variant:`outline`,size:`sm`,onClick:a[0]||=e=>v(ee).goTo(`config`,{helper:`grant`})},{default:r(()=>[...a[2]||=[C(`Open change helper`,-1)]]),_:1})]),_:1})]),_:1})):I.value===`error`?(T(),D(v(k),{key:3},{default:r(()=>[y(U,{message:v(m).error},null,8,[`message`])]),_:1})):I.value===`loading`?(T(),D(v(k),{key:4},{default:r(()=>[y(ve,{rows:P.value.length,cols:4},null,8,[`rows`])]),_:1})):I.value===`empty`?(T(),D(v(k),{key:5},{default:r(()=>[y(de,{title:M[o.kind]},null,8,[`title`])]),_:1})):(T(),D(v(k),{key:6,class:`overflow-x-auto`},{default:r(()=>[y(v(me),null,{default:r(()=>[y(v(be),null,{default:r(()=>[y(v(ge),null,{default:r(()=>[y(v(X),null,{default:r(()=>[...a[3]||=[C(`Group`,-1)]]),_:1}),(T(!0),g(i,null,_(N.value,e=>(T(),D(v(X),{key:e.key},{default:r(()=>[C(l(e.label),1)]),_:2},1024))),128))]),_:1})]),_:1}),y(v(pe),null,{default:r(()=>[(T(!0),g(i,null,_(P.value,e=>(T(),D(v(ge),{key:e.group},{default:r(()=>[y(v(X),{scope:`row`,class:`font-medium`},{default:r(()=>[C(l(e.group),1)]),_:2},1024),(T(!0),g(i,null,_(N.value,t=>(T(),D(v(Se),{key:t.key,class:`text-center`,title:V(e,t).detail},{default:r(()=>[y(s,{icon:K(V(e,t)),class:j([q(V(e,t)),`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),V(e,t).detail?(T(),g(`span`,Ze,l(V(e,t).detail),1)):O(``,!0),h(`span`,Qe,l(G(V(e,t))),1)]),_:2},1032,[`title`]))),128))]),_:2},1024))),128))]),_:1})]),_:1})]),_:1}))]),_:1})}}}),et=[`aria-label`,`aria-valuenow`,`aria-valuetext`,`title`],tt=m({__name:`UsageBar`,props:{ratio:{},label:{},valueText:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=S(()=>we(t.ratio)),r=S(()=>Math.min(100,Math.max(0,t.ratio*100))),i=S(()=>Math.round(r.value)),a={normal:`bg-primary`,amber:`bg-bar-amber`,red:`bg-destructive`};return(o,s)=>(T(),g(`span`,{role:`meter`,"aria-label":e.label,"aria-valuenow":i.value,"aria-valuemin":`0`,"aria-valuemax":`100`,"aria-valuetext":e.valueText,title:e.valueText,class:j(v(d)(`relative inline-block h-1.5 w-14 shrink-0 overflow-hidden rounded-full bg-muted align-middle`,t.class))},[h(`span`,{class:j([`absolute inset-y-0 left-0 rounded-full`,a[n.value]]),style:A({width:`${r.value}%`})},null,6)],10,et))}}),nt=60,rt=3600,it=86400,at=60,ot=30;function st(e,t=new Date){if(!e)return`never`;let n=Math.floor(t.getTime()/1e3),r=Math.max(0,n-e);if(r<nt)return`just now`;if(r<rt)return`${Math.floor(r/nt)}m ago`;if(r<it)return`${Math.floor(r/rt)}h ago`;let i=Math.floor(r/it);return i<at?`${i}d ago`:`${Math.floor(i/ot)}mo ago`}function $(e,t,n,r=String,i=!0,a){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>{if(e.original.storeDown)return`?`;let s=n(e.original),c=i?o(Z,{value:s}):r(s);if(!a)return c;let l=Oe(e.original).find(e=>e.id===a);if(!l)return c;let u=i?`${G(l.used)} / ${G(l.limit)}`:`${r(l.used)} / ${r(l.limit)}`;return o(`span`,{class:`inline-flex items-center justify-end gap-1.5`},[c,o(tt,{ratio:l.ratio,label:Ce[a]??t,valueText:u})])}}}function ct(){return{id:`rejDay`,header:`rejected/day`,accessorFn:e=>e.rejectionsPerDay,meta:{align:`right`},cell:({row:e})=>{if(e.original.storeDown)return`?`;let t=e.original.rejectionsPerDay;return o(Z,{value:t,class:t>0?`text-destructive`:void 0})}}}function lt(e){return{id:`costMonthProj`,header:`cost/month (proj.)`,meta:{align:`right`},accessorFn:t=>Q(t.costPerMonthMicroUsd,e)??0,cell:({row:t})=>{if(t.original.storeDown)return`?`;let n=Q(t.original.costPerMonthMicroUsd,e);if(n===null)return o(`span`,{class:`text-muted-foreground`},`not enough data yet`);let r=Te(n,t.original.limits?.costPerMonthUSD);return o(`span`,{class:r.willExceed?`text-destructive`:void 0,title:r.willExceed?`Projected to exceed the configured cost/month limit`:void 0},q(n))}}}function ut(e){return{id:`source`,header:`Source`,accessorFn:t=>e(t)??``,cell:({row:t})=>o(`span`,{class:`text-muted-foreground`},e(t.original)??`—`)}}function dt(e){return{id:`lastSeen`,header:`Last seen`,accessorFn:e=>e.lastSeen??0,cell:({row:t})=>st(t.original.lastSeen,e)}}function ft(e,t,n,r=new Date,i){let a=De(r),s=[{id:`id`,header:e,accessorFn:e=>e.id,cell:({row:e})=>o(Re,{class:`font-medium`,label:e.original.id,kind:`user`,id:e.original.id})},{id:`secondary`,header:t,accessorFn:n,sortingFn:`alphanumeric`,cell:({row:e})=>o(`span`,{class:`text-muted-foreground`},n(e.original))}];return i&&s.push(ut(i)),s.push({id:`limits`,header:`Limits`,accessorFn:e=>Y(e.limits),cell:({row:e})=>o(`span`,{class:`text-muted-foreground`},Y(e.original.limits))},$(`reqMin`,`req/min`,e=>e.requestsPerMinute,String,!0,`reqMin`),$(`reqDay`,`req/day`,e=>e.requestsPerDay,String,!0,`reqDay`),ct(),$(`tokInDay`,`tokIn/day`,e=>e.tokensInPerDay,String,!0,`tokDay`),$(`tokOutDay`,`tokOut/day`,e=>e.tokensOutPerDay,String,!0,`tokDay`),$(`tokInMonth`,`tokIn/month`,e=>e.tokensInPerMonth,String,!0,`tokMonth`),$(`tokOutMonth`,`tokOut/month`,e=>e.tokensOutPerMonth,String,!0,`tokMonth`),$(`costDay`,`cost/day`,e=>e.costPerDayMicroUsd,q,!1,`costDay`),$(`costMonth`,`cost/month`,e=>e.costPerMonthMicroUsd,q,!1,`costMonth`),lt(a),dt(r)),s}var pt=m({__name:`UsageTable`,props:{idLabel:{},entries:{},secondaryColumnLabel:{},secondaryValue:{type:Function},emptyMessage:{},now:{},sorting:{},sourceValue:{type:Function}},emits:[`update:sorting`],setup(e,{emit:t}){let n=e,r=t,i=S(()=>ft(n.idLabel,n.secondaryColumnLabel,n.secondaryValue,n.now,n.sourceValue));return(t,n)=>(T(),D(xe,{columns:i.value,data:e.entries,"empty-message":e.emptyMessage,"row-class":e=>e.storeDown?`bg-destructive/10`:void 0,sorting:e.sorting,"onUpdate:sorting":n[0]||=e=>r(`update:sorting`,e)},null,8,[`columns`,`data`,`empty-message`,`row-class`,`sorting`]))}}),mt={users:`Group`,groups:`Members`};function ht(e){return(e/Ee).toFixed(6)}function gt(e,t,n,r=new Date){let i=De(r),a=[`Name`,mt[t],`Limits`,`req/min`,`req/day`,`rejected/day`,`tokIn/day`,`tokOut/day`,`tokIn/month`,`tokOut/month`,`cost/day (USD)`,`cost/month (USD)`,`cost/month (proj., USD)`,`last seen (unix seconds)`],o=e.map(e=>{let t=e.storeDown,r=t?null:Q(e.costPerMonthMicroUsd,i);return[e.id,n(e),Y(e.limits),t?`?`:e.requestsPerMinute,t?`?`:e.requestsPerDay,t?`?`:e.rejectionsPerDay,t?`?`:e.tokensInPerDay,t?`?`:e.tokensOutPerDay,t?`?`:e.tokensInPerMonth,t?`?`:e.tokensOutPerMonth,t?`?`:ht(e.costPerDayMicroUsd),t?`?`:ht(e.costPerMonthMicroUsd),t?`?`:r===null?`not enough data yet`:ht(r),e.lastSeen??0]});return je(a,o)}function _t(e,t){return e.id.toLowerCase().includes(t)}function vt(e,t){return e.id.toLowerCase().includes(t)}function yt(e,t){return t.filter(t=>(t.groups??[t.groupName]).includes(e.id))}function bt(e,t,n){return yt(e,t).filter(e=>_t(e,n))}function xt(e,t,n){return vt(e,n)||bt(e,t,n).length>0}var St={class:`flex flex-col gap-6`},Ct={class:`text-lg font-semibold tabular-nums`},wt={class:`text-lg font-semibold tabular-nums`},Tt={class:`text-lg font-semibold tabular-nums`},Et={class:`text-lg font-semibold tabular-nums`},Dt={class:`flex items-start justify-between gap-2`},Ot={key:0,class:`mb-3 flex flex-wrap gap-x-4 gap-y-1 text-xs font-medium text-muted-foreground`},kt={class:`flex items-center gap-2`},At={class:`shrink-0 py-2.5 font-medium`},jt={class:`sr-only`},Mt={class:`flex flex-1 flex-wrap items-center gap-x-4 gap-y-1 pr-2 text-left`},Nt={class:`text-xs text-muted-foreground tabular-nums`},Pt={class:`text-xs text-muted-foreground tabular-nums`},Ft={class:`text-xs text-muted-foreground tabular-nums`},It={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},Lt={key:0,class:`flex flex-wrap gap-1.5`},Rt={key:1,class:`text-muted-foreground`},zt={key:0,class:`flex flex-wrap gap-1.5`},Bt={key:1,class:`text-muted-foreground`},Vt={key:0,class:`flex flex-wrap gap-1.5`},Ht={key:1,class:`text-muted-foreground`},Ut={key:0,class:`flex flex-wrap gap-1.5`},Wt={key:1,class:`text-muted-foreground`},Gt={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},Kt={class:`tabular-nums`},qt={class:`tabular-nums`},Jt={class:`tabular-nums`},Yt={class:`tabular-nums`},Xt={class:`tabular-nums`},Zt={class:`tabular-nums`},Qt=[`title`],$t={key:0,class:`mb-3 flex flex-wrap items-center gap-x-4 gap-y-1.5`},en={key:3,class:`py-6 text-center text-sm text-muted-foreground`},tn={class:`flex items-start justify-between gap-2`},nn=`Glob pattern — matches like a shell wildcard (*, ?, [...])`,rn=m({__name:`ConsumerDirectory`,setup(a){let o=te(),d=le(),f=ne(),m=S(()=>o.usage),b=S(()=>W({loading:!o.lastUpdated,hasData:m.value!==null,error:o.error}));p(()=>{d.ensureConsumers()});let{now:w,start:re,stop:A}=Ae();p(re),ee(A);let oe=S(()=>{let e={};for(let t of o.overview?.groups??[])e[t.name]=t.memberCount;return e});function R(e){return(e.groups??(e.groupName===void 0?[]:[e.groupName])).join(`, `)}function z(e){let t=oe.value[e.id];return t===void 0?``:String(t)}function se(e){return d.data?.users.find(t=>t.name===e.id)?.source}let ce=S({get:()=>f.params.q??``,set:e=>f.goTo(`consumers`,{...f.params,q:e})}),{query:V,normalized:H,hasQuery:K}=Ie(ce),ue=S(()=>{let e=m.value?.groups??[];if(!K.value)return e;let t=m.value?.users??[];return e.filter(e=>xt(e,t,H.value))}),X=S(()=>K.value?ue.value.filter(e=>!vt(e,H.value)).map(e=>e.id):[]);function pe(e){let t=m.value?.users??[];return!K.value||vt(e,H.value)?yt(e,t):bt(e,t,H.value)}let me=S(()=>m.value?.groups.length?K.value?`no groups match "${V.value}"`:`none`:`none configured`),ge=S(()=>(m.value?.groups.length??0)===0&&!K.value),be=S(()=>{let e=m.value?.users??[];if(!K.value)return e;let t=m.value?.groups??[],n=new Set(t.filter(e=>vt(e,H.value)).map(e=>e.id));return e.filter(e=>_t(e,H.value)||(e.groups??[e.groupName]).some(e=>e!==void 0&&n.has(e)))}),xe=S(()=>m.value?.users.length?K.value?`no users match "${V.value}"`:`none`:`none configured`),Se=S(()=>ft(`Name`,`Members`,z,w.value)),we=E([]),Ee=ye({get data(){return ue.value},get columns(){return Se.value},getCoreRowModel:he(),getSortedRowModel:fe(),onSortingChange:e=>Ue(e,we),state:{get sorting(){return we.value}}}),ke=S(()=>Ee.getRowModel().rows),je=new Set([`id`,`secondary`,`reqDay`,`costDay`]),Ne=S(()=>Ee.getHeaderGroups()[0].headers.filter(e=>je.has(e.column.id))),Re=x({manuallyExpanded:new Set,manuallyCollapsed:new Set}),ze=S(()=>N(Re,K.value,X.value));function Be(e){F(Re,e,ze.value.has(e))}let Ve=S({get:()=>Array.from(ze.value),set:e=>{let t=new Set(e);for(let e of ze.value)t.has(e)||Be(e);for(let e of t)ze.value.has(e)||Be(e)}});e(V,e=>{e.trim()===``&&L(Re)});function He(e){return/[*?[]/.test(e)}function We(e){return e.id.startsWith(`cost`)?`${q(e.used)} / ${q(e.limit)}`:`${G(e.used)} / ${G(e.limit)}`}function Ge(e,t){let n=De(t),r=Q(e.costPerMonthMicroUsd,n);return r===null?{text:`not enough data yet`,willExceed:!1}:{text:q(r),willExceed:Te(r,e.limits?.costPerMonthUSD).willExceed}}let Ke=S(()=>ft(`Name`,`Group`,R,w.value,se)),qe=E([]),Je=ye({get data(){return be.value},get columns(){return Ke.value},getCoreRowModel:he(),getSortedRowModel:fe(),onSortingChange:e=>Ue(e,qe),state:{get sorting(){return qe.value}}});function Ye(){return gt(Je.getRowModel().rows.map(e=>e.original),`users`,R,w.value)}function Xe(){return gt(ke.value.map(e=>e.original),`groups`,z,w.value)}return(e,a)=>(T(),g(`div`,St,[y(Fe,{modelValue:v(V),"onUpdate:modelValue":a[0]||=e=>s(V)?V.value=e:null,placeholder:`Filter users or groups`,class:`max-w-sm`},null,8,[`modelValue`]),m.value?(T(),D(v(u),{key:0},{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(c),null,{default:r(()=>[...a[4]||=[C(`Total`,-1)]]),_:1}),y(v(B),null,{default:r(()=>[...a[5]||=[C(`Usage summed across every user and group combined.`,-1)]]),_:1})]),_:1}),y(v(k),{class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-5`},{default:r(()=>[h(`div`,null,[a[6]||=h(`p`,{class:`text-muted-foreground`},`Requests/day`,-1),h(`p`,Ct,[y(Z,{value:m.value.total.requestsPerDay},null,8,[`value`])])]),h(`div`,null,[a[7]||=h(`p`,{class:`text-muted-foreground`},`Rejected/day`,-1),h(`p`,{class:j([`text-lg font-semibold tabular-nums`,m.value.total.rejectionsPerDay>0?`text-destructive`:void 0])},[y(Z,{value:m.value.total.rejectionsPerDay},null,8,[`value`])],2)]),h(`div`,null,[a[8]||=h(`p`,{class:`text-muted-foreground`},`Tokens in/day`,-1),h(`p`,wt,[y(Z,{value:m.value.total.tokensInPerDay},null,8,[`value`])])]),h(`div`,null,[a[9]||=h(`p`,{class:`text-muted-foreground`},`Tokens out/day`,-1),h(`p`,Tt,[y(Z,{value:m.value.total.tokensOutPerDay},null,8,[`value`])])]),h(`div`,null,[a[10]||=h(`p`,{class:`text-muted-foreground`},`Cost/day`,-1),h(`p`,Et,l(v(q)(m.value.total.costPerDayMicroUsd)),1)])]),_:1})]),_:1})):O(``,!0),m.value?(T(),D(Pe,{key:1,"mtd-micros":m.value.total.costPerMonthMicroUsd,limits:m.value.total.limits,now:v(w)},null,8,[`mtd-micros`,`limits`,`now`])):O(``,!0),y(v(u),null,{default:r(()=>[y(v(t),null,{default:r(()=>[h(`div`,Dt,[h(`div`,null,[y(v(c),null,{default:r(()=>[...a[11]||=[C(`Groups`,-1)]]),_:1}),y(v(B),null,{default:r(()=>[...a[12]||=[C(`Expand a group to see its member users' own usage.`,-1)]]),_:1})]),y(Me,{filename:`consumers-groups.csv`,build:Xe})])]),_:1}),y(v(k),null,{default:r(()=>[b.value===`skeleton`?(T(),D(Le,{key:0,rows:3})):b.value===`error`?(T(),D(U,{key:1,message:v(o).error,"on-retry":v(o).refresh},null,8,[`message`,`on-retry`])):(T(),g(i,{key:2},[ke.value.length?(T(),g(`div`,Ot,[(T(!0),g(i,null,_(Ne.value,e=>(T(),D(_e,{key:e.id,header:e},null,8,[`header`]))),128))])):O(``,!0),ke.value.length?(T(),D(v(I),{key:1,modelValue:Ve.value,"onUpdate:modelValue":a[1]||=e=>Ve.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:r(()=>[(T(!0),g(i,null,_(ke.value,e=>(T(),D(v(ie),{key:e.original.id,value:e.original.id},{default:r(()=>[h(`div`,kt,[h(`span`,At,l(e.original.id),1),y(v(M),{"header-class":`flex-1`},{default:r(()=>[h(`span`,jt,`Group `+l(e.original.id)+` details`,1),h(`span`,Mt,[h(`span`,Nt,l(z(e.original)||`0`)+` members`,1),h(`span`,Pt,[e.original.storeDown?(T(),g(i,{key:0},[C(`?`)],64)):(T(),D(Z,{key:1,value:e.original.requestsPerDay},null,8,[`value`])),a[13]||=C(` req/day `,-1)]),h(`span`,Ft,l(e.original.storeDown?`?`:v(q)(e.original.costPerDayMicroUsd))+`/day `,1)])]),_:2},1024)]),y(v(P),null,{default:r(()=>[h(`dl`,It,[h(`div`,null,[h(`dt`,{class:`text-xs text-muted-foreground`,title:nn},`Providers`),h(`dd`,null,[e.original.providers?.length?(T(),g(`div`,Lt,[(T(!0),g(i,null,_(e.original.providers,e=>(T(),D(v(J),{key:e,as:`span`,variant:`secondary`,class:`max-w-full truncate font-mono font-normal`,title:e},{default:r(()=>[C(l(e),1)]),_:2},1032,[`title`]))),128))])):(T(),g(`span`,Rt,`All providers`))])]),h(`div`,null,[h(`dt`,{class:`text-xs text-muted-foreground`,title:nn},`Models`),h(`dd`,null,[e.original.models?.length?(T(),g(`div`,zt,[(T(!0),g(i,null,_(e.original.models,e=>(T(),g(i,{key:e},[He(e)?(T(),D(v(J),{key:1,as:`span`,variant:`secondary`,class:`max-w-full truncate font-mono font-normal`,title:e},{default:r(()=>[C(l(e),1)]),_:2},1032,[`title`])):(T(),D(ae,{key:0,id:e},null,8,[`id`]))],64))),128))])):(T(),g(`span`,Bt,`All models`))])]),h(`div`,null,[h(`dt`,{class:`text-xs text-muted-foreground`,title:nn},`MCP servers`),h(`dd`,null,[e.original.mcpServers?.length?(T(),g(`div`,Vt,[(T(!0),g(i,null,_(e.original.mcpServers,e=>(T(),D(v(J),{key:e,as:`span`,variant:`secondary`,class:`max-w-full truncate font-mono font-normal`,title:e},{default:r(()=>[C(l(e),1)]),_:2},1032,[`title`]))),128))])):(T(),g(`span`,Ht,`All MCP servers`))])]),h(`div`,null,[h(`dt`,{class:`text-xs text-muted-foreground`,title:nn},`Agents`),h(`dd`,null,[e.original.agents?.length?(T(),g(`div`,Ut,[(T(!0),g(i,null,_(e.original.agents,e=>(T(),D(v(J),{key:e,as:`span`,variant:`secondary`,class:`max-w-full truncate font-mono font-normal`,title:e},{default:r(()=>[C(l(e),1)]),_:2},1032,[`title`]))),128))])):(T(),g(`span`,Wt,`All agents`))])])]),h(`dl`,Gt,[h(`div`,null,[a[14]||=h(`dt`,{class:`text-xs text-muted-foreground`},`Limits`,-1),h(`dd`,null,l(v(Y)(e.original.limits)),1)]),h(`div`,null,[a[15]||=h(`dt`,{class:`text-xs text-muted-foreground`},`req/min`,-1),h(`dd`,Kt,[e.original.storeDown?(T(),g(i,{key:0},[C(`?`)],64)):(T(),D(Z,{key:1,value:e.original.requestsPerMinute},null,8,[`value`]))])]),h(`div`,null,[a[16]||=h(`dt`,{class:`text-xs text-muted-foreground`},`rejected/day`,-1),h(`dd`,{class:j([`tabular-nums`,!e.original.storeDown&&e.original.rejectionsPerDay>0?`text-destructive`:void 0])},[e.original.storeDown?(T(),g(i,{key:0},[C(`?`)],64)):(T(),D(Z,{key:1,value:e.original.rejectionsPerDay},null,8,[`value`]))],2)]),h(`div`,null,[a[17]||=h(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/day`,-1),h(`dd`,qt,[e.original.storeDown?(T(),g(i,{key:0},[C(`?`)],64)):(T(),D(Z,{key:1,value:e.original.tokensInPerDay},null,8,[`value`]))])]),h(`div`,null,[a[18]||=h(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/day`,-1),h(`dd`,Jt,[e.original.storeDown?(T(),g(i,{key:0},[C(`?`)],64)):(T(),D(Z,{key:1,value:e.original.tokensOutPerDay},null,8,[`value`]))])]),h(`div`,null,[a[19]||=h(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/month`,-1),h(`dd`,Yt,[e.original.storeDown?(T(),g(i,{key:0},[C(`?`)],64)):(T(),D(Z,{key:1,value:e.original.tokensInPerMonth},null,8,[`value`]))])]),h(`div`,null,[a[20]||=h(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/month`,-1),h(`dd`,Xt,[e.original.storeDown?(T(),g(i,{key:0},[C(`?`)],64)):(T(),D(Z,{key:1,value:e.original.tokensOutPerMonth},null,8,[`value`]))])]),h(`div`,null,[a[21]||=h(`dt`,{class:`text-xs text-muted-foreground`},`cost/month`,-1),h(`dd`,Zt,l(e.original.storeDown?`?`:v(q)(e.original.costPerMonthMicroUsd)),1)]),h(`div`,null,[a[22]||=h(`dt`,{class:`text-xs text-muted-foreground`},`cost/month (proj.)`,-1),h(`dd`,{class:j([`tabular-nums`,!e.original.storeDown&&Ge(e.original,v(w)).willExceed?`text-destructive`:void 0]),title:!e.original.storeDown&&Ge(e.original,v(w)).willExceed?`Projected to exceed the configured cost/month limit`:void 0},l(e.original.storeDown?`?`:Ge(e.original,v(w)).text),11,Qt)])]),v(Oe)(e.original).length?(T(),g(`div`,$t,[(T(!0),g(i,null,_(v(Oe)(e.original),e=>(T(),g(`span`,{key:e.id,class:`inline-flex items-center gap-1.5 text-xs text-muted-foreground`},[C(l(v(Ce)[e.id])+` `,1),y(tt,{ratio:e.ratio,label:v(Ce)[e.id],"value-text":We(e)},null,8,[`ratio`,`label`,`value-text`])]))),128))])):O(``,!0),a[23]||=h(`p`,{class:`mb-1.5 text-xs font-medium text-muted-foreground`},`Members`,-1),y(pt,{"id-label":`Name`,"secondary-column-label":`Group`,entries:pe(e.original),"secondary-value":R,now:v(w),"source-value":se},null,8,[`entries`,`now`])]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):ge.value?(T(),D(de,{key:2,title:`No groups configured.`,description:`Grant a group access from the Config page's change helper.`},{default:r(()=>[y(v(n),{type:`button`,variant:`outline`,size:`sm`,onClick:a[2]||=e=>v(f).goTo(`config`,{helper:`grant`})},{default:r(()=>[...a[24]||=[C(`Open change helper`,-1)]]),_:1})]),_:1})):(T(),g(`p`,en,l(me.value),1))],64))]),_:1})]),_:1}),y(v(u),null,{default:r(()=>[y(v(t),null,{default:r(()=>[h(`div`,tn,[h(`div`,null,[y(v(c),null,{default:r(()=>[...a[25]||=[C(`Users`,-1)]]),_:1}),v(d).data?.usersFile?(T(),D(v(B),{key:0},{default:r(()=>[C(`File-backed users load from `+l(v(d).data.usersFile)+`.`,1)]),_:1})):O(``,!0)]),y(Me,{filename:`consumers-users.csv`,build:Ye})])]),_:1}),y(v(k),null,{default:r(()=>[b.value===`skeleton`?(T(),D(ve,{key:0,rows:5,cols:5})):b.value===`error`?(T(),D(U,{key:1,message:v(o).error,"on-retry":v(o).refresh},null,8,[`message`,`on-retry`])):(T(),D(pt,{key:2,"id-label":`Name`,"secondary-column-label":`Group`,entries:be.value,"secondary-value":R,"empty-message":xe.value,now:v(w),"source-value":se,sorting:qe.value,"onUpdate:sorting":a[3]||=e=>qe.value=e},null,8,[`entries`,`empty-message`,`now`,`sorting`]))]),_:1})]),_:1})]))}}),an={class:`flex flex-col gap-4`},on={class:`flex items-center gap-2`},sn={class:`flex flex-wrap items-center gap-2`},cn={class:`text-lg font-semibold tabular-nums`},ln={class:`text-lg font-semibold tabular-nums`},un={class:`text-lg font-semibold tabular-nums`},dn={class:`text-sm`},fn={key:0,class:`flex flex-col gap-2 text-sm`},pn={class:`flex flex-wrap items-center gap-2`},mn={class:`text-muted-foreground`},hn={class:`text-muted-foreground`},gn={key:1,class:`py-6 text-center text-sm text-muted-foreground`},_n={class:`flex flex-wrap gap-1.5`},vn={class:`flex flex-wrap gap-1.5`},yn=m({__name:`UserDetail`,props:{userId:{}},emits:[`close`],setup(o,{emit:s}){let d=o,f=s,m=te(),b=le(),x=He(),w=H(),E=ne(),{now:A,start:j,stop:ie}=Ae();p(j),ee(ie);let M=S(()=>m.usage?.users.find(e=>e.id===d.userId)),N=S(()=>b.data?.users.find(e=>e.name===d.userId)),P=S(()=>m.overview?.features.userModelStats??!1);function F(){return b.fetchUserDetail(d.userId,w.window,w.span,P.value)}p(()=>{F(),x.refresh()}),e([()=>d.userId,()=>w.range,P],F);let I=S(()=>b.detail[d.userId]),L=S(()=>(I.value?.reqSeries?.buckets??[]).map(e=>ue(e,I.value?.reqSeries?.window??w.window))),oe=S(()=>[{label:`Requests`,data:I.value?.reqSeries?.series[0]?.points??[],color:`--chart-requests`}]),R=S(()=>(I.value?.costSeries?.buckets??[]).map(e=>ue(e,I.value?.costSeries?.window??w.window))),z=S(()=>[{label:`Cost`,data:(I.value?.costSeries?.series[0]?.points??[]).map(e=>e),color:`--chart-cost`}]),fe=S(()=>W({loading:I.value?.loading??!1,hasData:I.value?.reqSeries!=null,error:I.value?.reqError??``})),he=S(()=>W({loading:I.value?.loading??!1,hasData:I.value?.costSeries!=null,error:I.value?.costError??``})),_e=S(()=>!P.value||I.value?.modelTotalsUnavailable===!0),ye=S(()=>[...I.value?.modelTotals?.rows??[]].sort((e,t)=>(t.values.cost??t.values.req??0)-(e.values.cost??e.values.req??0))),xe=S(()=>W({loading:I.value?.loading??!1,hasData:I.value?.modelTotals!=null,error:I.value?.modelError??``})),we=S(()=>x.events.filter(e=>e.user===d.userId).slice(0,10)),Q=S(()=>M.value?Oe(M.value):[]);function Te(e,t,n){return e.startsWith(`cost`)?`${q(t)} / ${q(n)}`:`${G(t)} / ${G(n)}`}let Ee=S(()=>{let e=M.value?.limits?.costPerMonthUSD;return!M.value||!e?null:Ne(M.value.costPerMonthMicroUsd,Math.round(e*1e6),A.value)});return(e,s)=>{let d=re(`FontAwesomeIcon`);return T(),g(`div`,an,[h(`div`,on,[y(v(n),{type:`button`,variant:`ghost`,size:`sm`,onClick:s[0]||=e=>f(`close`)},{default:r(()=>[y(d,{icon:v(a),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`]),s[2]||=C(` Back to directory `,-1)]),_:1})]),y(v(u),null,{default:r(()=>[y(v(t),null,{default:r(()=>[h(`div`,sn,[y(v(c),{class:`min-w-0 break-all font-mono`},{default:r(()=>[C(l(o.userId),1)]),_:1}),N.value?.admin?(T(),D(v(J),{key:0,variant:`destructive`},{default:r(()=>[...s[3]||=[C(`admin`,-1)]]),_:1})):O(``,!0),N.value?.source?(T(),D(v(J),{key:1,variant:`secondary`},{default:r(()=>[C(l(N.value.source),1)]),_:1})):O(``,!0)]),M.value?.groups?.length||M.value?.groupName?(T(),D(v(B),{key:0},{default:r(()=>[C(` Member of `+l((M.value?.groups??[M.value?.groupName]).filter(Boolean).join(`, `)),1)]),_:1})):O(``,!0)]),_:1}),M.value?(T(),D(v(k),{key:1,class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-4`},{default:r(()=>[h(`div`,null,[s[5]||=h(`p`,{class:`text-muted-foreground`},`Requests/day`,-1),h(`p`,cn,[y(Z,{value:M.value.requestsPerDay},null,8,[`value`])])]),h(`div`,null,[s[6]||=h(`p`,{class:`text-muted-foreground`},`Cost/day`,-1),h(`p`,ln,l(v(q)(M.value.costPerDayMicroUsd)),1)]),h(`div`,null,[s[7]||=h(`p`,{class:`text-muted-foreground`},`Cost/month`,-1),h(`p`,un,l(v(q)(M.value.costPerMonthMicroUsd)),1)]),h(`div`,null,[s[8]||=h(`p`,{class:`text-muted-foreground`},`Limits`,-1),h(`p`,dn,l(v(Y)(M.value.limits)),1)])]),_:1})):(T(),D(v(k),{key:0,class:`text-sm text-muted-foreground`},{default:r(()=>[...s[4]||=[C(` No usage scope for this user yet — it appears after their first request. `,-1)]]),_:1}))]),_:1}),M.value&&Q.value.length?(T(),D(v(u),{key:0},{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(c),null,{default:r(()=>[...s[9]||=[C(`Headroom`,-1)]]),_:1}),Ee.value?(T(),D(v(B),{key:0},{default:r(()=>[C(`At the current pace, cost/month runs out around `+l(v(K)(Ee.value.toISOString()))+`.`,1)]),_:1})):O(``,!0)]),_:1}),y(v(k),{class:`flex flex-wrap items-center gap-x-4 gap-y-1.5`},{default:r(()=>[(T(!0),g(i,null,_(Q.value,e=>(T(),g(`span`,{key:e.id,class:`inline-flex items-center gap-1.5 text-xs text-muted-foreground`},[C(l(v(Ce)[e.id])+` `,1),y(tt,{ratio:e.ratio,label:v(Ce)[e.id],"value-text":Te(e.id,e.used,e.limit)},null,8,[`ratio`,`label`,`value-text`])]))),128))]),_:1})]),_:1})):O(``,!0),y(v(u),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(c),null,{default:r(()=>[...s[10]||=[C(`Requests over time`,-1)]]),_:1})]),_:1}),y(v(k),null,{default:r(()=>[fe.value===`skeleton`?(T(),D(Be,{key:0})):fe.value===`error`?(T(),D(U,{key:1,message:I.value?.reqError??``,"on-retry":F},null,8,[`message`])):(T(),D(Ve,{key:2,labels:L.value,datasets:oe.value,ariaLabel:`Requests over time for ${o.userId}`},null,8,[`labels`,`datasets`,`ariaLabel`]))]),_:1})]),_:1}),y(v(u),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(c),null,{default:r(()=>[...s[11]||=[C(`Cost over time`,-1)]]),_:1})]),_:1}),y(v(k),null,{default:r(()=>[he.value===`skeleton`?(T(),D(Be,{key:0})):he.value===`error`?(T(),D(U,{key:1,message:I.value?.costError??``,"on-retry":F},null,8,[`message`])):(T(),D(Ve,{key:2,labels:R.value,datasets:z.value,"value-formatter":v(q),ariaLabel:`Cost over time for ${o.userId}`},null,8,[`labels`,`datasets`,`value-formatter`,`ariaLabel`]))]),_:1})]),_:1}),y(v(u),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(c),null,{default:r(()=>[...s[12]||=[C(`Models used`,-1)]]),_:1})]),_:1}),y(v(k),{class:`flex flex-col gap-3`},{default:r(()=>[y(ze,{window:v(w).window,span:v(w).span},null,8,[`window`,`span`]),_e.value?(T(),D(v(se),{key:0,variant:`warn`},{default:r(()=>[y(v(V),null,{default:r(()=>[...s[13]||=[C(`Per-user-model statistics are off`,-1)]]),_:1}),y(v(ce),{class:`flex flex-wrap items-center gap-2`},{default:r(()=>[s[15]||=h(`span`,null,[C(`Enable `),h(`code`,{class:`font-mono text-xs`},`admin.stats.userModel`),C(` in the middleware config to see a per-model breakdown for this user.`)],-1),y(v(n),{type:`button`,variant:`outline`,size:`sm`,onClick:s[1]||=e=>v(E).goTo(`config`)},{default:r(()=>[...s[14]||=[C(`Open Config`,-1)]]),_:1})]),_:1})]),_:1})):xe.value===`skeleton`?(T(),D(ve,{key:1,rows:3,cols:3})):xe.value===`error`?(T(),D(U,{key:2,message:I.value?.modelError??``,"on-retry":F},null,8,[`message`])):ye.value.length?(T(),D(v(me),{key:4},{default:r(()=>[y(v(be),null,{default:r(()=>[y(v(ge),null,{default:r(()=>[y(v(X),null,{default:r(()=>[...s[16]||=[C(`Model`,-1)]]),_:1}),y(v(X),{class:`text-right`},{default:r(()=>[...s[17]||=[C(`Requests`,-1)]]),_:1}),y(v(X),{class:`text-right`},{default:r(()=>[...s[18]||=[C(`Cost`,-1)]]),_:1})]),_:1})]),_:1}),y(v(pe),null,{default:r(()=>[(T(!0),g(i,null,_(ye.value,e=>(T(),D(v(ge),{key:e.id},{default:r(()=>[y(v(Se),null,{default:r(()=>[y(ae,{id:e.id},null,8,[`id`])]),_:2},1024),y(v(Se),{class:`text-right tabular-nums`},{default:r(()=>[y(Z,{value:e.values.req??0},null,8,[`value`])]),_:2},1024),y(v(Se),{class:`text-right tabular-nums`},{default:r(()=>[C(l(v(q)(e.values.cost??0)),1)]),_:2},1024)]),_:2},1024))),128))]),_:1})]),_:1})):(T(),D(de,{key:3,title:`No traffic in this range.`},{default:r(()=>[y(ke)]),_:1}))]),_:1})]),_:1}),y(v(u),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(c),null,{default:r(()=>[...s[19]||=[C(`Recent errors`,-1)]]),_:1})]),_:1}),y(v(k),null,{default:r(()=>[we.value.length?(T(),g(`ul`,fn,[(T(!0),g(i,null,_(we.value,(e,t)=>(T(),g(`li`,{key:t,class:`border-b pb-2 last:border-0 last:pb-0`},[h(`p`,pn,[y(v(J),{variant:`secondary`},{default:r(()=>[C(l(e.kind),1)]),_:2},1024),h(`span`,mn,l(v(K)(e.time)),1)]),h(`p`,hn,l(e.message),1)]))),128))])):(T(),g(`p`,gn,`none in the current event window`))]),_:1})]),_:1}),N.value?.providers?.length||N.value?.models?.length?(T(),D(v(u),{key:1},{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(c),null,{default:r(()=>[...s[20]||=[C(`Personal grant`,-1)]]),_:1}),y(v(B),null,{default:r(()=>[...s[21]||=[C(`Access this user has beyond their group's own.`,-1)]]),_:1})]),_:1}),y(v(k),{class:`grid grid-cols-1 gap-4 sm:grid-cols-2`},{default:r(()=>[h(`div`,null,[s[22]||=h(`p`,{class:`mb-1.5 text-xs text-muted-foreground`},`Providers`,-1),h(`div`,_n,[(T(!0),g(i,null,_(N.value?.providers??[],e=>(T(),D(v(J),{key:e,as:`span`,variant:`secondary`,class:`max-w-full truncate font-mono font-normal`,title:e},{default:r(()=>[C(l(e),1)]),_:2},1032,[`title`]))),128))])]),h(`div`,null,[s[23]||=h(`p`,{class:`mb-1.5 text-xs text-muted-foreground`},`Models`,-1),h(`div`,vn,[(T(!0),g(i,null,_(N.value?.models??[],e=>(T(),D(ae,{key:e,id:e},null,8,[`id`]))),128))])])]),_:1})]),_:1})):O(``,!0)])}}}),bn={key:1,class:`flex flex-col gap-4`},xn=m({__name:`ConsumersPage`,setup(e){let t=ne(),n=S(()=>t.params.user),i=S(()=>t.params.view===`matrix`?`matrix`:`directory`),a=S(()=>Je(t.params.matrix));function o(e){if(e!==`directory`&&e!==`matrix`)return;let{user:n,...r}=t.params;t.goTo(`consumers`,{...r,view:e})}function s(e){let{user:n,matrix:r,...i}=t.params;if(e===`models`){t.goTo(`consumers`,{...i,view:`matrix`});return}t.goTo(`consumers`,{...i,view:`matrix`,matrix:e})}function c(){let{user:e,...n}=t.params;t.goTo(`consumers`,n)}return(e,t)=>n.value?(T(),D(yn,{key:0,"user-id":n.value,onClose:c},null,8,[`user-id`])):(T(),g(`div`,bn,[y(v(R),{"model-value":i.value,"onUpdate:modelValue":o},{default:r(()=>[y(v(oe),null,{default:r(()=>[y(v(z),{value:`directory`},{default:r(()=>[...t[0]||=[C(`Directory`,-1)]]),_:1}),y(v(z),{value:`matrix`},{default:r(()=>[...t[1]||=[C(`Access matrix`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`]),i.value===`directory`?(T(),D(rn,{key:0})):(T(),D($e,{key:1,kind:a.value,"onUpdate:kind":s},null,8,[`kind`]))]))}});export{xn as default};",
		),
	},
	"DataTable-CQxRVDSY.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{Ar as e,Fr as t,Hn as n,Jt as r,On as i,Qr as a,Si as o,V as s,W as c,_n as l,an as u,cn as d,cr as f,dt as p,ft as m,gi as h,hn as g,in as _,jr as ee,li as te,lr as v,mn as ne,nr as y,oi as re,on as b,pt as ie,sn as x,t as ae,ur as oe,yi as S}from"./Skeleton-B0ziB6Od.js";var se={"data-slot":`table-container`,class:`relative w-full overflow-x-auto`},ce=l({__name:`Table`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(y(),d(`div`,se,[u(`table`,{"data-slot":`table`,class:S(h(c)(`w-full caption-bottom text-sm`,t.class))},[v(e.$slots,`default`)],2)]))}}),le=l({__name:`TableBody`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(y(),d(`tbody`,{"data-slot":`table-body`,class:S(h(c)(`[&_tr:last-child]:border-0`,t.class))},[v(e.$slots,`default`)],2))}}),C=l({__name:`TableCell`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(y(),d(`td`,{"data-slot":`table-cell`,class:S(h(c)(`p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[v(e.$slots,`default`)],2))}}),w=l({__name:`TableRow`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(y(),d(`tr`,{"data-slot":`table-row`,class:S(h(c)(`hover:bg-muted/50 data-[state=selected]:bg-muted border-b transition-colors has-aria-expanded:bg-muted/50`,t.class))},[v(e.$slots,`default`)],2))}}),ue={class:`flex items-center justify-center py-10`},de=l({__name:`TableEmpty`,props:{class:{type:[Boolean,null,String,Object,Array]},colspan:{default:1}},setup(e){let r=e,i=s(r,`class`);return(e,a)=>(y(),b(w,null,{default:t(()=>[g(C,n({class:h(c)(`p-4 whitespace-nowrap align-middle text-sm text-foreground`,r.class)},h(i)),{default:t(()=>[u(`div`,ue,[v(e.$slots,`default`)])]),_:3},16,[`class`])]),_:3}))}}),T=l({__name:`TableHead`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(y(),d(`th`,{"data-slot":`table-head`,class:S(h(c)(`text-foreground h-10 px-2 text-left align-middle font-medium whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[v(e.$slots,`default`)],2))}}),E=l({__name:`TableHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(y(),d(`thead`,{"data-slot":`table-header`,class:S(h(c)(`[&_tr]:border-b`,t.class))},[v(e.$slots,`default`)],2))}}),fe=l({__name:`SkeletonTable`,props:{rows:{default:5},cols:{default:4}},setup(e){return(n,i)=>(y(),b(h(ce),null,{default:t(()=>[g(h(E),null,{default:t(()=>[g(h(w),null,{default:t(()=>[(y(!0),d(r,null,f(e.cols,e=>(y(),b(h(T),{key:e},{default:t(()=>[g(h(ae),{class:`h-4 w-16`})]),_:1}))),128))]),_:1})]),_:1}),g(h(le),null,{default:t(()=>[(y(!0),d(r,null,f(e.rows,n=>(y(),b(h(w),{key:n},{default:t(()=>[(y(!0),d(r,null,f(e.cols,e=>(y(),b(h(C),{key:e},{default:t(()=>[g(h(ae),{class:`h-4 w-full max-w-32`})]),_:1}))),128))]),_:1}))),128))]),_:1})]),_:1}))}});function D(e,t){return typeof e==`function`?e(t):e}function O(e,t){return n=>{t.setState(t=>({...t,[e]:D(n,t[e])}))}}function k(e){return e instanceof Function}function pe(e){return Array.isArray(e)&&e.every(e=>typeof e==`number`)}function me(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 A(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 j(e,t,n,r){return{debug:()=>e?.debugAll??e[t],key:!1,onChange:r}}function he(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:A(()=>[e,n,t,i],(e,t,n,r)=>({table:e,column:t,row:n,cell:r,getValue:r.getValue,renderValue:r.renderValue}),j(e.options,`debugCells`,`cell.getContext`))};return e._features.forEach(r=>{r.createCell==null||r.createCell(i,n,t,e)},{}),i}function ge(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:A(()=>[!0],()=>[c,...c.columns?.flatMap(e=>e.getFlatColumns())],j(e.options,`debugColumns`,`column.getFlatColumns`)),getLeafColumns:A(()=>[e._getOrderColumnsFn()],e=>{var t;return(t=c.columns)!=null&&t.length?e(c.columns.flatMap(e=>e.getLeafColumns())):[c]},j(e.options,`debugColumns`,`column.getLeafColumns`))};for(let t of e._features)t.createColumn==null||t.createColumn(c,e);return c}var M=`debugHeaders`;function _e(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 ve={createTable:e=>{e.getHeaderGroups=A(()=>[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 N(t,[...a,...s,...o],e)},j(e.options,M,`getHeaderGroups`)),e.getCenterHeaderGroups=A(()=>[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))),N(t,n,e,`center`)),j(e.options,M,`getCenterHeaderGroups`)),e.getLeftHeaderGroups=A(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left],(t,n,r)=>N(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`left`),j(e.options,M,`getLeftHeaderGroups`)),e.getRightHeaderGroups=A(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.right],(t,n,r)=>N(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`right`),j(e.options,M,`getRightHeaderGroups`)),e.getFooterGroups=A(()=>[e.getHeaderGroups()],e=>[...e].reverse(),j(e.options,M,`getFooterGroups`)),e.getLeftFooterGroups=A(()=>[e.getLeftHeaderGroups()],e=>[...e].reverse(),j(e.options,M,`getLeftFooterGroups`)),e.getCenterFooterGroups=A(()=>[e.getCenterHeaderGroups()],e=>[...e].reverse(),j(e.options,M,`getCenterFooterGroups`)),e.getRightFooterGroups=A(()=>[e.getRightHeaderGroups()],e=>[...e].reverse(),j(e.options,M,`getRightFooterGroups`)),e.getFlatHeaders=A(()=>[e.getHeaderGroups()],e=>e.map(e=>e.headers).flat(),j(e.options,M,`getFlatHeaders`)),e.getLeftFlatHeaders=A(()=>[e.getLeftHeaderGroups()],e=>e.map(e=>e.headers).flat(),j(e.options,M,`getLeftFlatHeaders`)),e.getCenterFlatHeaders=A(()=>[e.getCenterHeaderGroups()],e=>e.map(e=>e.headers).flat(),j(e.options,M,`getCenterFlatHeaders`)),e.getRightFlatHeaders=A(()=>[e.getRightHeaderGroups()],e=>e.map(e=>e.headers).flat(),j(e.options,M,`getRightFlatHeaders`)),e.getCenterLeafHeaders=A(()=>[e.getCenterFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),j(e.options,M,`getCenterLeafHeaders`)),e.getLeftLeafHeaders=A(()=>[e.getLeftFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),j(e.options,M,`getLeftLeafHeaders`)),e.getRightLeafHeaders=A(()=>[e.getRightFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),j(e.options,M,`getRightLeafHeaders`)),e.getLeafHeaders=A(()=>[e.getLeftHeaderGroups(),e.getCenterHeaderGroups(),e.getRightHeaderGroups()],(e,t,n)=>[...e[0]?.headers??[],...t[0]?.headers??[],...n[0]?.headers??[]].map(e=>e.getLeafHeaders()).flat(),j(e.options,M,`getLeafHeaders`))}};function N(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=_e(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)=>_e(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 ye=(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:()=>me(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:A(()=>[e.getAllLeafColumns()],t=>t.map(t=>he(e,s,t,t.id)),j(e.options,`debugRows`,`getAllCells`)),_getAllCellsByColumnId:A(()=>[s.getAllCells()],e=>e.reduce((e,t)=>(e[t.column.id]=t,e),{}),j(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},be={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()}}},xe=(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))};xe.autoRemove=e=>I(e);var Se=(e,t,n)=>{var r;return!!((r=e.getValue(t))!=null&&(r=r.toString())!=null&&r.includes(n))};Se.autoRemove=e=>I(e);var Ce=(e,t,n)=>{var r;return((r=e.getValue(t))==null||(r=r.toString())==null?void 0:r.toLowerCase())===n?.toLowerCase()};Ce.autoRemove=e=>I(e);var we=(e,t,n)=>e.getValue(t)?.includes(n);we.autoRemove=e=>I(e);var Te=(e,t,n)=>!n.some(n=>{var r;return!((r=e.getValue(t))!=null&&r.includes(n))});Te.autoRemove=e=>I(e)||!(e!=null&&e.length);var Ee=(e,t,n)=>n.some(n=>e.getValue(t)?.includes(n));Ee.autoRemove=e=>I(e)||!(e!=null&&e.length);var De=(e,t,n)=>e.getValue(t)===n;De.autoRemove=e=>I(e);var Oe=(e,t,n)=>e.getValue(t)==n;Oe.autoRemove=e=>I(e);var P=(e,t,n)=>{let[r,i]=n,a=e.getValue(t);return a>=r&&a<=i};P.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]},P.autoRemove=e=>I(e)||I(e[0])&&I(e[1]);var F={includesString:xe,includesStringSensitive:Se,equalsString:Ce,arrIncludes:we,arrIncludesAll:Te,arrIncludesSome:Ee,equals:De,weakEquals:Oe,inNumberRange:P};function I(e){return e==null||e===``}var ke={getDefaultColumnDef:()=>({filterFn:`auto`}),getInitialState:e=>({columnFilters:[],...e}),getDefaultOptions:e=>({onColumnFiltersChange:O(`columnFilters`,e),filterFromLeafRows:!1,maxLeafRowFilterDepth:100}),createColumn:(e,t)=>{e.getAutoFilterFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);return typeof n==`string`?F.includesString:typeof n==`number`?F.inNumberRange:typeof n==`boolean`||typeof n==`object`&&n?F.equals:Array.isArray(n)?F.arrIncludes:F.weakEquals},e.getFilterFn=()=>k(e.columnDef.filterFn)?e.columnDef.filterFn:e.columnDef.filterFn===`auto`?e.getAutoFilterFn():t.options.filterFns?.[e.columnDef.filterFn]??F[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=D(n,i?i.value:void 0);if(Ae(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=>D(t,e)?.filter(e=>{let t=n.find(t=>t.id===e.id);return!(t&&Ae(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 Ae(e,t,n){return(e&&e.autoRemove?e.autoRemove(t,n):!1)||t===void 0||typeof t==`string`&&!t}var L={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(!pe(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},je={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:O(`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 L.sum;if(Object.prototype.toString.call(n)===`[object Date]`)return L.extent},e.getAggregationFn=()=>{if(!e)throw Error();return k(e.columnDef.aggregationFn)?e.columnDef.aggregationFn:e.columnDef.aggregationFn===`auto`?e.getAutoAggregationFn():t.options.aggregationFns?.[e.columnDef.aggregationFn]??L[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 Me(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 Ne={getInitialState:e=>({columnOrder:[],...e}),getDefaultOptions:e=>({onColumnOrderChange:O(`columnOrder`,e)}),createColumn:(e,t)=>{e.getIndex=A(e=>[U(t,e)],t=>t.findIndex(t=>t.id===e.id),j(t.options,`debugColumns`,`getIndex`)),e.getIsFirstColumn=n=>U(t,n)[0]?.id===e.id,e.getIsLastColumn=n=>{let r=U(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=A(()=>[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 Me(i,t,n)},j(e.options,`debugTable`,`_getOrderColumnsFn`))}},R=()=>({left:[],right:[]}),Pe={getInitialState:e=>({columnPinning:R(),...e}),getDefaultOptions:e=>({onColumnPinningChange:O(`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=A(()=>[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))},j(t.options,`debugRows`,`getCenterVisibleCells`)),e.getLeftVisibleCells=A(()=>[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`})),j(t.options,`debugRows`,`getLeftVisibleCells`)),e.getRightVisibleCells=A(()=>[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`})),j(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?R():e.initialState?.columnPinning??R()),e.getIsSomeColumnsPinned=t=>{let n=e.getState().columnPinning;return t?!!n[t]?.length:!!(n.left?.length||n.right?.length)},e.getLeftLeafColumns=A(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),j(e.options,`debugColumns`,`getLeftLeafColumns`)),e.getRightLeafColumns=A(()=>[e.getAllLeafColumns(),e.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),j(e.options,`debugColumns`,`getRightLeafColumns`)),e.getCenterLeafColumns=A(()=>[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))},j(e.options,`debugColumns`,`getCenterLeafColumns`))}};function Fe(e){return e||(typeof document<`u`?document:null)}var z={size:150,minSize:20,maxSize:2**53-1},B=()=>({startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,isResizingColumn:!1,columnSizingStart:[]}),Ie={getDefaultColumnDef:()=>z,getInitialState:e=>({columnSizing:{},columnSizingInfo:B(),...e}),getDefaultOptions:e=>({columnResizeMode:`onEnd`,columnResizeDirection:`ltr`,onColumnSizingChange:O(`columnSizing`,e),onColumnSizingInfoChange:O(`columnSizingInfo`,e)}),createColumn:(e,t)=>{e.getSize=()=>{let n=t.getState().columnSizing[e.id];return Math.min(Math.max(e.columnDef.minSize??z.minSize,n??e.columnDef.size??z.size),e.columnDef.maxSize??z.maxSize)},e.getStart=A(e=>[e,U(t,e),t.getState().columnSizing],(t,n)=>n.slice(0,e.getIndex(t)).reduce((e,t)=>e+t.getSize(),0),j(t.options,`debugColumns`,`getStart`)),e.getAfter=A(e=>[e,U(t,e),t.getState().columnSizing],(t,n)=>n.slice(e.getIndex(t)+1).reduce((e,t)=>e+t.getSize(),0),j(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(),H(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=H(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=Fe(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=Le()?{passive:!1}:!1;H(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?B():e.initialState.columnSizingInfo??B())},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}},V=null;function Le(){if(typeof V==`boolean`)return V;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 V=e,V}function H(e){return e.type===`touchstart`}var Re={getInitialState:e=>({columnVisibility:{},...e}),getDefaultOptions:e=>({onColumnVisibilityChange:O(`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=A(()=>[e.getAllCells(),t.getState().columnVisibility],e=>e.filter(e=>e.column.getIsVisible()),j(t.options,`debugRows`,`_getAllVisibleCells`)),e.getVisibleCells=A(()=>[e.getLeftVisibleCells(),e.getCenterVisibleCells(),e.getRightVisibleCells()],(e,t,n)=>[...e,...t,...n],j(t.options,`debugRows`,`getVisibleCells`))},createTable:e=>{let t=(t,n)=>A(()=>[n(),n().filter(e=>e.getIsVisible()).map(e=>e.id).join(`_`)],e=>e.filter(e=>e.getIsVisible==null?void 0:e.getIsVisible()),j(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 U(e,t){return t?t===`center`?e.getCenterVisibleLeafColumns():t===`left`?e.getLeftVisibleLeafColumns():e.getRightVisibleLeafColumns():e.getVisibleLeafColumns()}var ze={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()}}},Be={getInitialState:e=>({globalFilter:void 0,...e}),getDefaultOptions:e=>({onGlobalFilterChange:O(`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=()=>F.includesString,e.getGlobalFilterFn=()=>{let{globalFilterFn:t}=e.options;return k(t)?t:t===`auto`?e.getGlobalAutoFilterFn():e.options.filterFns?.[t]??F[t]},e.setGlobalFilter=t=>{e.options.onGlobalFilterChange==null||e.options.onGlobalFilterChange(t)},e.resetGlobalFilter=t=>{e.setGlobalFilter(t?void 0:e.initialState.globalFilter)}}},Ve={getInitialState:e=>({expanded:{},...e}),getDefaultOptions:e=>({onExpandedChange:O(`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()}}}},W=0,G=10,K=()=>({pageIndex:W,pageSize:G}),He={getInitialState:e=>({...e,pagination:{...K(),...e?.pagination}}),getDefaultOptions:e=>({onPaginationChange:O(`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=>D(t,e)),e.resetPagination=t=>{e.setPagination(t?K():e.initialState.pagination??K())},e.setPageIndex=t=>{e.setPagination(n=>{let r=D(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?W:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageIndex)??W)},e.resetPageSize=t=>{var n;e.setPageSize(t?G:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageSize)??G)},e.setPageSize=t=>{e.setPagination(e=>{let n=Math.max(1,D(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=D(t,e.options.pageCount??-1);return typeof r==`number`&&(r=Math.max(-1,r)),{...n,pageCount:r}}),e.getPageOptions=A(()=>[e.getPageCount()],e=>{let t=[];return e&&e>0&&(t=[...Array(e)].fill(null).map((e,t)=>t)),t},j(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}},q=()=>({top:[],bottom:[]}),Ue={getInitialState:e=>({rowPinning:q(),...e}),getDefaultOptions:e=>({onRowPinningChange:O(`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?q():e.initialState?.rowPinning??q()),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=A(()=>[e.getRowModel().rows,e.getState().rowPinning.top],(t,n)=>e._getPinnedRows(t,n,`top`),j(e.options,`debugRows`,`getTopRows`)),e.getBottomRows=A(()=>[e.getRowModel().rows,e.getState().rowPinning.bottom],(t,n)=>e._getPinnedRows(t,n,`bottom`),j(e.options,`debugRows`,`getBottomRows`)),e.getCenterRows=A(()=>[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))},j(e.options,`debugRows`,`getCenterRows`))}},We={getInitialState:e=>({rowSelection:{},...e}),getDefaultOptions:e=>({onRowSelectionChange:O(`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=>{J(i,t.id,r,!0,e)}),i}),e.getPreSelectedRowModel=()=>e.getCoreRowModel(),e.getSelectedRowModel=A(()=>[e.getState().rowSelection,e.getCoreRowModel()],(t,n)=>Object.keys(t).length?Ge(e,n):{rows:[],flatRows:[],rowsById:{}},j(e.options,`debugTable`,`getSelectedRowModel`)),e.getFilteredSelectedRowModel=A(()=>[e.getState().rowSelection,e.getFilteredRowModel()],(t,n)=>Object.keys(t).length?Ge(e,n):{rows:[],flatRows:[],rowsById:{}},j(e.options,`debugTable`,`getFilteredSelectedRowModel`)),e.getGroupedSelectedRowModel=A(()=>[e.getState().rowSelection,e.getSortedRowModel()],(t,n)=>Object.keys(t).length?Ge(e,n):{rows:[],flatRows:[],rowsById:{}},j(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 J(o,e.id,n,r?.selectChildren??!0,t),o})},e.getIsSelected=()=>{let{rowSelection:n}=t.getState();return Ke(e,n)},e.getIsSomeSelected=()=>{let{rowSelection:n}=t.getState();return qe(e,n)===`some`},e.getIsAllSubRowsSelected=()=>{let{rowSelection:n}=t.getState();return qe(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)}}}},J=(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=>J(e,t.id,n,r,i))};function Ge(e,t){let n=e.getState().rowSelection,r=[],i={},a=function(e,t){return e.map(e=>{var t;let o=Ke(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 Ke(e,t){return t[e.id]??!1}function qe(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()&&(Ke(e,t)?a=!0:i=!1),e.subRows&&e.subRows.length)){let n=qe(e,t);n===`all`?a=!0:(n===`some`&&(a=!0),i=!1)}}),i?`all`:a?`some`:!1}var Je=/([0-9]+)/gm,Ye=(e,t,n)=>nt(Y(e.getValue(n)).toLowerCase(),Y(t.getValue(n)).toLowerCase()),Xe=(e,t,n)=>nt(Y(e.getValue(n)),Y(t.getValue(n))),Ze=(e,t,n)=>tt(Y(e.getValue(n)).toLowerCase(),Y(t.getValue(n)).toLowerCase()),Qe=(e,t,n)=>tt(Y(e.getValue(n)),Y(t.getValue(n))),$e=(e,t,n)=>{let r=e.getValue(n),i=t.getValue(n);return r>i?1:r<i?-1:0},et=(e,t,n)=>tt(e.getValue(n),t.getValue(n));function tt(e,t){return e===t?0:e>t?1:-1}function Y(e){return typeof e==`number`?isNaN(e)||e===1/0||e===-1/0?``:String(e):typeof e==`string`?e:``}function nt(e,t){let n=e.split(Je).filter(Boolean),r=t.split(Je).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 X={alphanumeric:Ye,alphanumericCaseSensitive:Xe,text:Ze,textCaseSensitive:Qe,datetime:$e,basic:et},rt=[ve,Re,Ne,Pe,be,ke,ze,Be,{getInitialState:e=>({sorting:[],...e}),getDefaultColumnDef:()=>({sortingFn:`auto`,sortUndefined:1}),getDefaultOptions:e=>({onSortingChange:O(`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 X.datetime;if(typeof n==`string`&&(r=!0,n.split(Je).length>1))return X.alphanumeric}return r?X.text:X.basic},e.getAutoSortDir=()=>typeof t.getFilteredRowModel().flatRows[0]?.getValue(e.id)==`string`?`asc`:`desc`,e.getSortingFn=()=>{if(!e)throw Error();return k(e.columnDef.sortingFn)?e.columnDef.sortingFn:e.columnDef.sortingFn===`auto`?e.getAutoSortingFn():t.options.sortingFns?.[e.columnDef.sortingFn]??X[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())}},je,Ve,He,Ue,We,Ie];function it(e){let t=[...rt,...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=D(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:A(()=>[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}),j(e,`debugColumns`,`_getDefaultColumnDef`)),_getColumnDefs:()=>n.options.columns,getAllColumns:A(()=>[n._getColumnDefs()],e=>{let t=function(e,r,i){return i===void 0&&(i=0),e.map(e=>{let a=ge(n,e,i,r),o=e;return a.columns=o.columns?t(o.columns,a,i+1):[],a})};return t(e)},j(e,`debugColumns`,`getAllColumns`)),getAllFlatColumns:A(()=>[n.getAllColumns()],e=>e.flatMap(e=>e.getFlatColumns()),j(e,`debugColumns`,`getAllFlatColumns`)),_getAllFlatColumnsById:A(()=>[n.getAllFlatColumns()],e=>e.reduce((e,t)=>(e[t.id]=t,e),{}),j(e,`debugColumns`,`getAllFlatColumnsById`)),getAllLeafColumns:A(()=>[n.getAllColumns(),n._getOrderColumnsFn()],(e,t)=>t(e.flatMap(e=>e.getLeafColumns())),j(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 at(){return e=>A(()=>[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=ye(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},j(e.options,`debugTable`,`getRowModel`,()=>e._autoResetPageIndex()))}function ot(){return e=>A(()=>[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}},j(e.options,`debugTable`,`getSortedRowModel`,()=>e._autoResetPageIndex()))}function Z(){return!0}var st=Symbol(`merge-proxy`),ct={get(e,t,n){return t===st?n:e.get(t)},has(e,t){return e.has(t)},set:Z,deleteProperty:Z,getOwnPropertyDescriptor(e,t){return{configurable:!0,enumerable:!0,get(){return e.get(t)},set:Z,deleteProperty:Z}},ownKeys(e){return e.keys()}};function lt(e){return`value`in e?e.value:e}function Q(){var e=[...arguments];return new Proxy({get(t){for(let n=e.length-1;n>=0;n--){let r=lt(e[n])[t];if(r!==void 0)return r}},has(t){for(let n=e.length-1;n>=0;n--)if(t in lt(e[n]))return!0;return!1},keys(){let t=[];for(let n=0;n<e.length;n++)t.push(...Object.keys(lt(e[n])));return[...Array.from(new Set(t))]}},ct)}var $=l({props:[`render`,`props`],setup:e=>()=>typeof e.render==`function`||typeof e.render==`object`?i(e.render,e.props):e.render});function ut(e){return Q(e,{data:h(e.data)})}function dt(t){let n=a(t.data),r=it(Q({state:{},onStateChange:()=>{},renderFallbackValue:null,mergeOptions(e,t){return n?{...e,...t}:Q(e,t)}},n?ut(t):t));if(n){let n=te(t.data);e(n,()=>{r.setState(e=>({...e,data:n.value}))},{immediate:!0})}let i=re(r.initialState);return ee(()=>{r.setOptions(e=>{let r=new Proxy({},{get:(e,t)=>i.value[t]});return Q(e,n?ut(t):t,{state:Q(r,t.state??{}),onStateChange:e=>{e instanceof Function?i.value=e(i.value):i.value=e,t.onStateChange==null||t.onStateChange(e)}})})}),r}var ft=[`aria-label`],pt=l({__name:`SortHeaderButton`,props:{header:{}},setup(e){let t=e,n=_(()=>t.header.column.getIsSorted()),r=_(()=>n.value===`asc`?ie:n.value===`desc`?m:p),i=_(()=>{let e=t.header.column.columnDef.header;return typeof e==`string`?e:t.header.column.id}),a=_(()=>{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=oe(`FontAwesomeIcon`);return y(),d(`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?x(``,!0):(y(),b(h($),{key:0,render:e.header.column.columnDef.header,props:e.header.getContext()},null,8,[`render`,`props`])),g(s,{icon:r.value,class:S([`size-3 shrink-0`,n.value?`text-foreground`:`text-muted-foreground/60`]),"aria-hidden":`true`},null,8,[`icon`,`class`])],8,ft)}}}),mt=l({__name:`DataTable`,props:{columns:{},data:{},rowClass:{type:Function},emptyMessage:{},sorting:{}},emits:[`update:sorting`],setup(e,{emit:n}){let i=e,a=n,s=re([]),c=dt({get data(){return i.data},get columns(){return i.columns},getCoreRowModel:at(),getSortedRowModel:ot(),onSortingChange:e=>{let t=i.sorting??s.value,n=typeof e==`function`?e(t):e;i.sorting===void 0?s.value=n:a(`update:sorting`,n)},state:{get sorting(){return i.sorting??s.value}}});function l(e){if(e===`asc`)return`ascending`;if(e===`desc`)return`descending`}return(n,i)=>(y(),b(h(ce),null,{default:t(()=>[g(h(E),null,{default:t(()=>[(y(!0),d(r,null,f(h(c).getHeaderGroups(),e=>(y(),b(h(w),{key:e.id},{default:t(()=>[(y(!0),d(r,null,f(e.headers,e=>(y(),b(h(T),{key:e.id,class:S(e.column.columnDef.meta?.align===`right`?`text-right`:void 0),"aria-sort":e.column.getCanSort()?l(e.column.getIsSorted())??`none`:void 0},{default:t(()=>[e.column.getCanSort()?(y(),b(pt,{key:0,header:e,class:`-mx-1.5`},null,8,[`header`])):e.isPlaceholder?x(``,!0):(y(),b(h($),{key:1,render:e.column.columnDef.header,props:e.getContext()},null,8,[`render`,`props`]))]),_:2},1032,[`class`,`aria-sort`]))),128))]),_:2},1024))),128))]),_:1}),g(h(le),null,{default:t(()=>[h(c).getRowModel().rows.length===0?(y(),b(h(de),{key:0,colspan:e.columns.length,class:`text-muted-foreground`},{default:t(()=>[ne(o(e.emptyMessage??`none`),1)]),_:1},8,[`colspan`])):x(``,!0),(y(!0),d(r,null,f(h(c).getRowModel().rows,n=>(y(),b(h(w),{key:n.id,class:S(e.rowClass?.(n.original))},{default:t(()=>[(y(!0),d(r,null,f(n.getVisibleCells(),e=>(y(),b(h(C),{key:e.id,class:S(e.column.columnDef.meta?.align===`right`?`text-right tabular-nums`:void 0)},{default:t(()=>[g(h($),{render:e.column.columnDef.cell,props:e.getContext()},null,8,[`render`,`props`])]),_:2},1032,[`class`]))),128))]),_:2},1032,[`class`]))),128))]),_:1})]),_:1}))}});export{ot as a,T as c,le as d,ce as f,at as i,w as l,pt as n,fe as o,dt as r,E as s,mt as t,C as u};",
		),
	},
	"EntityLink-Dg93KGVT.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"aW1wb3J0e1NpIGFzIGUsWSBhcyB0LF9uIGFzIG4sYW4gYXMgcixjbiBhcyBpLGdpIGFzIGEsaG4gYXMgbyxuIGFzIHMsbnIgYXMgYyx1ciBhcyBsLHlpIGFzIHV9ZnJvbSIuL1NrZWxldG9uLUIwemlCNk9kLmpzIjt2YXIgZD1bYGFyaWEtbGFiZWxgLGB0aXRsZWBdLGY9bih7X19uYW1lOmBFbnRpdHlMaW5rYCxwcm9wczp7bGFiZWw6e30sa2luZDp7fSxpZDp7fSxsYWJlbENsYXNzOnt9fSxzZXR1cChuKXtsZXQgZj1uLHA9cygpLG09e3VzZXI6e3BhZ2U6YGNvbnN1bWVyc2AscGFyYW1LZXk6YHVzZXJgLG5vdW46YENvbnN1bWVyc2B9LG1vZGVsOntwYWdlOmBtb2RlbHNgLHBhcmFtS2V5OmBtb2RlbGAsbm91bjpgTW9kZWxzYH19O2Z1bmN0aW9uIGgoZSl7ZS5zdG9wUHJvcGFnYXRpb24oKTtsZXQgdD1tW2Yua2luZF07cC5nb1RvKHQucGFnZSx7W3QucGFyYW1LZXldOmYuaWR9KX1yZXR1cm4ocyxmKT0+e2xldCBwPWwoYEZvbnRBd2Vzb21lSWNvbmApO3JldHVybiBjKCksaShgYnV0dG9uYCx7dHlwZTpgYnV0dG9uYCwiYXJpYS1sYWJlbCI6YFZpZXcgJHtuLmxhYmVsfSBpbiAke21bbi5raW5kXS5ub3VufWAsdGl0bGU6YFZpZXcgJHtuLmxhYmVsfSBpbiAke21bbi5raW5kXS5ub3VufWAsY2xhc3M6YGlubGluZS1mbGV4IG1pbi13LTAgY3Vyc29yLXBvaW50ZXIgaXRlbXMtY2VudGVyIGdhcC0xIHJvdW5kZWQtc20gdGV4dC1pbmhlcml0IGhvdmVyOnRleHQtcHJpbWFyeSBob3Zlcjp1bmRlcmxpbmUgZm9jdXMtdmlzaWJsZTpvdXRsaW5lLW5vbmUgZm9jdXMtdmlzaWJsZTpyaW5nLTIgZm9jdXMtdmlzaWJsZTpyaW5nLXJpbmcvNTBgLG9uQ2xpY2s6aH0sW3IoYHNwYW5gLHtjbGFzczp1KFtgbWluLXctMGAsbi5sYWJlbENsYXNzXSl9LGUobi5sYWJlbCksMyksbyhwLHtpY29uOmEodCksY2xhc3M6YHNpemUtMyBzaHJpbmstMGAsImFyaWEtaGlkZGVuIjpgdHJ1ZWB9LG51bGwsOCxbYGljb25gXSldLDgsZCl9fX0pO2V4cG9ydHtmIGFzIHR9Ow==",
		),
	},
	"ErrorState-ym6eSlj2.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"aW1wb3J0e0UgYXMgZSxGciBhcyB0LEogYXMgbixTaSBhcyByLF9uIGFzIGksYW4gYXMgYSxjbiBhcyBvLGdpIGFzIHMsaG4gYXMgYyxtbiBhcyBsLG10IGFzIHUsbnIgYXMgZCxvaSBhcyBmLG9uIGFzIHAsc24gYXMgbSx1ciBhcyBoLHlpIGFzIGd9ZnJvbSIuL1NrZWxldG9uLUIwemlCNk9kLmpzIjt2YXIgXz17cm9sZTpgYWxlcnRgLGNsYXNzOmBmbGV4IGZsZXgtY29sIGl0ZW1zLWNlbnRlciBnYXAtMiBweC00IHB5LTggdGV4dC1jZW50ZXJgfSx2PXtjbGFzczpgbWF4LXctZnVsbCBicmVhay13b3JkcyB0ZXh0LXNtIGZvbnQtbWVkaXVtIHRleHQtZGVzdHJ1Y3RpdmVgfSx5PWkoe19fbmFtZTpgRXJyb3JTdGF0ZWAscHJvcHM6e21lc3NhZ2U6e30sb25SZXRyeTp7dHlwZTpGdW5jdGlvbn19LHNldHVwKGkpe2xldCB5PWksYj1mKCExKTthc3luYyBmdW5jdGlvbiB4KCl7aWYoISgheS5vblJldHJ5fHxiLnZhbHVlKSl7Yi52YWx1ZT0hMDt0cnl7YXdhaXQgeS5vblJldHJ5KCl9ZmluYWxseXtiLnZhbHVlPSExfX19cmV0dXJuKGYseSk9PntsZXQgUz1oKGBGb250QXdlc29tZUljb25gKTtyZXR1cm4gZCgpLG8oYGRpdmAsXyxbYyhTLHtpY29uOnModSksY2xhc3M6YHNpemUtNiB0ZXh0LWRlc3RydWN0aXZlYCwiYXJpYS1oaWRkZW4iOmB0cnVlYH0sbnVsbCw4LFtgaWNvbmBdKSxhKGBwYCx2LHIoaS5tZXNzYWdlKSwxKSxpLm9uUmV0cnk/KGQoKSxwKHMoZSkse2tleTowLHR5cGU6YGJ1dHRvbmAsdmFyaWFudDpgb3V0bGluZWAsc2l6ZTpgc21gLGNsYXNzOmBtdC0xYCxkaXNhYmxlZDpiLnZhbHVlLG9uQ2xpY2s6eH0se2RlZmF1bHQ6dCgoKT0+W2MoUyx7aWNvbjpzKG4pLGNsYXNzOmcoW2BzaXplLTMuNWAsYi52YWx1ZT9gYW5pbWF0ZS1zcGluIG1vdGlvbi1yZWR1Y2U6YW5pbWF0ZS1ub25lYDp2b2lkIDBdKSwiYXJpYS1oaWRkZW4iOmB0cnVlYH0sbnVsbCw4LFtgaWNvbmAsYGNsYXNzYF0pLGwoYCBgK3IoYi52YWx1ZT9gUmV0cnlpbmfigKZgOmBSZXRyeWApLDEpXSksXzoxfSw4LFtgZGlzYWJsZWRgXSkpOm0oYGAsITApXSl9fX0pO2V4cG9ydHt5IGFzIHR9Ow==",
		),
	},
	"HomePage-xxao-DzQ.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{Ar as e,C as t,Fr as n,Jt as r,S as i,Si as a,T as o,Xn as s,_n as c,an as l,b as ee,cn as u,cr as d,er as te,fr as f,g as ne,gi as p,hn as m,ii as re,in as h,lr as g,mn as _,n as ie,nr as v,oi as y,on as b,sn as x,t as S,v as ae,w as C,x as oe,y as se,yi as w}from"./Skeleton-B0ziB6Od.js";import{n as ce,r as le,t as ue}from"./tabs-YlhnHpK-.js";import{t as de}from"./index-dywS8OpT.js";import{t as T}from"./ErrorState-ym6eSlj2.js";import{_ as E,f as fe,i as pe,o as D,t as me,v as O}from"./badge-DUiBTDyA.js";import{i as he,n as ge,r as _e,t as ve}from"./TryLongerRangeButton-CjkUnaOz.js";import{t as ye}from"./SkeletonList-Cmqz3hfa.js";import{t as k}from"./EntityLink-Dg93KGVT.js";import{t as be}from"./events-PUxhEega.js";import{n as xe,r as Se}from"./events-filter-XFnjIaR7.js";import{a as Ce,i as we,n as Te,o as Ee,r as De,t as Oe}from"./kpi-chm3BiuF.js";var A={class:`text-xs font-medium text-muted-foreground`},j={key:0,class:`text-xs text-muted-foreground`},M=c({__name:`KpiTile`,props:{label:{},value:{},delta:{},tier:{default:`ok`},to:{}},setup(e){let t=e,r=ie(),i=h(()=>{switch(t.tier){case`warn`:return`text-status-warn`;case`critical`:return`text-destructive`;default:return`text-foreground`}});function s(){t.to&&r.goTo(t.to.page,t.to.params??{})}return(t,r)=>(v(),b(f(e.to?`button`:`div`),{type:e.to?`button`:void 0,class:w([`block w-full rounded-xl text-left`,e.to?`cursor-pointer transition-colors hover:opacity-90 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50`:void 0]),onClick:s},{default:n(()=>[m(p(o),null,{default:n(()=>[m(p(C),{class:`flex flex-col gap-1 px-4 py-3`},{default:n(()=>[l(`span`,A,a(e.label),1),l(`span`,{class:w([`text-2xl font-semibold tracking-tight tabular-nums`,i.value])},a(e.value),3),e.delta?(v(),u(`span`,j,a(e.delta),1)):x(``,!0)]),_:1})]),_:1})]),_:1},8,[`type`,`class`]))}}),ke=c({__name:`SkeletonKpiTile`,setup(e){return(e,t)=>(v(),b(p(o),null,{default:n(()=>[m(p(C),{class:`flex flex-col gap-1 px-4 py-3`},{default:n(()=>[m(p(S),{class:`h-3 w-20`}),m(p(S),{class:`h-7 w-16`}),m(p(S),{class:`h-3 w-28`})]),_:1})]),_:1}))}}),N={key:4,class:`flex flex-col gap-1.5`},P={class:`flex min-w-0 items-center gap-2`},F={class:`w-4 shrink-0 text-right text-xs text-muted-foreground`},Ae={class:`shrink-0 font-medium tabular-nums`},I=c({__name:`TopList`,props:{title:{},items:{},emptyText:{},loading:{type:Boolean,default:!1},loaded:{type:Boolean,default:!1},error:{default:``},onRetry:{},notice:{},noticeDescription:{}},setup(e){let s=e,c=h(()=>E({loading:s.loading,hasData:s.loaded,error:s.error??``}));return(s,ee)=>(v(),b(p(o),null,{default:n(()=>[m(p(t),null,{default:n(()=>[m(p(i),null,{default:n(()=>[_(a(e.title),1)]),_:1}),g(s.$slots,`controls`)]),_:3}),m(p(C),null,{default:n(()=>[e.notice?(v(),b(O,{key:0,title:e.notice,description:e.noticeDescription},null,8,[`title`,`description`])):c.value===`skeleton`?(v(),b(ye,{key:1,rows:5})):c.value===`error`?(v(),b(T,{key:2,message:e.error??``,"on-retry":e.onRetry},null,8,[`message`,`on-retry`])):e.items.length===0?(v(),b(O,{key:3,title:e.emptyText},{default:n(()=>[g(s.$slots,`empty-action`)]),_:3},8,[`title`])):(v(),u(`ol`,N,[(v(!0),u(r,null,d(e.items,(e,t)=>(v(),u(`li`,{key:e.id,class:`flex items-center justify-between gap-3 text-sm`},[l(`span`,P,[l(`span`,F,a(t+1),1),m(k,{label:e.label,kind:e.kind,id:e.id,class:`min-w-0`,"label-class":`truncate`},null,8,[`label`,`kind`,`id`])]),l(`span`,Ae,a(e.value),1)]))),128))]))]),_:3})]),_:3}))}}),L=[`cost`,`req`,`tokens`],je=`cost`,Me={cost:`Cost`,req:`Requests`,tokens:`Tokens`},Ne=64e3,Pe={cost:[`cost`],req:[`req`],tokens:[`tokin`,`tokout`]};function Fe(e){return L.includes(e??``)?e:je}var Ie=1e3;function Le(e,t,n,r=Ie){let i=new URLSearchParams;return i.set(`kind`,`user`),i.set(`window`,e),i.set(`span`,String(t)),i.set(`offset`,`0`),i.set(`metrics`,Pe[n].join(`,`)),i.set(`limit`,String(r)),`/admin/api/usage/totals?${i.toString()}`}function R(e,t,n){return e*t*n>Ne}function Re(e,t,n){return e!==null&&R(e,t,n)}function ze(e,t){switch(t){case`cost`:return e.values.cost??0;case`req`:return e.values.req??0;case`tokens`:return(e.values.tokin??0)+(e.values.tokout??0)}}function Be(e,t,n=5){return e.map(e=>({id:e.id,value:ze(e,t)})).filter(e=>e.value>0).sort((e,t)=>t.value===e.value?e.id.localeCompare(t.id):t.value-e.value).slice(0,n)}var Ve={class:`flex flex-col gap-4`},He={"aria-label":`Key metrics`,class:`grid grid-cols-2 gap-3 sm:grid-cols-3 lg:grid-cols-4`},Ue={key:1,class:`col-span-full`},We={"aria-label":`Top spenders and models`,class:`grid grid-cols-1 gap-3 lg:grid-cols-2`},Ge={key:2,class:`text-sm text-muted-foreground`},Ke={key:3,class:`flex flex-col gap-2`},qe={class:`flex min-w-0 items-center gap-2`},Je={class:`min-w-0 truncate text-muted-foreground`},Ye={class:`shrink-0 tabular-nums text-muted-foreground`},Xe=5,Ze=6e4,Qe=c({__name:`HomePage`,setup(c){let f=oe(),g=ne(),x=be(),S=de(),w=ie(),O=h(()=>g.usage?.total.costPerDayMicroUsd??0),k=h(()=>g.usage?.total.costPerMonthMicroUsd??0),A=h(()=>Ee(g.overview?.groups??[])),j=h(()=>Te(Oe(k.value,A.value))),N=h(()=>{let e=`${D(O.value)} today`;return A.value>0?`${e} · budget ${D(A.value)}/mo`:`${e} · no budget set`}),P=h(()=>he(k.value,_e(new Date))),F=h(()=>ge(P.value,A.value>0?A.value/1e6:void 0)),Ae=h(()=>P.value===null?`not enough data yet`:D(P.value)),je=h(()=>F.value.willExceed?`critical`:`ok`),Ne=h(()=>{if(P.value!==null)return A.value<=0?`no budget set`:F.value.willExceed?`projected to exceed budget`:`projected within budget`}),Ie=h(()=>g.usage?.total.requestsPerMinute??0),R=h(()=>we(g.overview?.providers??[])),ze=h(()=>De(R.value.rate)),Qe=h(()=>{let e=R.value.rate;return e===null?`no traffic`:e<=0?`0%`:`${Math.ceil(e*100)}%`}),$e=h(()=>`${R.value.failures}/${R.value.attempts} attempts in the last minute`),et=h(()=>Ce(g.overview?.providers??[])),tt=h(()=>g.overview?.warnings.length??0),nt=h(()=>g.overview?.pricing.unpriced??0),rt=h(()=>E({loading:!0,hasData:g.overview!==null&&g.usage!==null,error:g.error})),z=h(()=>Fe(w.params.top));function it(e){if(typeof e!=`string`||!L.includes(e))return;let t=e;if(t===`cost`){let{top:e,...t}=w.params;w.goTo(`home`,t);return}w.goTo(`home`,{...w.params,top:t})}let at=h(()=>g.usage?.users.length??null),B=y([]),V=y([]),H=y(!1),U=y(``),W=y(!1),G=y(``),K=y(!1),q=y(!1),J=re(new Map),ot=h(()=>J.has(z.value)),Y=0,X=0;function st(e,t){return e===`cost`?D(t):pe(t)}let ct=h(()=>Be(B.value,z.value).map(e=>({id:e.id,label:e.id,value:st(z.value,e.value),kind:`user`}))),lt=h(()=>`Top 5 users by ${Me[z.value].toLowerCase()}`);async function Z(){if(!f.isAuthenticated)return;let e=z.value,t=Pe[e].length;if(Re(at.value,t,S.span)){++Y,H.value=!1,q.value=!0,U.value=``;return}let n=++Y;H.value=!0;try{let t=await ee(Le(S.window,S.span,e));if(n!==Y)return;J.set(e,t.rows),B.value=t.rows,U.value=``,q.value=!1}catch(e){if(n!==Y)return;e instanceof se&&e.status===400&&/range too large/i.test(e.message)?(q.value=!0,U.value=``):U.value=e instanceof Error?e.message:String(e)}finally{n===Y&&(H.value=!1)}}async function ut(){if(!f.isAuthenticated)return;let e=++X;W.value=!0;try{let t=await ee(`/admin/api/usage/models?metric=cost&window=${S.window}&span=${S.span}&limit=${Xe}`);if(e!==X)return;V.value=t.models.map(e=>({id:e.id,label:e.id,value:D(e.value),kind:`model`})),G.value=``,K.value=!0}catch(t){if(e!==X)return;G.value=t instanceof Error?t.message:String(t)}finally{e===X&&(W.value=!1)}}async function dt(){await Promise.allSettled([Z(),ut()])}let Q;e(z,e=>{let t=J.get(e);B.value=t??[],U.value=``,q.value=!1,Z()}),e(()=>S.range,()=>{J.clear(),B.value=[],V.value=[],K.value=!1,U.value=``,G.value=``,q.value=!1,dt()});function ft(e){return xe[e]??e}let pt=h(()=>x.events.slice(0,8)),$=h(()=>E({loading:x.refreshing,hasData:x.lastUpdated!==null,error:x.error})),mt=h(()=>pt.value.length===0);return s(()=>{x.startPolling(),Q=ae({intervalMs:Ze,tick:()=>void dt()}),Q.start()}),te(()=>{x.stopPolling(),Q?.stop()}),(e,s)=>(v(),u(`div`,Ve,[l(`section`,He,[rt.value===`skeleton`?(v(),u(r,{key:0},d(7,e=>m(ke,{key:e})),64)):rt.value===`error`?(v(),u(`div`,Ue,[m(T,{message:p(g).error,"on-retry":p(g).refresh},null,8,[`message`,`on-retry`])])):(v(),u(r,{key:2},[m(M,{label:`Spend (MTD)`,value:p(D)(k.value),delta:N.value,tier:j.value,to:{page:`spend`}},null,8,[`value`,`delta`,`tier`]),m(M,{label:`Projected month-end`,value:Ae.value,delta:Ne.value,tier:je.value,to:{page:`spend`}},null,8,[`value`,`delta`,`tier`]),m(M,{label:`Requests/min`,value:p(pe)(Ie.value)},null,8,[`value`]),m(M,{label:`Error rate (last minute)`,value:Qe.value,delta:$e.value,tier:ze.value,to:{page:`reliability`}},null,8,[`value`,`delta`,`tier`]),m(M,{label:`Open breakers (per replica)`,value:String(et.value),tier:et.value>0?`warn`:`ok`,to:{page:`models`}},null,8,[`value`,`tier`]),m(M,{label:`Config warnings`,value:String(tt.value),tier:tt.value>0?`warn`:`ok`,to:{page:`config`}},null,8,[`value`,`tier`]),m(M,{label:`Unpriced models`,value:String(nt.value),tier:nt.value>0?`warn`:`ok`,to:{page:`spend`}},null,8,[`value`,`tier`])],64))]),l(`section`,We,[m(I,{title:lt.value,items:ct.value,"empty-text":`No traffic in this range.`,loading:H.value,loaded:ot.value,error:U.value,"on-retry":Z,notice:q.value?`Too many configured users for this range.`:void 0,"notice-description":`Pick a shorter range above — a fleet this size needs a narrower window to rank users.`},{controls:n(()=>[m(p(le),{"model-value":z.value,"onUpdate:modelValue":it},{default:n(()=>[m(p(ce),null,{default:n(()=>[(v(!0),u(r,null,d(p(L),e=>(v(),b(p(ue),{key:e,value:e},{default:n(()=>[_(a(p(Me)[e]),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])]),"empty-action":n(()=>[m(ve)]),_:1},8,[`title`,`items`,`loading`,`loaded`,`error`,`notice`]),m(I,{title:`Top 5 models by cost`,items:V.value,"empty-text":`No traffic in this range.`,loading:W.value,loaded:K.value,error:G.value,"on-retry":ut},{"empty-action":n(()=>[m(ve)]),_:1},8,[`items`,`loading`,`loaded`,`error`])]),m(p(o),null,{default:n(()=>[m(p(t),null,{default:n(()=>[m(p(i),null,{default:n(()=>[...s[0]||=[_(`Latest events`,-1)]]),_:1})]),_:1}),m(p(C),null,{default:n(()=>[$.value===`skeleton`?(v(),b(ye,{key:0,rows:4})):$.value===`error`?(v(),b(T,{key:1,message:p(x).error,"on-retry":p(x).refresh},null,8,[`message`,`on-retry`])):mt.value?(v(),u(`p`,Ge,`No events recorded yet.`)):(v(),u(`ol`,Ke,[(v(!0),u(r,null,d(pt.value,(e,t)=>(v(),u(`li`,{key:`${e.time}-${e.replica}-${t}`,class:`flex items-start justify-between gap-3 text-sm`},[l(`span`,qe,[m(p(me),{variant:p(Se)(e.kind),class:`shrink-0 font-normal`},{default:n(()=>[_(a(ft(e.kind)),1)]),_:2},1032,[`variant`]),l(`span`,Je,a(e.message),1)]),l(`span`,Ye,a(p(fe)(e.time)),1)]))),128))]))]),_:1})]),_:1})]))}});export{Qe as default};",
		),
	},
	"ModelsPage-CcA1RHK6.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{Ar as e,C as t,E as n,Fr as r,Jt as i,On as a,Qr as o,S as s,Si as c,T as l,Xn as u,_n as d,_t as f,an as p,b as m,cn as h,cr as ee,et as g,g as te,gi as _,hn as v,ii as ne,in as y,mn as b,mt as re,n as x,nr as S,on as C,rt as w,sn as T,ur as ie,w as E,y as ae,yi as D}from"./Skeleton-B0ziB6Od.js";import{a as oe,c as O,i as se,n as ce,o as le,r as ue,s as de,t as fe}from"./search-expand-CHd4FWZZ.js";import{c as k,g as pe,h as me,m as he,t as A}from"./index-dywS8OpT.js";import{t as ge}from"./ErrorState-ym6eSlj2.js";import{_ as _e,a as ve,d as j,g as M,h as ye,l as N,m as be,n as xe,o as P,p as Se,t as F,v as I}from"./badge-DUiBTDyA.js";import{o as L,t as Ce}from"./DataTable-CQxRVDSY.js";import{t as R}from"./CompactNumber-pr8cJ4cv.js";import{n as we,t as Te}from"./useSearchQuery-bQZP4TsZ.js";import{t as Ee}from"./SkeletonList-Cmqz3hfa.js";import{t as De}from"./EntityLink-Dg93KGVT.js";import{a as Oe,c as ke,i as Ae,n as z,o as B,r as je,s as V,t as H}from"./provider-rate-DU7OgSeB.js";import{t as U}from"./catalog-lU41irIq.js";import{t as W}from"./reliability-CFIkRxVV.js";function Me(e,t){let n=t.trim().toLowerCase();return n?e.filter(e=>e.id.toLowerCase().includes(n)||e.aliases.some(e=>e.toLowerCase().includes(n))):e}function G(e,t,n){let r=new Map(t.models.map(e=>[e.id,e])),i=new Map((n.rows??[]).map(e=>[e.id,e])),a=[];for(let t of e.providers)for(let e of t.models){let n=r.get(e.id),o=i.get(e.id);a.push({id:e.id,model:e.model,providerName:t.name,contextTokens:e.contextTokens,inputPerMTokUsd:e.inputPerMTokUsd,outputPerMTokUsd:e.outputPerMTokUsd,priceSource:e.priceSource,displayFree:e.displayFree,aliases:e.aliases??[],requests:n?.requests??0,tokensIn:n?.tokensIn??0,tokensOut:n?.tokensOut??0,costMicroUsd:n?.costMicroUsd??0,p50Ms:o?.p50Ms,p95Ms:o?.p95Ms,attempts:o?.attempts??0,failures:o?.failures??0})}return a}var Ne={override:`override`,builtin:`builtin`,litellm:`litellm`};function Pe(e){if(e.priceSource===`unpriced`)return a(F,{as:`span`,variant:`destructive`,class:`font-normal`,title:`No pricing rule matched — billed as $0.`},()=>`unpriced`);if(e.priceSource===`free`)return a(F,{as:`span`,variant:`secondary`,class:`font-normal`,title:`Configured free (modelMeta.free) — priced at $0.`},()=>`free`);let t=e.inputPerMTokUsd!==void 0&&e.outputPerMTokUsd!==void 0,n=e.priceSource;return a(`span`,{class:`inline-flex flex-wrap items-center gap-1.5`},[a(`span`,{},t?j(e.inputPerMTokUsd,e.outputPerMTokUsd):`—`),a(F,{as:`span`,variant:`outline`,class:`font-normal`},()=>Ne[n])])}function K(e){return e.priceSource===`unpriced`?-1:e.inputPerMTokUsd??0}function Fe(){return[{id:`id`,header:`Model`,accessorFn:e=>e.id,cell:({row:e})=>a(`span`,{class:`inline-flex flex-wrap items-center gap-1.5`},[a(O,{id:e.original.id,contextTokens:e.original.contextTokens,inputPerMTokUsd:e.original.inputPerMTokUsd,outputPerMTokUsd:e.original.outputPerMTokUsd}),a(De,{label:e.original.id,kind:`model`,id:e.original.id})])},{id:`context`,header:`Context`,meta:{align:`right`},accessorFn:e=>e.contextTokens??0,cell:({row:e})=>a(`span`,{class:`tabular-nums`},e.original.contextTokens===void 0?`—`:ve(e.original.contextTokens))},{id:`price`,header:`Price`,accessorFn:e=>K(e),cell:({row:e})=>Pe(e.original)},{id:`free`,header:`Free`,accessorFn:e=>+!!e.displayFree,cell:({row:e})=>e.original.displayFree?a(F,{as:`span`,variant:`secondary`,class:`font-normal`,title:`':free' suffix model — display-only, billing follows the Price column's own source`},()=>`free`):a(`span`,{class:`text-muted-foreground`},`—`)},{id:`aliases`,header:`Aliases`,enableSorting:!1,accessorFn:e=>e.aliases.join(`, `),cell:({row:e})=>{let t=e.original.aliases;return t.length===0?a(`span`,{class:`text-muted-foreground`},`—`):a(`div`,{class:`flex flex-wrap gap-1`},t.map(e=>a(F,{key:e,as:`span`,variant:`outline`,class:`font-mono font-normal`},()=>e)))}},{id:`requests`,header:`Requests`,meta:{align:`right`},accessorFn:e=>e.requests,cell:({row:e})=>a(R,{value:e.original.requests})},{id:`tokensIn`,header:`Tokens in`,meta:{align:`right`},accessorFn:e=>e.tokensIn,cell:({row:e})=>a(R,{value:e.original.tokensIn})},{id:`tokensOut`,header:`Tokens out`,meta:{align:`right`},accessorFn:e=>e.tokensOut,cell:({row:e})=>a(R,{value:e.original.tokensOut})},{id:`cost`,header:`Cost`,meta:{align:`right`},accessorFn:e=>e.costMicroUsd,cell:({row:e})=>{let t=e.original;return(t.priceSource===`free`||t.displayFree)&&t.costMicroUsd===0?a(F,{as:`span`,variant:`secondary`,class:`font-normal`,title:`priced at $0 per token`},()=>`free`):P(t.costMicroUsd)}},{id:`p50`,header:`p50`,meta:{align:`right`},accessorFn:e=>e.p50Ms??-1,cell:({row:e})=>a(`span`,{class:`tabular-nums`},e.original.p50Ms===void 0?`—`:N(e.original.p50Ms))},{id:`p95`,header:`p95`,meta:{align:`right`},accessorFn:e=>e.p95Ms??-1,cell:({row:e})=>a(`span`,{class:`tabular-nums`},e.original.p95Ms===void 0?`—`:N(e.original.p95Ms))},{id:`errorRate`,header:`Error rate`,meta:{align:`right`},accessorFn:e=>B(e.attempts,e.failures)??-1,cell:({row:e})=>a(`span`,{class:`tabular-nums`},z(B(e.original.attempts,e.original.failures)))}]}var q=d({__name:`ModelCatalogTable`,props:{rows:{},query:{},latencyEnabled:{type:Boolean},loading:{type:Boolean},error:{},onRetry:{type:Function}},emits:[`update:query`],setup(e,{emit:i}){let a=e,o=i,c=x(),u=y(()=>Me(a.rows,a.query)),d=Fe(),f=y(()=>_e({loading:a.loading,hasData:a.rows.length>0,error:a.error??``})),m=y(()=>a.query.trim()?`no models match "${a.query}"`:`none`);return(i,a)=>(S(),C(_(l),null,{default:r(()=>[v(_(t),null,{default:r(()=>[v(_(s),null,{default:r(()=>[...a[2]||=[b(`Model catalog`,-1)]]),_:1}),v(_(k),null,{default:r(()=>[...a[3]||=[b(` Every configured model: price source, per-model usage for the current range, fleet p50/p95, and error rate. `,-1)]]),_:1}),v(we,{"model-value":e.query,placeholder:`Search models or aliases...`,class:`mt-2 max-w-sm`,"onUpdate:modelValue":a[0]||=e=>o(`update:query`,e)},null,8,[`model-value`])]),_:1}),v(_(E),{class:`flex flex-col gap-3`},{default:r(()=>[e.latencyEnabled?T(``,!0):(S(),C(_(pe),{key:0,variant:`warn`},{default:r(()=>[v(_(he),null,{default:r(()=>[...a[4]||=[b(`Latency statistics are off`,-1)]]),_:1}),v(_(me),{class:`flex flex-wrap items-center gap-2`},{default:r(()=>[a[6]||=p(`span`,null,[b(`Enable `),p(`code`,null,`admin.stats.latency`),b(` in the middleware config to see fleet p50/p95.`)],-1),v(_(n),{type:`button`,variant:`outline`,size:`sm`,onClick:a[1]||=e=>_(c).goTo(`config`)},{default:r(()=>[...a[5]||=[b(`Open Config`,-1)]]),_:1})]),_:1})]),_:1})),f.value===`skeleton`?(S(),C(L,{key:1,rows:5,cols:_(d).length},null,8,[`cols`])):f.value===`error`?(S(),C(ge,{key:2,message:e.error??``,"on-retry":e.onRetry},null,8,[`message`,`on-retry`])):f.value===`empty`?(S(),C(I,{key:3,title:`No models configured.`})):(S(),C(Ce,{key:4,columns:_(d),data:u.value,"empty-message":m.value},null,8,[`columns`,`data`,`empty-message`]))]),_:1})]),_:1}))}}),Ie={"aria-hidden":`true`},J={class:`sr-only`},Le=d({__name:`ProviderRateBadge`,props:{attemptsDay:{},failuresDay:{},attemptsMinute:{},failuresMinute:{}},setup(e){let t=e,n=y(()=>ke(t.attemptsDay,t.failuresDay)),i=y(()=>V(n.value)),a=y(()=>i.value===`no-traffic`?`no traffic`:je(n.value)),o=y(()=>t.attemptsMinute===void 0||t.failuresMinute===void 0?H(t.attemptsDay,t.failuresDay):Oe(t.attemptsMinute,t.failuresMinute)),s=y(()=>i.value===`severe`?`destructive`:i.value===`healthy`?`secondary`:`outline`),l=y(()=>i.value===`degraded`?`border-status-warn/40 text-status-warn`:i.value===`no-traffic`?`text-muted-foreground`:``);return(e,t)=>(S(),C(_(F),{as:`span`,variant:s.value,class:D([l.value,`font-normal tabular-nums`]),title:o.value},{default:r(()=>[p(`span`,Ie,c(a.value),1),p(`span`,J,c(o.value),1)]),_:1},8,[`variant`,`class`,`title`]))}}),Re=f(`models`,{state:()=>({rows:[],providerPerf:[],perfWindow:{window:`day`,span:0},latencyEnabled:!1,loading:!1,lastUpdated:null,error:``,reqId:0}),actions:{async fetch(){let e=++this.reqId;this.loading=!0;try{let t=U(),n=A();if(await t.ensureLoaded(),e!==this.reqId)return;if(!t.data){this.error=t.error||`catalog unavailable`;return}let r=W(n.window,n.span),[i,a,o]=await Promise.all([m(`/admin/api/usage/models?window=${n.window}&span=${n.span}&limit=100&detail=1&metric=req`),m(`/admin/api/performance?kind=model&window=${r.window}&span=${r.span}`),m(`/admin/api/performance?kind=provider&window=${r.window}&span=${r.span}`)]);if(e!==this.reqId)return;this.rows=G(t.data,i,a),this.providerPerf=o.rows??[],this.perfWindow=r,this.latencyEnabled=a.latencyEnabled,this.lastUpdated=new Date,this.error=``}catch(t){if(e!==this.reqId||t instanceof ae&&(t.status===401||t.status===403))return;this.error=t instanceof Error?t.message:String(t)}finally{e===this.reqId&&(this.loading=!1)}}}}),ze={class:`flex flex-col gap-6`},Be={class:`grid gap-4 sm:grid-cols-3`},Ve={class:`font-medium`},He={key:0,class:`flex items-start gap-1.5 text-destructive`},Ue={class:`font-medium`},We={key:0,class:`text-muted-foreground`},Ge={class:`font-medium`},Ke={key:0,class:`text-muted-foreground`},qe={key:3,class:`py-6 text-center text-sm text-muted-foreground`},Je={key:4,class:`py-6 text-center text-sm text-muted-foreground`},Ye={class:`text-xs text-muted-foreground`},Xe={class:`flex items-center gap-2`},Ze=[`aria-label`,`title`,`onClick`],Qe={class:`sr-only`},$e={class:`flex flex-1 flex-wrap items-center gap-x-3 gap-y-1 pr-2 text-left`},et={class:`text-xs text-muted-foreground tabular-nums`},tt={class:`text-xs text-muted-foreground`},nt={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-3`},rt={class:`break-all`},it={key:0},at={key:1},ot={class:`text-destructive`},st={key:0,class:`flex flex-wrap gap-1.5`},ct={key:0,title:`context window`,class:`text-xs text-muted-foreground tabular-nums`},lt={key:1,class:`text-sm text-muted-foreground`},ut={key:0,class:`text-xs text-muted-foreground`},Y=d({__name:`ProviderHealthPanel`,setup(u){let d=te(),f=Re(),m=y(()=>d.overview),ae=x();function A(e){ae.goTo(`models`,{q:`${e}/`})}let j=ne({manuallyExpanded:new Set,manuallyCollapsed:new Set}),{query:P,normalized:I,hasQuery:L}=Te();function R(e,t){return M(e,t).toLowerCase().includes(I.value)}function Oe(e){return e.models.some(t=>R(e.name,t))}function ke(e){return e.alias.toLowerCase().includes(I.value)||e.target.toLowerCase().includes(I.value)}let z=y(()=>_e({loading:!0,hasData:m.value!==null,error:d.error})),B=y(()=>{let e=m.value?.providers??[];return L.value?e.filter(Oe):e}),je=y(()=>{let e=m.value?.aliases??[];return L.value?e.filter(ke):e}),V=y(()=>ce(j,L.value,B.value.map(e=>e.name)));function H(e){ue(j,e,V.value.has(e))}let U=y({get:()=>Array.from(V.value),set:e=>{let t=new Set(e);for(let e of V.value)t.has(e)||H(e);for(let e of t)V.value.has(e)||H(e)}});e(P,e=>{e.trim()===``&&fe(j)});function W(e){return L.value?e.models.filter(t=>R(e.name,t)):e.models}let Me={attemptsDay:0,failuresDay:0};function G(e,t){return e.modelRates?.[t]??Me}function Ne(e,t){let n=G(e,t);return Ae(n.attemptsDay,n.failuresDay)}let Pe={};function K(e,t){return e.modelMeta?.[t]??Pe}function Fe(e){switch(e){case`open`:return`destructive`;case`half-open`:return`secondary`;default:return}}function q(e){let t=Se(e.openUntil);return t?`${e.healthState} (${t})`:e.healthState}function Ie(e){return e===`open`?`text-destructive`:`text-muted-foreground`}function J(e){return e.latency?.streaming}function Y(e){return e.latency?.[`non-streaming`]}function X(e){return e.count===void 0?`no observations counted`:`${e.count} ${e.count===1?`observation`:`observations`} on this replica`}function Z(){let e=m.value?.replica;return`Per-replica (${e?`replica ${e}`:`this replica`}), in-process only — not a fleet-wide average across this deployment’s replicas.`}function dt(e){return`Average time to first byte, the load-sensitive reading for streaming traffic. ${X(e)}. ${Z()}`}function ft(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. ${X(e)}. ${Z()}`}function Q(e){return e.provenance?.estimated}function pt(e){return e.provenance?.unbilled}function mt(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. ${Z()}`}function ht(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. ${Z()}`}function $(e){return f.providerPerf.find(t=>t.id===e)}function gt(e){let{window:t,span:n}=f.perfWindow;return`Fleet-wide (every replica combined) ${e===`p50`?`median`:`95th percentile`} response time, over the last ${n} ${t}${n===1?``:`s`}.`}function _t(e){let{window:t,span:n}=f.perfWindow;return`${e===`timeouts`?`requests that exceeded the deadline`:`requests failed away from this provider to another candidate`}, fleet-wide, over the last ${n} ${t}${n===1?``:`s`}.`}let vt=[{id:`alias`,header:`Alias`,accessorFn:e=>e.alias,cell:({row:e})=>a(O,{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})=>a(`span`,{class:`text-muted-foreground`},e.original.target)}],yt=y(()=>m.value?.aliases.length?L.value?`no aliases match "${P.value}"`:`none`:`none configured`);return(e,a)=>{let u=ie(`FontAwesomeIcon`);return S(),h(`div`,ze,[p(`div`,Be,[v(_(l),null,{default:r(()=>[v(_(t),null,{default:r(()=>[v(_(s),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:r(()=>[v(u,{icon:m.value?.redis.configured?_(g):_(w),class:D([m.value?.redis.configured?`text-chart-requests`:`text-muted-foreground`,`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),a[3]||=b(` Redis `,-1)]),_:1})]),_:1}),v(_(E),{class:`flex flex-col gap-1 text-sm`},{default:r(()=>[p(`p`,Ve,c(m.value?.redis.configured?`Configured`:`Not configured`),1),m.value?.redis.lastErr?(S(),h(`p`,He,[v(u,{icon:_(re),class:`mt-0.5 size-3.5 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),p(`span`,null,c(m.value.redis.lastErr)+c(_(xe)(m.value.redis.lastErrAt)),1)])):T(``,!0)]),_:1})]),_:1}),v(_(l),null,{default:r(()=>[v(_(t),null,{default:r(()=>[v(_(s),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:r(()=>[v(u,{icon:m.value?.cache.enabled?_(g):_(w),class:D([m.value?.cache.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),a[4]||=b(` Response cache `,-1)]),_:1})]),_:1}),v(_(E),{class:`text-sm`},{default:r(()=>[p(`p`,Ue,c(m.value?.cache.enabled?`Enabled`:`Disabled`),1),m.value?.cache.enabled?(S(),h(`p`,We,`ttl `+c(m.value.cache.ttl),1)):T(``,!0)]),_:1})]),_:1}),v(_(l),null,{default:r(()=>[v(_(t),null,{default:r(()=>[v(_(s),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:r(()=>[v(u,{icon:m.value?.retry.enabled?_(g):_(w),class:D([m.value?.retry.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),a[5]||=b(` Retry `,-1)]),_:1})]),_:1}),v(_(E),{class:`text-sm`},{default:r(()=>[p(`p`,Ge,c(m.value?.retry.enabled?`Enabled`:`Disabled`),1),m.value?.retry.enabled?(S(),h(`p`,Ke,` attempts `+c(m.value.retry.attempts)+`, backoff `+c(m.value.retry.backoff),1)):T(``,!0)]),_:1})]),_:1})]),v(_(l),null,{default:r(()=>[v(_(t),null,{default:r(()=>[v(_(s),null,{default:r(()=>[...a[6]||=[b(`Providers`,-1)]]),_:1}),v(_(k),null,{default:r(()=>[...a[7]||=[b(` Every configured upstream, its last discovery refresh, and fleet-wide performance. Search filters providers and aliases by model id. `,-1)]]),_:1}),v(we,{modelValue:_(P),"onUpdate:modelValue":a[0]||=e=>o(P)?P.value=e:null,placeholder:`Search models or aliases...`,class:`mt-2 max-w-sm`},null,8,[`modelValue`])]),_:1}),v(_(E),{class:`flex flex-col gap-3`},{default:r(()=>[_(f).latencyEnabled?T(``,!0):(S(),C(_(pe),{key:0,variant:`warn`},{default:r(()=>[v(_(he),null,{default:r(()=>[...a[8]||=[b(`Latency statistics are off`,-1)]]),_:1}),v(_(me),{class:`flex flex-wrap items-center gap-2`},{default:r(()=>[a[10]||=p(`span`,null,[b(`Enable `),p(`code`,null,`admin.stats.latency`),b(` in the middleware config to see fleet p50/p95.`)],-1),v(_(n),{type:`button`,variant:`outline`,size:`sm`,onClick:a[1]||=e=>_(ae).goTo(`config`)},{default:r(()=>[...a[9]||=[b(`Open Config`,-1)]]),_:1})]),_:1})]),_:1})),z.value===`skeleton`?(S(),C(Ee,{key:1,rows:3})):z.value===`error`?(S(),C(ge,{key:2,message:_(d).error,"on-retry":_(d).refresh},null,8,[`message`,`on-retry`])):m.value?.providers.length?_(L)&&B.value.length===0?(S(),h(`p`,Je,` no providers match "`+c(_(P))+`" `,1)):(S(),h(i,{key:5},[p(`p`,Ye,c(Z())+` Fleet p50/p95/timeouts/failovers below are fleet-wide, not per-replica.`,1),v(_(de),{modelValue:U.value,"onUpdate:modelValue":a[2]||=e=>U.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:r(()=>[(S(!0),h(i,null,ee(B.value,e=>(S(),C(_(oe),{key:e.name,value:e.name},{default:r(()=>[p(`div`,Xe,[p(`button`,{type:`button`,class:`shrink-0 cursor-pointer rounded-sm py-2.5 font-medium hover:text-primary hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50`,"aria-label":`View ${e.name}'s models in the Models table`,title:`View ${e.name}'s models in the Models table`,onClick:t=>A(e.name)},c(e.name),9,Ze),v(_(se),{"header-class":`flex-1`},{default:r(()=>[p(`span`,Qe,`Provider `+c(e.name)+` details`,1),p(`span`,$e,[v(_(F),{as:`span`,variant:`secondary`,class:`font-normal`},{default:r(()=>[b(c(e.type),1)]),_:2},1024),p(`span`,et,c(e.modelCount)+` models`,1),v(Le,{"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`?T(``,!0):(S(),C(_(F),{key:0,as:`span`,variant:Fe(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:r(()=>[b(c(q(e)),1)]),_:2},1032,[`variant`,`title`])),J(e)?.avgTtfbMs===void 0?T(``,!0):(S(),C(_(F),{key:1,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:dt(J(e))},{default:r(()=>[b(` streaming ttfb `+c(_(N)(J(e).avgTtfbMs)),1)]),_:2},1032,[`title`])),Y(e)?.avgDurationMs===void 0?T(``,!0):(S(),C(_(F),{key:2,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:ft(Y(e))},{default:r(()=>[b(` non-streaming avg `+c(_(N)(Y(e).avgDurationMs)),1)]),_:2},1032,[`title`])),$(e.name)?.p50Ms===void 0?T(``,!0):(S(),C(_(F),{key:3,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:gt(`p50`)},{default:r(()=>[b(` fleet p50 `+c(_(N)($(e.name).p50Ms)),1)]),_:2},1032,[`title`])),$(e.name)?.p95Ms===void 0?T(``,!0):(S(),C(_(F),{key:4,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:gt(`p95`)},{default:r(()=>[b(` fleet p95 `+c(_(N)($(e.name).p95Ms)),1)]),_:2},1032,[`title`])),($(e.name)?.timeouts??0)>0?(S(),C(_(F),{key:5,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:_t(`timeouts`)},{default:r(()=>[b(c($(e.name).timeouts)+` timeouts `,1)]),_:2},1032,[`title`])):T(``,!0),($(e.name)?.failovers??0)>0?(S(),C(_(F),{key:6,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:_t(`failovers`)},{default:r(()=>[b(c($(e.name).failovers)+` failovers `,1)]),_:2},1032,[`title`])):T(``,!0),Q(e)?(S(),C(_(F),{key:7,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:mt(Q(e))},{default:r(()=>[b(` estimated `+c(Q(e).requests),1)]),_:2},1032,[`title`])):T(``,!0),pt(e)?(S(),C(_(F),{key:8,as:`span`,variant:`destructive`,class:`font-normal tabular-nums`,title:ht(pt(e))},{default:r(()=>[b(` unbilled `+c(pt(e).requests),1)]),_:2},1032,[`title`])):T(``,!0),e.lastErr?(S(),C(u,{key:9,icon:_(re),class:`size-3.5 shrink-0 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):T(``,!0),p(`span`,tt,c(_(ye)(e.discoveryEnabled,e.lastRefresh)),1)])]),_:2},1024)]),v(_(le),null,{default:r(()=>[p(`dl`,nt,[p(`div`,null,[a[11]||=p(`dt`,{class:`text-xs text-muted-foreground`},`Base URL`,-1),p(`dd`,rt,c(e.baseUrl),1)]),p(`div`,null,[a[12]||=p(`dt`,{class:`text-xs text-muted-foreground`},`Last refresh`,-1),p(`dd`,null,c(_(be)(e.discoveryEnabled,e.lastRefresh)),1)]),e.healthState===`closed`?T(``,!0):(S(),h(`div`,it,[a[13]||=p(`dt`,{class:`text-xs text-muted-foreground`},`Discovery health`,-1),p(`dd`,{class:D(Ie(e.healthState))},c(q(e)),3)])),e.lastErr?(S(),h(`div`,at,[a[14]||=p(`dt`,{class:`text-xs text-muted-foreground`},`Last error`,-1),p(`dd`,ot,c(e.lastErr),1)])):T(``,!0)]),W(e).length?(S(),h(`div`,st,[(S(!0),h(i,null,ee(W(e),t=>(S(),h(`span`,{key:t,class:`inline-flex min-w-0 max-w-full items-center gap-1`},[v(O,{id:_(M)(e.name,t),"context-tokens":K(e,t).contextTokens,"input-per-m-tok-usd":K(e,t).inputPerMTokUsd,"output-per-m-tok-usd":K(e,t).outputPerMTokUsd},null,8,[`id`,`context-tokens`,`input-per-m-tok-usd`,`output-per-m-tok-usd`]),v(De,{label:_(M)(e.name,t),kind:`model`,id:_(M)(e.name,t),class:`min-w-0`,"label-class":`truncate`},null,8,[`label`,`id`]),K(e,t).contextTokens===void 0?T(``,!0):(S(),h(`span`,ct,c(_(ve)(K(e,t).contextTokens)),1)),Ne(e,t)?(S(),C(Le,{key:1,"attempts-day":G(e,t).attemptsDay,"failures-day":G(e,t).failuresDay},null,8,[`attempts-day`,`failures-day`])):T(``,!0)]))),128))])):(S(),h(`p`,lt,`no models known yet`))]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])],64)):(S(),h(`p`,qe,`none`))]),_:1})]),_:1}),v(_(l),null,{default:r(()=>[v(_(t),null,{default:r(()=>[v(_(s),null,{default:r(()=>[...a[15]||=[b(`Model aliases`,-1)]]),_:1}),v(_(k),null,{default:r(()=>[...a[16]||=[b(`Operator-defined alias → target model mappings.`,-1)]]),_:1})]),_:1}),v(_(E),null,{default:r(()=>[v(Ce,{columns:vt,data:je.value,"empty-message":yt.value},null,8,[`data`,`empty-message`])]),_:1})]),_:1}),m.value?.version?(S(),h(`p`,ut,`Version: `+c(m.value.version),1)):T(``,!0)])}}}),X={class:`flex flex-col gap-6`},Z={key:0,class:`text-sm break-words text-destructive`},dt=d({__name:`ModelsPage`,setup(t){let n=A(),r=Re(),i=x(),a=y({get:()=>i.params.q??i.params.model??``,set:e=>{let{model:t,...n}=i.params;i.goTo(`models`,{...n,q:e})}});return u(()=>void r.fetch()),e(()=>n.range,()=>void r.fetch()),(e,t)=>(S(),h(`div`,X,[v(Y),_(r).error&&_(r).rows.length>0?(S(),h(`p`,Z,c(_(r).error),1)):T(``,!0),v(q,{rows:_(r).rows,query:a.value,"latency-enabled":_(r).latencyEnabled,loading:_(r).loading,error:_(r).error,"on-retry":_(r).fetch,"onUpdate:query":t[0]||=e=>a.value=e},null,8,[`rows`,`query`,`latency-enabled`,`loading`,`error`,`on-retry`])]))}});export{dt as default};",
		),
	},
	"ReliabilityPage-6-bz5x6z.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{Ar as e,C as t,E as n,Fr as r,Jt as i,On as a,Qr as o,S as s,Si as c,T as l,Xn as u,_n as d,an as f,cn as p,cr as m,er as h,et as g,g as _,gi as v,hn as y,in as b,mn as x,mt as S,n as C,nr as w,on as T,sn as E,ur as D,vt as ee,w as O}from"./Skeleton-B0ziB6Od.js";import{a as te,c as k,g as A,h as j,i as M,m as ne,n as re,o as ie,r as ae,t as N}from"./index-dywS8OpT.js";import{t as P}from"./ErrorState-ym6eSlj2.js";import{_ as F,f as I,r as L,t as R,v as oe}from"./badge-DUiBTDyA.js";import{o as z,t as se}from"./DataTable-CQxRVDSY.js";import{n as ce,t as B}from"./useSearchQuery-bQZP4TsZ.js";import{t as V}from"./SkeletonList-Cmqz3hfa.js";import{n as H,t as U}from"./TimeSeriesChart-BFcT6woA.js";import{t as W}from"./events-PUxhEega.js";import{i as G,n as K,r as le,t as ue}from"./events-filter-XFnjIaR7.js";import{n as de}from"./provider-rate-DU7OgSeB.js";import{n as fe,r as pe}from"./reliability-CFIkRxVV.js";function q(e){return K[e]??e}function me(e){return e.user?`user:${e.user}`:e.group?`group:${e.group}`:`—`}function J(e){let t=[e.model,e.provider].filter(e=>!!e);return t.length?t.join(` → `):`—`}function he(){return[{id:`time`,header:`Time`,accessorFn:e=>e.time,cell:({row:e})=>a(`span`,{class:`text-muted-foreground tabular-nums`},I(e.original.time))},{id:`kind`,header:`Kind`,accessorFn:e=>e.kind,cell:({row:e})=>a(R,{as:`span`,variant:le(e.original.kind),class:`font-normal`},()=>q(e.original.kind))},{id:`route`,header:`Route`,accessorFn:e=>e.route,cell:({row:e})=>a(`span`,{class:`font-mono text-xs`},e.original.route)},{id:`scope`,header:`User / group`,enableSorting:!1,accessorFn:e=>e.user??e.group??``,cell:({row:e})=>{let t=me(e.original);return a(`span`,{class:t===`—`?`text-muted-foreground`:void 0},t)}},{id:`target`,header:`Model / provider`,enableSorting:!1,accessorFn:e=>`${e.model??``} ${e.provider??``}`,cell:({row:e})=>{let t=J(e.original);return a(`span`,{class:t===`—`?`text-muted-foreground`:`font-mono text-xs`},t)}},{id:`replica`,header:`Replica`,accessorFn:e=>e.replica,cell:({row:e})=>a(`span`,{class:`text-muted-foreground`},e.original.replica)},{id:`status`,header:`Status`,meta:{align:`right`},accessorFn:e=>e.status??0,cell:({row:e})=>a(`span`,{class:`tabular-nums`},e.original.status===void 0?`—`:String(e.original.status))},{id:`message`,header:`Message`,enableSorting:!1,accessorFn:e=>e.message,cell:({row:e})=>a(`span`,{class:`text-muted-foreground`},e.original.message)}]}var Y={class:`flex flex-col gap-6`},X={class:`flex flex-wrap items-center gap-3`},Z=`all`,ge=d({__name:`EventsView`,setup(e){let n=W(),{kindFilter:a,userFilter:d}=ee(n),{normalized:_}=B(d),C=b(()=>a.value===``?Z:a.value),N=b(()=>G(n.events,{kind:a.value,user:_.value}));function I(e){typeof e==`string`&&n.setKindFilter(e===Z?``:e)}let L=he(),R=b(()=>F({loading:n.refreshing,hasData:n.lastUpdated!==null,error:n.error})),V=b(()=>n.events.length===0),H=b(()=>a.value!==``||_.value?`no events match the current filter`:`none`),U=b(()=>n.source===`redis`?`Fleet-wide, across every replica`:`This replica only (${n.replica||`unknown`}) — Redis is unreachable or unconfigured`);return u(()=>{n.startPolling()}),h(()=>{n.stopPolling()}),(e,a)=>{let u=D(`FontAwesomeIcon`);return w(),p(`div`,Y,[v(n).degraded?(w(),T(v(A),{key:0,variant:`destructive`},{default:r(()=>[y(u,{icon:v(S),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`]),y(v(ne),null,{default:r(()=>[...a[1]||=[x(`Fleet-wide event log unavailable`,-1)]]),_:1}),y(v(j),null,{default:r(()=>[...a[2]||=[x(` Redis is configured but could not be read — showing this replica's own in-memory events only, which may miss events recorded by other replicas. `,-1)]]),_:1})]),_:1})):E(``,!0),y(v(l),null,{default:r(()=>[y(v(t),{class:`flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between`},{default:r(()=>[f(`div`,null,[y(v(s),null,{default:r(()=>[...a[3]||=[x(`Events`,-1)]]),_:1}),R.value===`ready`?(w(),T(v(k),{key:0},{default:r(()=>[x(c(U.value)+` — rate limit, budget, and upstream events, newest first (capacity `+c(v(n).capacity)+`). `,1)]),_:1})):E(``,!0)]),f(`div`,X,[y(ce,{modelValue:v(d),"onUpdate:modelValue":a[0]||=e=>o(d)?d.value=e:null,placeholder:`Filter by user or group`,class:`w-56`},null,8,[`modelValue`]),y(v(ie),{"model-value":C.value,"onUpdate:modelValue":I},{default:r(()=>[y(v(ae),{class:`w-44`,"aria-label":`Filter by kind`},{default:r(()=>[y(v(re),{placeholder:`Kind`})]),_:1}),y(v(te),null,{default:r(()=>[y(v(M),{value:Z},{default:r(()=>[...a[4]||=[x(`All kinds`,-1)]]),_:1}),(w(!0),p(i,null,m(v(ue),e=>(w(),T(v(M),{key:e,value:e},{default:r(()=>[x(c(v(K)[e]),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),_:1}),y(v(O),null,{default:r(()=>[R.value===`skeleton`?(w(),T(z,{key:0,rows:5,cols:v(L).length},null,8,[`cols`])):R.value===`error`?(w(),T(P,{key:1,message:v(n).error,"on-retry":v(n).refresh},null,8,[`message`,`on-retry`])):V.value?(w(),T(oe,{key:2,icon:v(g),title:`No failures recorded.`,description:`Rate-limit, budget, and upstream events will show up here as they happen.`},null,8,[`icon`])):(w(),T(se,{key:3,columns:v(L),data:N.value,"empty-message":H.value},null,8,[`columns`,`data`,`empty-message`]))]),_:1})]),_:1})])}}}),_e={class:`flex flex-col gap-6`},ve={class:`flex flex-col gap-1`},ye={key:2,class:`text-sm break-words text-destructive`},be={key:3,class:`text-sm text-muted-foreground`},xe={key:0,class:`text-sm text-muted-foreground`},Se={key:2,class:`grid gap-6 lg:grid-cols-2`},Ce={class:`grid gap-6 lg:grid-cols-2`},Q=`all`,we=d({__name:`ReliabilityPage`,setup(a){let o=_(),d=W(),h=N(),g=C(),S=pe(),D=b(()=>g.params.provider??``),ee=b(()=>D.value||Q);function I(e){typeof e==`string`&&g.goTo(`reliability`,{...g.params,provider:e===Q?``:e})}function R(e){return e.replace(/^provider:/,``)}function z(e){return D.value?e.filter(e=>R(e.scope)===D.value):e}function se(e){return e.map(e=>e===null?NaN:e)}let ce=b(()=>z(S.errorRate).map((e,t)=>({label:R(e.scope),data:se(e.points),color:fe(t)})));function B(e){return z(e).map((e,t)=>({label:R(e.scope),data:e.points,color:fe(t)}))}let G=b(()=>B(S.timeouts)),K=b(()=>B(S.failovers)),le=b(()=>[{label:`429 rejections`,data:S.rejections,color:`--destructive`}]),ue=b(()=>[{label:`402 unpriced refusals`,data:S.unpriced,color:`--status-warn`}]),q=b(()=>S.buckets.map(e=>L(e,S.windowUsed)));function me(e){return de(Number.isNaN(e)?null:e)}let J=b(()=>(o.overview?.providers.length??0)>0),he=b(()=>o.overview!==null&&o.overview.features.failover===!1),Y=b(()=>F({loading:!o.lastUpdated,hasData:o.overview!==null,error:o.error})),X=b(()=>Y.value===`ready`?J.value?`ready`:`empty`:Y.value),Z=b(()=>o.overview?.features.latencyStats??!1),we=b(()=>D.value!==``&&Z.value),Te=b(()=>S.providerPerfBuckets.map(e=>L(e,S.providerPerfWindowUsed))),Ee=b(()=>[{label:`p50`,data:S.providerPerfPoints.map(e=>e.p50Ms??NaN),color:`--chart-requests`},{label:`p95`,data:S.providerPerfPoints.map(e=>e.p95Ms??NaN),color:`--chart-tokens-in`}]),De=b(()=>[{label:`failures`,data:S.providerPerfPoints.map(e=>e.failures),color:`--destructive`}]);e(()=>[D.value,h.range],([e])=>void S.fetchProviderPerf(e),{immediate:!0});let Oe=b(()=>h.window===`month`),$=b(()=>Y.value===`ready`?F({loading:S.loading,hasData:S.buckets.length>0,error:S.error}):Y.value),ke=b(()=>F({loading:S.providerPerfLoading,hasData:S.providerPerfPoints.length>0,error:S.providerPerfError}));return e(()=>[h.range,o.overview?.providers.length??0],()=>void S.fetch()),e(()=>[d.kindFilter,d.userFilter],([e,t])=>{g.goTo(`reliability`,{...g.params,kind:e,user:t})}),e(()=>[g.params.kind,g.params.user],([e,t])=>{d.setKindFilter(e??``),d.setUserFilter(t??``)},{immediate:!0}),u(()=>void S.fetch()),(e,a)=>(w(),p(`div`,_e,[y(v(l),null,{default:r(()=>[y(v(t),{class:`flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between`},{default:r(()=>[f(`div`,null,[y(v(s),null,{default:r(()=>[...a[1]||=[x(`Reliability`,-1)]]),_:1}),y(v(k),null,{default:r(()=>[...a[2]||=[x(`Provider error rate, failovers, timeouts, rate-limit rejections, and 402 refusals.`,-1)]]),_:1})]),f(`div`,ve,[a[4]||=f(`label`,{id:`reliability-provider-label`,class:`text-xs font-medium text-muted-foreground`},`Provider`,-1),y(v(ie),{"model-value":ee.value,"onUpdate:modelValue":I},{default:r(()=>[y(v(ae),{"aria-labelledby":`reliability-provider-label`,class:`w-48`},{default:r(()=>[y(v(re),{placeholder:`All providers`})]),_:1}),y(v(te),null,{default:r(()=>[y(v(M),{value:Q},{default:r(()=>[...a[3]||=[x(`All providers`,-1)]]),_:1}),(w(!0),p(i,null,m(v(o).overview?.providers??[],e=>(w(),T(v(M),{key:e.name,value:e.name},{default:r(()=>[x(c(e.name),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),_:1}),y(v(O),null,{default:r(()=>[Y.value===`skeleton`?(w(),T(V,{key:0,rows:2})):Y.value===`error`?(w(),T(P,{key:1,message:v(o).error,"on-retry":v(o).refresh},null,8,[`message`,`on-retry`])):v(S).error?(w(),p(`p`,ye,c(v(S).error),1)):J.value?E(``,!0):(w(),p(`p`,be,`No providers configured.`))]),_:1})]),_:1}),Oe.value?(w(),T(v(A),{key:0,variant:`warn`},{default:r(()=>[y(v(j),null,{default:r(()=>[x(` Reliability data has no monthly retention — every chart below shows the most recent 30 days, not the full `+c(v(h).range)+` range selected above. `,1)]),_:1})]),_:1})):E(``,!0),X.value===`skeleton`?(w(),p(i,{key:1},[y(v(l),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(s),null,{default:r(()=>[...a[5]||=[x(`Error rate by provider`,-1)]]),_:1})]),_:1}),y(v(O),null,{default:r(()=>[y(H)]),_:1})]),_:1}),y(v(l),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(s),null,{default:r(()=>[...a[6]||=[x(`Selected provider performance`,-1)]]),_:1})]),_:1}),y(v(O),null,{default:r(()=>[y(H)]),_:1})]),_:1}),y(v(l),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(s),null,{default:r(()=>[...a[7]||=[x(`Timeouts by provider`,-1)]]),_:1})]),_:1}),y(v(O),null,{default:r(()=>[y(H)]),_:1})]),_:1}),y(v(l),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(s),null,{default:r(()=>[...a[8]||=[x(`Failovers by provider`,-1)]]),_:1})]),_:1}),y(v(O),null,{default:r(()=>[y(H)]),_:1})]),_:1})],64)):X.value===`empty`?(w(),T(v(l),{key:2},{default:r(()=>[y(v(O),null,{default:r(()=>[y(oe,{title:`No providers configured.`,description:`Add a providers entry to the middleware config to see per-provider reliability charts here.`})]),_:1})]),_:1})):X.value===`ready`?(w(),p(i,{key:3},[y(v(l),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(s),null,{default:r(()=>[...a[9]||=[x(`Error rate by provider`,-1)]]),_:1}),y(v(k),null,{default:r(()=>[...a[10]||=[x(`Failed attempts / total attempts per bucket. A gap means no attempts in that bucket.`,-1)]]),_:1})]),_:1}),y(v(O),null,{default:r(()=>[$.value===`skeleton`?(w(),T(H,{key:0})):$.value===`error`?(w(),T(P,{key:1,message:v(S).error,"on-retry":v(S).fetch},null,8,[`message`,`on-retry`])):(w(),T(U,{key:2,labels:q.value,datasets:ce.value,"value-formatter":me,ariaLabel:`Error rate by provider over time`},null,8,[`labels`,`datasets`]))]),_:1})]),_:1}),y(v(l),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(s),null,{default:r(()=>[...a[11]||=[x(`Selected provider performance`,-1)]]),_:1}),y(v(k),null,{default:r(()=>[...a[12]||=[x(`Latency (p50/p95) and failures per bucket for one provider.`,-1)]]),_:1})]),_:1}),y(v(O),{class:`flex flex-col gap-4`},{default:r(()=>[D.value===``?(w(),p(`p`,xe,` Select a provider above to see its latency and failure breakdown per bucket. `)):Z.value?we.value?(w(),p(i,{key:2},[ke.value===`skeleton`?(w(),T(H,{key:0})):ke.value===`error`?(w(),T(P,{key:1,message:v(S).providerPerfError,"on-retry":()=>v(S).fetchProviderPerf(D.value)},null,8,[`message`,`on-retry`])):(w(),p(`div`,Se,[f(`div`,null,[a[17]||=f(`p`,{class:`mb-2 text-sm font-medium text-muted-foreground`},`Latency (ms)`,-1),y(U,{labels:Te.value,datasets:Ee.value,ariaLabel:`p50/p95 latency for ${D.value} over time`},null,8,[`labels`,`datasets`,`ariaLabel`])]),f(`div`,null,[a[18]||=f(`p`,{class:`mb-2 text-sm font-medium text-muted-foreground`},`Failures`,-1),y(U,{labels:Te.value,datasets:De.value,ariaLabel:`Failures for ${D.value} over time`},null,8,[`labels`,`datasets`,`ariaLabel`])])]))],64)):E(``,!0):(w(),T(v(A),{key:1,variant:`warn`},{default:r(()=>[y(v(ne),null,{default:r(()=>[...a[13]||=[x(`Latency statistics are off`,-1)]]),_:1}),y(v(j),{class:`flex flex-wrap items-center gap-2`},{default:r(()=>[f(`span`,null,[a[14]||=x(`Enable `,-1),a[15]||=f(`code`,{class:`font-mono text-xs`},`admin.stats.latency`,-1),x(` in the middleware config to see per-bucket latency for `+c(D.value)+`.`,1)]),y(v(n),{type:`button`,variant:`outline`,size:`sm`,onClick:a[0]||=e=>v(g).goTo(`config`)},{default:r(()=>[...a[16]||=[x(`Open Config`,-1)]]),_:1})]),_:1})]),_:1}))]),_:1})]),_:1}),y(v(l),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(s),null,{default:r(()=>[...a[19]||=[x(`Timeouts by provider`,-1)]]),_:1})]),_:1}),y(v(O),null,{default:r(()=>[$.value===`skeleton`?(w(),T(H,{key:0})):$.value===`error`?(w(),T(P,{key:1,message:v(S).error,"on-retry":v(S).fetch},null,8,[`message`,`on-retry`])):(w(),T(U,{key:2,labels:q.value,datasets:G.value,ariaLabel:`Timeouts by provider over time`},null,8,[`labels`,`datasets`]))]),_:1})]),_:1}),y(v(l),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(s),null,{default:r(()=>[...a[20]||=[x(`Failovers by provider`,-1)]]),_:1}),he.value?(w(),T(v(k),{key:0},{default:r(()=>[...a[21]||=[x(`This deployment has no failover chains configured.`,-1)]]),_:1})):E(``,!0)]),_:1}),y(v(O),null,{default:r(()=>[$.value===`skeleton`?(w(),T(H,{key:0})):$.value===`error`?(w(),T(P,{key:1,message:v(S).error,"on-retry":v(S).fetch},null,8,[`message`,`on-retry`])):(w(),T(U,{key:2,labels:q.value,datasets:K.value,ariaLabel:`Failovers by provider over time`},null,8,[`labels`,`datasets`]))]),_:1})]),_:1})],64)):E(``,!0),f(`div`,Ce,[y(v(l),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(s),null,{default:r(()=>[...a[22]||=[x(`Rate-limit rejections (429)`,-1)]]),_:1}),y(v(k),null,{default:r(()=>[...a[23]||=[x(`Fleet-wide, every scope combined.`,-1)]]),_:1})]),_:1}),y(v(O),null,{default:r(()=>[$.value===`skeleton`?(w(),T(H,{key:0})):$.value===`error`?(w(),T(P,{key:1,message:v(S).error,"on-retry":v(S).fetch},null,8,[`message`,`on-retry`])):(w(),T(U,{key:2,labels:q.value,datasets:le.value,ariaLabel:`Rate-limit rejections over time, fleet-wide`},null,8,[`labels`,`datasets`]))]),_:1})]),_:1}),y(v(l),null,{default:r(()=>[y(v(t),null,{default:r(()=>[y(v(s),null,{default:r(()=>[...a[24]||=[x(`Unpriced refusals (402)`,-1)]]),_:1}),y(v(k),null,{default:r(()=>[...a[25]||=[x(`Fleet-wide requests refused for having no resolvable price.`,-1)]]),_:1})]),_:1}),y(v(O),null,{default:r(()=>[$.value===`skeleton`?(w(),T(H,{key:0})):$.value===`error`?(w(),T(P,{key:1,message:v(S).error,"on-retry":v(S).fetch},null,8,[`message`,`on-retry`])):(w(),T(U,{key:2,labels:q.value,datasets:ue.value,ariaLabel:`Unpriced refusals (402) over time, fleet-wide`},null,8,[`labels`,`datasets`]))]),_:1})]),_:1})]),y(ge)]))}});export{we as default};",
		),
	},
	"Skeleton-B0ziB6Od.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"function e(e){let t=Object.create(null);for(let n of e.split(`,`))t[n]=1;return e=>e in t}var t={},n=[],r=()=>{},i=()=>!1,a=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&(e.charCodeAt(2)>122||e.charCodeAt(2)<97),o=e=>e.startsWith(`onUpdate:`),s=Object.assign,c=(e,t)=>{let n=e.indexOf(t);n>-1&&e.splice(n,1)},l=Object.prototype.hasOwnProperty,u=(e,t)=>l.call(e,t),d=Array.isArray,f=e=>S(e)===`[object Map]`,p=e=>S(e)===`[object Set]`,m=e=>S(e)===`[object Date]`,h=e=>S(e)===`[object RegExp]`,g=e=>typeof e==`function`,_=e=>typeof e==`string`,v=e=>typeof e==`symbol`,y=e=>typeof e==`object`&&!!e,b=e=>(y(e)||g(e))&&g(e.then)&&g(e.catch),x=Object.prototype.toString,S=e=>x.call(e),C=e=>S(e).slice(8,-1),w=e=>S(e)===`[object Object]`,T=e=>_(e)&&e!==`NaN`&&e[0]!==`-`&&``+parseInt(e,10)===e,E=e(`,key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted`),D=e=>{let t=Object.create(null);return(n=>t[n]||(t[n]=e(n)))},ee=/-\w/g,O=D(e=>e.replace(ee,e=>e.slice(1).toUpperCase())),te=/\B([A-Z])/g,k=D(e=>e.replace(te,`-$1`).toLowerCase()),A=D(e=>e.charAt(0).toUpperCase()+e.slice(1)),ne=D(e=>e?`on${A(e)}`:``),j=(e,t)=>!Object.is(e,t),M=(e,...t)=>{for(let n=0;n<e.length;n++)e[n](...t)},N=(e,t,n,r=!1)=>{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:r,value:n})},re=e=>{let t=parseFloat(e);return isNaN(t)?e:t},ie=e=>{let t=_(e)?Number(e):NaN;return isNaN(t)?e:t},ae,oe=()=>ae||=typeof globalThis<`u`?globalThis:typeof self<`u`?self:typeof window<`u`?window:typeof global<`u`?global:{},P=e(`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 F(e){if(d(e)){let t={};for(let n=0;n<e.length;n++){let r=e[n],i=_(r)?le(r):F(r);if(i)for(let e in i)t[e]=i[e]}return t}if(_(e)||y(e))return e}var se=/;(?![^(]*\))/g,ce=/:([^]+)/,I=/\/\*[^]*?\*\//g;function le(e){let t={};return e.replace(I,``).split(se).forEach(e=>{if(e){let n=e.split(ce);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}function L(e){let t=``;if(_(e))t=e;else if(d(e))for(let n=0;n<e.length;n++){let r=L(e[n]);r&&(t+=r+` `)}else if(y(e))for(let n in e)e[n]&&(t+=n+` `);return t.trim()}function ue(e){if(!e)return null;let{class:t,style:n}=e;return t&&!_(t)&&(e.class=L(t)),n&&(e.style=F(n)),e}var de=`itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`,fe=e(de);de+``;function pe(e){return!!e||e===``}function me(e,t){if(e.length!==t.length)return!1;let n=!0;for(let r=0;n&&r<e.length;r++)n=he(e[r],t[r]);return n}function he(e,t){if(e===t)return!0;let n=m(e),r=m(t);if(n||r)return n&&r?e.getTime()===t.getTime():!1;if(n=v(e),r=v(t),n||r)return e===t;if(n=d(e),r=d(t),n||r)return n&&r?me(e,t):!1;if(n=y(e),r=y(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||!he(e[n],t[n]))return!1}}return String(e)===String(t)}function ge(e,t){return e.findIndex(e=>he(e,t))}var _e=e=>!!(e&&e.__v_isRef===!0),ve=e=>_(e)?e:e==null?``:d(e)||y(e)&&(e.toString===x||!g(e.toString))?_e(e)?ve(e.value):JSON.stringify(e,ye,2):String(e),ye=(e,t)=>_e(t)?ye(e,t.value):f(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((e,[t,n],r)=>(e[be(t,r)+` =>`]=n,e),{})}:p(t)?{[`Set(${t.size})`]:[...t.values()].map(e=>be(e))}:v(t)?be(t):y(t)&&!d(t)&&!w(t)?String(t):t,be=(e,t=``)=>v(e)?`Symbol(${e.description??t})`:e;function xe(e){return e==null?`initial`:typeof e==`string`?e===``?` `:e:String(e)}var R,Se=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&&R&&(R.active?(this.parent=R,this.index=(R.scopes||(R.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=R;try{return R=this,e()}finally{R=t}}}on(){++this._on===1&&(this.prevScope=R,R=this)}off(){if(this._on>0&&--this._on===0){if(R===this)R=this.prevScope;else{let e=R;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 Ce(e){return new Se(e)}function we(){return R}function Te(e,t=!1){R&&R.cleanups.push(e)}var z,Ee=new WeakSet,De=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,R&&(R.active?R.effects.push(this):this.flags&=-2)}pause(){this.flags|=64}resume(){this.flags&64&&(this.flags&=-65,Ee.has(this)&&(Ee.delete(this),this.trigger()))}notify(){this.flags&2&&!(this.flags&32)||this.flags&8||je(this)}run(){if(!(this.flags&1))return this.fn();this.flags|=2,Ke(this),Pe(this);let e=z,t=He;z=this,He=!0;try{return this.fn()}finally{Fe(this),z=e,He=t,this.flags&=-3}}stop(){if(this.flags&1){for(let e=this.deps;e;e=e.nextDep)Re(e);this.deps=this.depsTail=void 0,Ke(this),this.onStop&&this.onStop(),this.flags&=-2}}trigger(){this.flags&64?Ee.add(this):this.scheduler?this.scheduler():this.runIfDirty()}runIfDirty(){Ie(this)&&this.run()}get dirty(){return Ie(this)}},Oe=0,ke,Ae;function je(e,t=!1){if(e.flags|=8,t){e.next=Ae,Ae=e;return}e.next=ke,ke=e}function Me(){Oe++}function Ne(){if(--Oe>0)return;if(Ae){let e=Ae;for(Ae=void 0;e;){let t=e.next;e.next=void 0,e.flags&=-9,e=t}}let e;for(;ke;){let t=ke;for(ke=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 Pe(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function Fe(e){let t,n=e.depsTail,r=n;for(;r;){let e=r.prevDep;r.version===-1?(r===n&&(n=e),Re(r),ze(r)):t=r,r.dep.activeLink=r.prevActiveLink,r.prevActiveLink=void 0,r=e}e.deps=t,e.depsTail=n}function Ie(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(Le(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function Le(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===qe)||(e.globalVersion=qe,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!Ie(e))))return;e.flags|=2;let t=e.dep,n=z,r=He;z=e,He=!0;try{Pe(e);let n=e.fn(e._value);(t.version===0||j(n,e._value))&&(e.flags|=128,e._value=n,t.version++)}catch(e){throw t.version++,e}finally{z=n,He=r,Fe(e),e.flags&=-3}}function Re(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)Re(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 Be(e,t){e.effect instanceof De&&(e=e.effect.fn);let n=new De(e);t&&s(n,t);try{n.run()}catch(e){throw n.stop(),e}let r=n.run.bind(n);return r.effect=n,r}function Ve(e){e.effect.stop()}var He=!0,Ue=[];function We(){Ue.push(He),He=!1}function Ge(){let e=Ue.pop();He=e===void 0||e}function Ke(e){let{cleanup:t}=e;if(e.cleanup=void 0,t){let e=z;z=void 0;try{t()}finally{z=e}}}var qe=0,Je=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}},Ye=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(!z||!He||z===this.computed)return;let t=this.activeLink;if(t===void 0||t.sub!==z)t=this.activeLink=new Je(z,this),z.deps?(t.prevDep=z.depsTail,z.depsTail.nextDep=t,z.depsTail=t):z.deps=z.depsTail=t,Xe(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=z.depsTail,t.nextDep=void 0,z.depsTail.nextDep=t,z.depsTail=t,z.deps===t&&(z.deps=e)}return t}trigger(e){this.version++,qe++,this.notify(e)}notify(e){Me();try{for(let e=this.subs;e;e=e.prevSub)e.sub.notify()&&e.sub.dep.notify()}finally{Ne()}}};function Xe(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)Xe(e)}let n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}var Ze=new WeakMap,Qe=Symbol(``),$e=Symbol(``),et=Symbol(``);function B(e,t,n){if(He&&z){let t=Ze.get(e);t||Ze.set(e,t=new Map);let r=t.get(n);r||(t.set(n,r=new Ye),r.map=t,r.key=n),r.track()}}function tt(e,t,n,r,i,a){let o=Ze.get(e);if(!o){qe++;return}let s=e=>{e&&e.trigger()};if(Me(),t===`clear`)o.forEach(s);else{let i=d(e),a=i&&T(n);if(i&&n===`length`){let e=Number(r);o.forEach((t,n)=>{(n===`length`||n===et||!v(n)&&n>=e)&&s(t)})}else switch((n!==void 0||o.has(void 0))&&s(o.get(n)),a&&s(o.get(et)),t){case`add`:i?a&&s(o.get(`length`)):(s(o.get(Qe)),f(e)&&s(o.get($e)));break;case`delete`:i||(s(o.get(Qe)),f(e)&&s(o.get($e)));break;case`set`:f(e)&&s(o.get(Qe))}}Ne()}function nt(e,t){let n=Ze.get(e);return n&&n.get(t)}function rt(e){let t=V(e);return t===e?t:(B(t,`iterate`,et),Gt(e)?t:t.map(Jt))}function it(e){return B(e=V(e),`iterate`,et),e}function at(e,t){return Wt(e)?Yt(Ut(e)?Jt(t):t):Jt(t)}var ot={__proto__:null,[Symbol.iterator](){return st(this,Symbol.iterator,e=>at(this,e))},concat(...e){return rt(this).concat(...e.map(e=>d(e)?rt(e):e))},entries(){return st(this,`entries`,e=>(e[1]=at(this,e[1]),e))},every(e,t){return lt(this,`every`,e,t,void 0,arguments)},filter(e,t){return lt(this,`filter`,e,t,e=>e.map(e=>at(this,e)),arguments)},find(e,t){return lt(this,`find`,e,t,e=>at(this,e),arguments)},findIndex(e,t){return lt(this,`findIndex`,e,t,void 0,arguments)},findLast(e,t){return lt(this,`findLast`,e,t,e=>at(this,e),arguments)},findLastIndex(e,t){return lt(this,`findLastIndex`,e,t,void 0,arguments)},forEach(e,t){return lt(this,`forEach`,e,t,void 0,arguments)},includes(...e){return dt(this,`includes`,e)},indexOf(...e){return dt(this,`indexOf`,e)},join(e){return rt(this).join(e)},lastIndexOf(...e){return dt(this,`lastIndexOf`,e)},map(e,t){return lt(this,`map`,e,t,void 0,arguments)},pop(){return ft(this,`pop`)},push(...e){return ft(this,`push`,e)},reduce(e,...t){return ut(this,`reduce`,e,t)},reduceRight(e,...t){return ut(this,`reduceRight`,e,t)},shift(){return ft(this,`shift`)},some(e,t){return lt(this,`some`,e,t,void 0,arguments)},splice(...e){return ft(this,`splice`,e)},toReversed(){return rt(this).toReversed()},toSorted(e){return rt(this).toSorted(e)},toSpliced(...e){return rt(this).toSpliced(...e)},unshift(...e){return ft(this,`unshift`,e)},values(){return st(this,`values`,e=>at(this,e))}};function st(e,t,n){let r=it(e),i=r[t]();return r!==e&&!Gt(e)&&(i._next=i.next,i.next=()=>{let e=i._next();return e.done||(e.value=n(e.value)),e}),i}var ct=Array.prototype;function lt(e,t,n,r,i,a){let o=it(e),s=o!==e&&!Gt(e),c=o[t];if(c!==ct[t]){let t=c.apply(e,a);return s?Jt(t):t}let l=n;o!==e&&(s?l=function(t,r){return n.call(this,at(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 ut(e,t,n,r){let i=it(e),a=i!==e&&!Gt(e),o=n,s=!1;i!==e&&(a?(s=r.length===0,o=function(t,r,i){return s&&(s=!1,t=at(e,t)),n.call(this,t,at(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?at(e,c):c}function dt(e,t,n){let r=V(e);B(r,`iterate`,et);let i=r[t](...n);return(i===-1||i===!1)&&Kt(n[0])?(n[0]=V(n[0]),r[t](...n)):i}function ft(e,t,n=[]){We(),Me();let r=V(e)[t].apply(e,n);return Ne(),Ge(),r}var pt=e(`__proto__,__v_isRef,__isVue`),mt=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!==`arguments`&&e!==`caller`).map(e=>Symbol[e]).filter(v));function ht(e){v(e)||(e=String(e));let t=V(this);return B(t,`has`,e),t.hasOwnProperty(e)}var gt=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?It:Ft:i?Pt:Nt).get(e)||Object.getPrototypeOf(e)===Object.getPrototypeOf(n)?e:void 0;let a=d(e);if(!r){let e;if(a&&(e=ot[t]))return e;if(t===`hasOwnProperty`)return ht}let o=Reflect.get(e,t,H(e)?e:n);if((v(t)?mt.has(t):pt(t))||(r||B(e,`get`,t),i))return o;if(H(o)){let e=a&&T(t)?o:o.value;return r&&y(e)?Bt(e):e}return y(o)?r?Bt(o):Rt(o):o}},_t=class extends gt{constructor(e=!1){super(!1,e)}set(e,t,n,r){let i=e[t],a=d(e)&&T(t);if(!this._isShallow){let e=Wt(i);if(!Gt(n)&&!Wt(n)&&(i=V(i),n=V(n)),!a&&H(i)&&!H(n))return e||(i.value=n),!0}let o=a?Number(t)<e.length:u(e,t),s=Reflect.set(e,t,n,H(e)?e:r);return e===V(r)&&s&&(o?j(n,i)&&tt(e,`set`,t,n,i):tt(e,`add`,t,n)),s}deleteProperty(e,t){let n=u(e,t),r=e[t],i=Reflect.deleteProperty(e,t);return i&&n&&tt(e,`delete`,t,void 0,r),i}has(e,t){let n=Reflect.has(e,t);return(!v(t)||!mt.has(t))&&B(e,`has`,t),n}ownKeys(e){return B(e,`iterate`,d(e)?`length`:Qe),Reflect.ownKeys(e)}},vt=class extends gt{constructor(e=!1){super(!0,e)}set(e,t){return!0}deleteProperty(e,t){return!0}},yt=new _t,bt=new vt,xt=new _t(!0),St=new vt(!0),Ct=e=>e,wt=e=>Reflect.getPrototypeOf(e);function Tt(e,t,n){return function(...r){let i=this.__v_raw,a=V(i),o=f(a),c=e===`entries`||e===Symbol.iterator&&o,l=e===`keys`&&o,u=i[e](...r),d=n?Ct:t?Yt:Jt;return!t&&B(a,`iterate`,l?$e:Qe),s(Object.create(u),{next(){let{value:e,done:t}=u.next();return t?{value:e,done:t}:{value:c?[d(e[0]),d(e[1])]:d(e),done:t}}})}}function Et(e){return function(...t){return e===`delete`?!1:e===`clear`?void 0:this}}function Dt(e,t){let n={get(n){let r=this.__v_raw,i=V(r),a=V(n);e||(j(n,a)&&B(i,`get`,n),B(i,`get`,a));let{has:o}=wt(i),s=t?Ct:e?Yt:Jt;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&&B(V(t),`iterate`,Qe),t.size},has(t){let n=this.__v_raw,r=V(n),i=V(t);return e||(j(t,i)&&B(r,`has`,t),B(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=V(a),s=t?Ct:e?Yt:Jt;return!e&&B(o,`iterate`,Qe),a.forEach((e,t)=>n.call(r,s(e),s(t),i))}};return s(n,e?{add:Et(`add`),set:Et(`set`),delete:Et(`delete`),clear:Et(`clear`)}:{add(e){let n=V(this),r=wt(n),i=V(e),a=!t&&!Gt(e)&&!Wt(e)?i:e;return r.has.call(n,a)||j(e,a)&&r.has.call(n,e)||j(i,a)&&r.has.call(n,i)||(n.add(a),tt(n,`add`,a,a)),this},set(e,n){!t&&!Gt(n)&&!Wt(n)&&(n=V(n));let r=V(this),{has:i,get:a}=wt(r),o=i.call(r,e);o||=(e=V(e),i.call(r,e));let s=a.call(r,e);return r.set(e,n),o?j(n,s)&&tt(r,`set`,e,n,s):tt(r,`add`,e,n),this},delete(e){let t=V(this),{has:n,get:r}=wt(t),i=n.call(t,e);i||=(e=V(e),n.call(t,e));let a=r?r.call(t,e):void 0,o=t.delete(e);return i&&tt(t,`delete`,e,void 0,a),o},clear(){let e=V(this),t=e.size!==0,n=e.clear();return t&&tt(e,`clear`,void 0,void 0,void 0),n}}),[`keys`,`values`,`entries`,Symbol.iterator].forEach(r=>{n[r]=Tt(r,e,t)}),n}function Ot(e,t){let n=Dt(e,t);return(t,r,i)=>r===`__v_isReactive`?!e:r===`__v_isReadonly`?e:r===`__v_raw`?t:Reflect.get(u(n,r)&&r in t?n:t,r,i)}var kt={get:Ot(!1,!1)},At={get:Ot(!1,!0)},jt={get:Ot(!0,!1)},Mt={get:Ot(!0,!0)},Nt=new WeakMap,Pt=new WeakMap,Ft=new WeakMap,It=new WeakMap;function Lt(e){switch(e){case`Object`:case`Array`:return 1;case`Map`:case`Set`:case`WeakMap`:case`WeakSet`:return 2;default:return 0}}function Rt(e){return Wt(e)?e:Ht(e,!1,yt,kt,Nt)}function zt(e){return Ht(e,!1,xt,At,Pt)}function Bt(e){return Ht(e,!0,bt,jt,Ft)}function Vt(e){return Ht(e,!0,St,Mt,It)}function Ht(e,t,n,r,i){if(!y(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=Lt(C(e));if(o===0)return e;let s=new Proxy(e,o===2?r:n);return i.set(e,s),s}function Ut(e){return Wt(e)?Ut(e.__v_raw):!!(e&&e.__v_isReactive)}function Wt(e){return!!(e&&e.__v_isReadonly)}function Gt(e){return!!(e&&e.__v_isShallow)}function Kt(e){return e?!!e.__v_raw:!1}function V(e){let t=e&&e.__v_raw;return t?V(t):e}function qt(e){return!u(e,`__v_skip`)&&Object.isExtensible(e)&&N(e,`__v_skip`,!0),e}var Jt=e=>y(e)?Rt(e):e,Yt=e=>y(e)?Bt(e):e;function H(e){return e?e.__v_isRef===!0:!1}function Xt(e){return Qt(e,!1)}function Zt(e){return Qt(e,!0)}function Qt(e,t){return H(e)?e:new $t(e,t)}var $t=class{constructor(e,t){this.dep=new Ye,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=t?e:V(e),this._value=t?e:Jt(e),this.__v_isShallow=t}get value(){return this.dep.track(),this._value}set value(e){let t=this._rawValue,n=this.__v_isShallow||Gt(e)||Wt(e);e=n?e:V(e),j(e,t)&&(this._rawValue=e,this._value=n?e:Jt(e),this.dep.trigger())}};function en(e){e.dep&&e.dep.trigger()}function tn(e){return H(e)?e.value:e}function nn(e){return g(e)?e():tn(e)}var rn={get:(e,t,n)=>t===`__v_raw`?e:tn(Reflect.get(e,t,n)),set:(e,t,n,r)=>{let i=e[t];return H(i)&&!H(n)?(i.value=n,!0):Reflect.set(e,t,n,r)}};function an(e){return Ut(e)?e:new Proxy(e,rn)}var on=class{constructor(e){this.__v_isRef=!0,this._value=void 0;let t=this.dep=new Ye,{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 sn(e){return new on(e)}function cn(e){let t=d(e)?Array(e.length):{};for(let n in e)t[n]=fn(e,n);return t}var ln=class{constructor(e,t,n){this._object=e,this._defaultValue=n,this.__v_isRef=!0,this._value=void 0,this._key=v(t)?t:String(t),this._raw=V(e);let r=!0,i=e;if(!d(e)||v(this._key)||!T(this._key))do r=!Kt(i)||Gt(i);while(r&&(i=i.__v_raw));this._shallow=r}get value(){let e=this._object[this._key];return this._shallow&&(e=tn(e)),this._value=e===void 0?this._defaultValue:e}set value(e){if(this._shallow&&H(this._raw[this._key])){let t=this._object[this._key];if(H(t)){t.value=e;return}}this._object[this._key]=e}get dep(){return nt(this._raw,this._key)}},un=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 dn(e,t,n){return H(e)?e:g(e)?new un(e):y(e)&&arguments.length>1?fn(e,t,n):Xt(e)}function fn(e,t,n){return new ln(e,t,n)}var pn=class{constructor(e,t,n){this.fn=e,this.setter=t,this._value=void 0,this.dep=new Ye(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=qe-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!t,this.isSSR=n}notify(){if(this.flags|=16,!(this.flags&8)&&z!==this)return je(this,!0),!0}get value(){let e=this.dep.track();return Le(this),e&&(e.version=this.dep.version),this._value}set value(e){this.setter&&this.setter(e)}};function mn(e,t,n=!1){let r,i;return g(e)?r=e:(r=e.get,i=e.set),new pn(r,i,n)}var hn={GET:`get`,HAS:`has`,ITERATE:`iterate`},gn={SET:`set`,ADD:`add`,DELETE:`delete`,CLEAR:`clear`},_n={},vn=new WeakMap,yn=void 0;function bn(){return yn}function xn(e,t=!1,n=yn){if(n){let t=vn.get(n);t||vn.set(n,t=[]),t.push(e)}}function Sn(e,n,i=t){let{immediate:a,deep:o,once:s,scheduler:l,augmentJob:u,call:f}=i,p=e=>o?e:Gt(e)||o===!1||o===0?Cn(e,1):Cn(e),m,h,_,v,y=!1,b=!1;if(H(e)?(h=()=>e.value,y=Gt(e)):Ut(e)?(h=()=>p(e),y=!0):d(e)?(b=!0,y=e.some(e=>Ut(e)||Gt(e)),h=()=>e.map(e=>{if(H(e))return e.value;if(Ut(e))return p(e);if(g(e))return f?f(e,2):e()})):h=g(e)?n?f?()=>f(e,2):e:()=>{if(_){We();try{_()}finally{Ge()}}let t=yn;yn=m;try{return f?f(e,3,[v]):e(v)}finally{yn=t}}:r,n&&o){let e=h,t=o===!0?1/0:o;h=()=>Cn(e(),t)}let x=we(),S=()=>{m.stop(),x&&x.active&&c(x.effects,m)};if(s&&n){let e=n;n=(...t)=>{let n=e(...t);return S(),n}}let C=b?Array(e.length).fill(_n):_n,w=e=>{if(!(!(m.flags&1)||!m.dirty&&!e)){if(n){let t=m.run();if(e||o||y||(b?t.some((e,t)=>j(e,C[t])):j(t,C))){_&&_();let e=yn;yn=m;try{let e=[t,C===_n?void 0:b&&C[0]===_n?[]:C,v];C=t,f?f(n,3,e):n(...e)}finally{yn=e}}}else m.run()}};return u&&u(w),m=new De(h),m.scheduler=l?()=>l(w,!1):w,v=e=>xn(e,!1,m),_=m.onStop=()=>{let e=vn.get(m);if(e){if(f)f(e,4);else for(let t of e)t();vn.delete(m)}},n?a?w(!0):C=m.run():l?l(w.bind(null,!0),!0):m.run(),S.pause=m.pause.bind(m),S.resume=m.resume.bind(m),S.stop=S,S}function Cn(e,t=1/0,n){if(t<=0||!y(e)||e.__v_skip||(n||=new Map,(n.get(e)||0)>=t))return e;if(n.set(e,t),t--,H(e))Cn(e.value,t,n);else if(d(e))for(let r=0;r<e.length;r++)Cn(e[r],t,n);else if(p(e)||f(e))e.forEach(e=>{Cn(e,t,n)});else if(w(e)){for(let r in e)Cn(e[r],t,n);for(let r of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,r)&&Cn(e[r],t,n)}return e}var wn=[];function Tn(e){wn.push(e)}function En(){wn.pop()}function Dn(e,t){}var On={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`},kn={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 An(e,t,n,r){try{return r?e(...r):e()}catch(e){Mn(e,t,n)}}function jn(e,t,n,r){if(g(e)){let i=An(e,t,n,r);return i&&b(i)&&i.catch(e=>{Mn(e,t,n)}),i}if(d(e)){let i=[];for(let a=0;a<e.length;a++)i.push(jn(e[a],t,n,r));return i}}function Mn(e,n,r,i=!0){let a=n?n.vnode:null,{errorHandler:o,throwUnhandledErrorInProduction:s}=n&&n.appContext.config||t;if(n){let t=n.parent,i=n.proxy,a=`https://vuejs.org/error-reference/#runtime-${r}`;for(;t;){let n=t.ec;if(n){for(let t=0;t<n.length;t++)if(n[t](e,i,a)===!1)return}t=t.parent}if(o){We(),An(o,null,10,[e,i,a]),Ge();return}}Nn(e,r,a,i,s)}function Nn(e,t,n,r=!0,i=!1){if(i)throw e;console.error(e)}var Pn=[],Fn=-1,In=[],Ln=null,Rn=0,zn=Promise.resolve(),Bn=null;function Vn(e){let t=Bn||zn;return e?t.then(this?e.bind(this):e):t}function Hn(e){let t=Fn+1,n=Pn.length;for(;t<n;){let r=t+n>>>1,i=Pn[r],a=Jn(i);a<e||a===e&&i.flags&2?t=r+1:n=r}return t}function Un(e){if(!(e.flags&1)){let t=Jn(e),n=Pn[Pn.length-1];!n||!(e.flags&2)&&t>=Jn(n)?Pn.push(e):Pn.splice(Hn(t),0,e),e.flags|=1,Wn()}}function Wn(){Bn||=zn.then(Yn)}function Gn(e){if(!d(e))Ln&&e.id===-1?Ln.splice(Rn+1,0,e):e.flags&1||(In.push(e),e.flags|=1);else for(let t=0;t<e.length;t++)In.push(e[t]);Wn()}function Kn(e,t,n=Fn+1){for(;n<Pn.length;n++){let t=Pn[n];if(t&&t.flags&2){if(e&&t.id!==e.uid)continue;Pn.splice(n,1),n--,t.flags&4&&(t.flags&=-2),t(),t.flags&4||(t.flags&=-2)}}}function qn(e){if(In.length){let e=[...new Set(In)].sort((e,t)=>Jn(e)-Jn(t));if(In.length=0,Ln){for(let t=0;t<e.length;t++)Ln.push(e[t]);return}for(Ln=e,Rn=0;Rn<Ln.length;Rn++){let e=Ln[Rn];e.flags&4&&(e.flags&=-2),e.flags&8||e(),e.flags&=-2}Ln=null,Rn=0}}var Jn=e=>e.id==null?e.flags&2?-1:1/0:e.id;function Yn(e){try{for(Fn=0;Fn<Pn.length;Fn++){let e=Pn[Fn];e&&!(e.flags&8)&&(e.flags&4&&(e.flags&=-2),An(e,e.i,e.i?15:14),e.flags&4||(e.flags&=-2))}}finally{for(;Fn<Pn.length;Fn++){let e=Pn[Fn];e&&(e.flags&=-2)}Fn=-1,Pn.length=0,qn(e),Bn=null,(Pn.length||In.length)&&Yn(e)}}var Xn,Zn=[];function Qn(e,t){Xn=e,Xn?(Xn.enabled=!0,Zn.forEach(({event:e,args:t})=>Xn.emit(e,...t)),Zn=[]):typeof window<`u`&&window.HTMLElement&&!(window.navigator?.userAgent)?.includes(`jsdom`)?((t.__VUE_DEVTOOLS_HOOK_REPLAY__=t.__VUE_DEVTOOLS_HOOK_REPLAY__||[]).push(e=>{Qn(e,t)}),setTimeout(()=>{Xn||(t.__VUE_DEVTOOLS_HOOK_REPLAY__=null,Zn=[])},3e3)):Zn=[]}var U=null,$n=null;function er(e){let t=U;return U=e,$n=e&&e.type.__scopeId||null,t}function tr(e){$n=e}function nr(){$n=null}var rr=e=>ir;function ir(e,t=U,n){if(!t||e._n)return e;let r=(...n)=>{r._d&&is(-1);let i=er(t),a=$o.length,o;try{o=e(...n)}finally{for(let e=$o.length;e>a;e--)ns();er(i),r._d&&is(1)}return o};return r._n=!0,r._c=!0,r._d=!0,r}function ar(e,n){if(U===null)return e;let r=Ws(U),i=e.dirs||=[];for(let e=0;e<n.length;e++){let[a,o,s,c=t]=n[e];a&&(g(a)&&(a={mounted:a,updated:a}),a.deep&&Cn(o),i.push({dir:a,instance:r,value:o,oldValue:void 0,arg:s,modifiers:c}))}return e}function or(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&&(We(),jn(c,n,8,[e.el,s,e,t]),Ge())}}function sr(e,t){if(J){let n=J.provides,r=J.parent&&J.parent.provides;r===n&&(n=J.provides=Object.create(r)),n[e]=t}}function cr(e,t,n=!1){let r=Y();if(r||qa){let i=qa?qa._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&&g(t)?t.call(r&&r.proxy):t}}function lr(){return!!(Y()||qa)}var ur=Symbol.for(`v-scx`),dr=()=>cr(ur);function fr(e,t){return gr(e,null,t)}function pr(e,t){return gr(e,null,{flush:`post`})}function mr(e,t){return gr(e,null,{flush:`sync`})}function hr(e,t,n){return gr(e,t,n)}function gr(e,n,i=t){let{immediate:a,deep:o,flush:c,once:l}=i,u=s({},i),d=n&&a||!n&&c!==`post`,f;if(Ns){if(c===`sync`){let e=dr();f=e.__watcherHandles||=[]}else if(!d){let e=()=>{};return e.stop=r,e.resume=r,e.pause=r,e}}let p=J;u.call=(e,t,n)=>jn(e,p,t,n);let m=!1;c===`post`?u.scheduler=e=>{W(e,p&&p.suspense)}:c!==`sync`&&(m=!0,u.scheduler=(e,t)=>{t?e():Un(e)}),u.augmentJob=e=>{n&&(e.flags|=4),m&&(e.flags|=2,p&&(e.id=p.uid,e.i=p))};let h=Sn(e,n,u);return Ns&&(f?f.push(h):d&&h()),h}function _r(e,t,n){let r=this.proxy,i=_(e)?e.includes(`.`)?vr(r,e):()=>r[e]:e.bind(r,r),a;g(t)?a=t:(a=t.handler,n=t);let o=As(this),s=gr(i,a.bind(r),n);return o(),s}function vr(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 yr=new WeakMap,br=Symbol(`_vte`),xr=e=>e.__isTeleport,Sr=e=>e&&(e.disabled||e.disabled===``),Cr=e=>e&&(e.defer||e.defer===``),wr=e=>typeof SVGElement<`u`&&e instanceof SVGElement,Tr=e=>typeof MathMLElement==`function`&&e instanceof MathMLElement,Er=(e,t)=>{let n=e&&e.to;return _(n)?t?t(n):null:n},Dr={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=Sr(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=Sr(e.props),r=e.target=Er(e.props,m),a=Mr(r,e,h,p);r&&(o!==`svg`&&wr(r)?o=`svg`:o!==`mathml`&&Tr(r)&&(o=`mathml`),i&&i.isCE&&(i.ce._teleportTargets||(i.ce._teleportTargets=new Set)).add(r),n||(b(e,r,a),jr(e,!1)))},S=e=>{let t=()=>{if(yr.get(e)===t){if(yr.delete(e),Sr(e.props)){let t=_(e.el)||n;b(e,t,e.anchor),jr(e,!0)}x(e)}};yr.set(e,t),W(t,a)};if(e==null){let e=t.el=h(``),i=t.anchor=h(``);if(p(e,n,r),p(i,n,r),Cr(t.props)||a&&a.pendingBranch){S(t);return}v&&(b(t,n,i),jr(t,!0)),x()}else{t.el=e.el;let r=t.anchor=e.anchor,u=yr.get(e);if(u){u.flags|=8,yr.delete(e),S(t);return}t.targetStart=e.targetStart;let p=t.target=e.target,h=t.targetAnchor=e.targetAnchor,g=Sr(e.props),_=g?n:p,b=g?r:h;if(o===`svg`||wr(p)?o=`svg`:(o===`mathml`||Tr(p))&&(o=`mathml`),y?(f(e.dynamicChildren,y,_,i,a,o,s),No(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):Or(t,n,r,l,1);else if((t.props&&t.props.to)!==(e.props&&e.props.to)){let e=Er(t.props,m);e&&(t.target=e,Or(t,e,null,l,0))}else g&&Or(t,p,h,l,1);jr(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=Sr(f),m=a||!p,h=yr.get(e);if(h&&(h.flags|=8,yr.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:Or,hydrate:kr};function Or(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),!yr.has(e)&&(!d||Sr(u))&&c&16)for(let e=0;e<l.length;e++)i(l[e],t,n,2);d&&r(s,t,n)}function kr(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=Er(t.props,c),h=Sr(t.props);if(m){let c=m._lpa||m.firstChild;t.shapeFlag&16&&(h?(p(e,t),f(m,c),t.targetAnchor||Mr(m,t,u,l,s(e)===m?e:null)):(t.anchor=o(e),f(m,c),t.targetAnchor||Mr(m,t,u,l),d(c&&o(c),t,m,n,r,i,a))),jr(t,h)}else h&&t.shapeFlag&16&&(p(e,t),t.targetStart=e,t.targetAnchor=o(e));return t.anchor&&o(t.anchor)}var Ar=Dr;function jr(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 Mr(e,t,n,r,i=null){let a=t.targetStart=n(``),o=t.targetAnchor=n(``);return a[br]=o,e&&(r(a,e,i),r(o,e,i)),o}var Nr=Symbol(`_leaveCb`),Pr=Symbol(`_enterCb`);function Fr(){let e={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return Vi(()=>{e.isMounted=!0}),Wi(()=>{e.isUnmounting=!0}),e}var Ir=[Function,Array],Lr={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:Ir,onEnter:Ir,onAfterEnter:Ir,onEnterCancelled:Ir,onBeforeLeave:Ir,onLeave:Ir,onAfterLeave:Ir,onLeaveCancelled:Ir,onBeforeAppear:Ir,onAppear:Ir,onAfterAppear:Ir,onAppearCancelled:Ir},Rr=e=>{let t=e.subTree;return t.component?Rr(t.component):t},zr={name:`BaseTransition`,props:Lr,setup(e,{slots:t}){let n=Y(),r=Fr();return()=>{let i=t.default&&qr(t.default(),!0),a=i&&i.length?Br(i):n.subTree?ys():void 0;if(!a)return;let o=V(e),{mode:s}=o;if(r.isLeaving)return Wr(a);let c=Gr(a);if(!c)return Wr(a);let l=Ur(c,o,r,n,e=>l=e);c.type!==K&&Kr(c,l);let u=n.subTree&&Gr(n.subTree);if(u&&u.type!==K&&!ls(u,c)&&Rr(n).type!==K){let e=Ur(u,o,r,n);if(Kr(u,e),s===`out-in`&&c.type!==K)return r.isLeaving=!0,e.afterLeave=()=>{r.isLeaving=!1,n.job.flags&8||n.update(),delete e.afterLeave,u=void 0},Wr(a);s===`in-out`&&c.type!==K?e.delayLeave=(e,t,n)=>{let i=Hr(r,u);i[String(u.key)]=u,e[Nr]=()=>{t(),e[Nr]=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 Br(e){let t=e[0];if(e.length>1){for(let n of e)if(n.type!==K){t=n;break}}return t}var Vr=zr;function Hr(e,t){let{leavingVNodes:n}=e,r=n.get(t.type);return r||(r=Object.create(null),n.set(t.type,r)),r}function Ur(e,t,n,r,i){let{appear:a,mode:o,persisted:s=!1,onBeforeEnter:c,onEnter:l,onAfterEnter:u,onEnterCancelled:f,onBeforeLeave:p,onLeave:m,onAfterLeave:h,onLeaveCancelled:g,onBeforeAppear:_,onAppear:v,onAfterAppear:y,onAppearCancelled:b}=t,x=String(e.key),S=Hr(n,e),C=(e,t)=>{e&&jn(e,r,9,t)},w=(e,t)=>{let n=t[1];C(e,t),d(e)?e.every(e=>e.length<=1)&&n():e.length<=1&&n()},T={mode:o,persisted:s,beforeEnter(t){let r=c;if(!n.isMounted){if(a)r=_||c;else return}t[Nr]&&t[Nr](!0);let i=S[x];i&&ls(e,i)&&i.el[Nr]&&i.el[Nr](),C(r,[t])},enter(t){if(S[x]===e)return;let r=l,i=u,o=f;if(!n.isMounted){if(a)r=v||l,i=y||u,o=b||f;else return}let s=!1;t[Pr]=e=>{s||(s=!0,C(e?o:i,[t]),T.delayedLeave&&T.delayedLeave(),t[Pr]=void 0)};let c=t[Pr].bind(null,!1);r?w(r,[t,c]):c()},leave(t,r){let i=String(e.key);if(t[Pr]&&t[Pr](!0),n.isUnmounting)return r();C(p,[t]);let a=!1;t[Nr]=n=>{a||(a=!0,r(),C(n?g:h,[t]),t[Nr]=void 0,S[i]===e&&delete S[i])};let o=t[Nr].bind(null,!1);S[i]=e,m?w(m,[t,o]):o()},clone(e){let a=Ur(e,t,n,r,i);return i&&i(a),a}};return T}function Wr(e){if(ki(e))return e=gs(e),e.children=null,e}function Gr(e){if(!ki(e))return xr(e.type)&&e.children?Br(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&&g(n.default))return n.default()}}function Kr(e,t){if(e.shapeFlag&6&&e.component){e.transition=t;let n=e.component.subTree;Kr(xr(n.type)&&Gr(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 qr(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===G?(o.patchFlag&128&&i++,r=r.concat(qr(o.children,t,s))):(t||o.type!==K)&&r.push(s==null?o:gs(o,{key:s}))}if(i>1)for(let e=0;e<r.length;e++)r[e].patchFlag=-2;return r}function Jr(e,t){return g(e)?s({name:e.name},t,{setup:e}):e}function Yr(){let e=Y();return e?(e.appContext.config.idPrefix||`v`)+`-`+e.ids[0]+e.ids[1]++:``}function Xr(e){e.ids=[e.ids[0]+e.ids[2]+++`-`,0,0]}function Zr(e){let n=Y(),r=Zt(null);if(n){let i=n.refs===t?n.refs={}:n.refs;Object.defineProperty(i,e,{enumerable:!0,get:()=>r.value,set:e=>r.value=e})}return r}function Qr(e,t){let n;return!!((n=Object.getOwnPropertyDescriptor(e,t))&&!n.configurable)}var $r=new WeakMap;function ei(e,n,r,a,o=!1){if(d(e)){e.forEach((e,t)=>ei(e,n&&(d(n)?n[t]:n),r,a,o));return}if(Ei(a)&&!o){a.shapeFlag&512&&a.type.__asyncResolved&&a.component.subTree.component&&ei(e,n,r,a.component.subTree);return}let s=a.shapeFlag&4?Ws(a.component):a.el,l=o?null:s,{i:f,r:p}=e,m=n&&n.r,h=f.refs===t?f.refs={}:f.refs,v=f.setupState,y=V(v),b=v===t?i:e=>!Qr(h,e)&&u(y,e),x=(e,t)=>!(t&&Qr(h,t));if(m!=null&&m!==p){if(ti(n),_(m))h[m]=null,b(m)&&(v[m]=null);else if(H(m)){let e=n;x(m,e.k)&&(m.value=null),e.k&&(h[e.k]=null)}}if(g(p))An(p,f,12,[l,h]);else{let t=_(p),n=H(p);if(t||n){let i=()=>{if(e.f){let n=t?b(p)?v[p]:h[p]:x(p)||!e.k?p.value:h[e.k];if(o)d(n)&&c(n,s);else if(d(n))n.includes(s)||n.push(s);else if(t)h[p]=[s],b(p)&&(v[p]=h[p]);else{let t=[s];x(p,e.k)&&(p.value=t),e.k&&(h[e.k]=t)}}else t?(h[p]=l,b(p)&&(v[p]=l)):n&&(x(p,e.k)&&(p.value=l),e.k&&(h[e.k]=l))};if(l){let t=()=>{i(),$r.delete(e)};t.id=-1,$r.set(e,t),W(t,r)}else ti(e),i()}}}function ti(e){let t=$r.get(e);t&&(t.flags|=8,$r.delete(e))}var ni=!1,ri=()=>{ni||=(console.error(`Hydration completed but contains mismatches.`),!0)},ii=e=>e.namespaceURI.includes(`svg`)&&e.tagName!==`foreignObject`,ai=e=>e.namespaceURI.includes(`MathML`),oi=e=>{if(e.nodeType===1){if(ii(e))return`svg`;if(ai(e))return`mathml`}},si=e=>e.nodeType===8;function ci(e){let{mt:t,p:n,o:{patchProp:r,createText:i,nextSibling:o,parentNode:s,remove:c,insert:l,createComment:u}}=e,d=(e,t)=>{if(!t.hasChildNodes()){n(null,e,t),qn(),t._vnode=e;return}f(t.firstChild,e,null,null,null),qn(),t._vnode=e},f=(n,r,a,c,u,d=!1)=>{d||=!!r.dynamicChildren;let b=si(n)&&n.data===`[`,x=()=>g(n,r,a,c,u,b),{type:S,ref:C,shapeFlag:w,patchFlag:T}=r,E=n.nodeType;r.el=n,T===-2&&(d=!1,r.dynamicChildren=null);let D=null;switch(S){case Zo:E===3?(n.data!==r.children&&(ri(),n.data=r.children),D=o(n)):r.children===``?(l(r.el=i(``),s(n),n),D=n):D=x();break;case K:y(n)?(D=o(n),v(r.el=n.content.firstChild,n,a)):D=E!==8||b?x():o(n);break;case Qo:if(b&&(n=o(n),E=n.nodeType),E===1||E===3){D=n;let e=!r.children.length;for(let t=0;t<r.staticCount;t++)e&&(r.children+=D.nodeType===1?D.outerHTML:D.data),t===r.staticCount-1&&(r.anchor=D),D=o(D);return b?o(D):D}x();break;case G:D=b?h(n,r,a,c,u,d):x();break;default:if(w&1)D=(E!==1||r.type.toLowerCase()!==n.tagName.toLowerCase())&&!y(n)?x():p(n,r,a,c,u,d);else if(w&6){r.slotScopeIds=u;let e=s(n);if(D=b?_(n):si(n)&&n.data===`teleport start`?_(n,n.data,`teleport end`):o(n),t(r,e,null,a,c,oi(e),d),Ei(r)&&!r.type.__asyncResolved){let t;b?(t=q(G),t.anchor=D?D.previousSibling:e.lastChild):t=n.nodeType===3?_s(``):q(`div`),t.el=n,r.component.subTree=t}}else w&64?D=E===8?r.type.hydrate(n,r,a,c,u,d,e,m):x():w&128&&(D=r.type.hydrate(n,r,a,c,oi(s(n)),u,d,e,f))}return C!=null&&ei(C,null,c,r),D},p=(e,t,n,i,o,s)=>{s||=!!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&&or(t,null,n,`created`);let l=!1;if(y(e)){l=Mo(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,o,s);for(r&&!pi(e,1)&&ri();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,`
`)&&(pi(e,0)||ri(),e.textContent=t.children)}if(d){if(_||b||!s||f&48){let t=e.tagName.includes(`-`),i=e.namespaceURI.includes(`svg`)?`svg`:e.namespaceURI.includes(`MathML`)?`mathml`:void 0;for(let o in d)if(_&&(o.endsWith(`value`)||o===`indeterminate`)||a(o)&&!E(o)||o[0]===`.`||t&&!E(o)||u&&u.includes(o)){if(ui(e,o,d[o]))continue;r(e,o,null,d[o],i,n)}}else if(d.onClick)r(e,`onClick`,null,d.onClick,void 0,n);else if(f&4&&Ut(d.style))for(let e in d.style)d.style[e]}let x;(x=d&&d.onVnodeBeforeMount)&&ws(x,n,t),h&&or(t,null,n,`beforeMount`),((x=d&&d.onVnodeMounted)||h||l)&&Jo(()=>{x&&ws(x,n,t),l&&g.enter(e),h&&or(t,null,n,`mounted`)},i)}return e.nextSibling},m=(e,t,r,a,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]=bs(d[t]),g=h.type===Zo;e?(g&&!u&&t+1<p&&bs(d[t+1]).type===Zo&&(l(i(e.data.slice(h.children.length)),r,o(e)),e.data=h.children),e=f(e,h,a,s,c,u)):g&&!h.children?l(h.el=i(``),r):(m||(m=!0,pi(r,1)||ri()),n(null,h,r,null,a,s,oi(r),c))}return e},h=(e,t,n,r,i,a)=>{let{slotScopeIds:c}=t;c&&(i=i?i.concat(c):c);let d=s(e),f=m(o(e),t,d,n,r,i,a);return f&&si(f)&&f.data===`]`?o(t.anchor=f):(ri(),l(t.anchor=u(`]`),d,f),f)},g=(e,t,r,i,a,l)=>{if(hi(e,t)||ri(),t.el=null,l){let t=_(e);for(;;){let n=o(e);if(n&&n!==t)c(n);else break}}let u=o(e),d=s(e);return c(e),n(null,t,d,u,r,i,oi(d),a),r&&(r.vnode.el=t.el,so(r,t.el)),u},_=(e,t=`[`,n=`]`)=>{let r=0;for(;e;)if(e=o(e),e&&si(e)&&(e.data===t&&r++,e.data===n)){if(r===0)return o(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 li=new Set([`src`,`srcset`,`href`,`poster`]);function ui(e,t,n){return li.has(t)?e.getAttribute(t)===(n==null?null:`${n}`):!1}var di=`data-allow-mismatch`,fi={0:`text`,1:`children`,2:`class`,3:`style`,4:`attribute`};function pi(e,t){if(t===0||t===1)for(;e&&!e.hasAttribute(di);)e=e.parentElement;return mi(e&&e.getAttribute(di),t)}function mi(e,t){if(e==null)return!1;if(e===``)return!0;{let n=e.split(`,`);return t===0&&n.includes(`children`)?!0:n.includes(fi[t])}}function hi(e,t){return pi(e.parentElement,1)||gi(e)||_i(t)}function gi(e){return e.nodeType===1&&mi(e.getAttribute(di),1)}function _i({props:e}){let t=e&&e[di];return typeof t==`string`&&mi(t,1)}var vi=oe().requestIdleCallback||(e=>setTimeout(e,1)),yi=oe().cancelIdleCallback||(e=>clearTimeout(e)),bi=(e=1e4)=>t=>{let n=vi(t,{timeout:e});return()=>yi(n)};function xi(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 Si=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(xi(e))return t(),r.disconnect(),!1;r.observe(e)}}),()=>r.disconnect()},Ci=e=>t=>{if(e){let n=matchMedia(e);if(n.matches)t();else return n.addEventListener(`change`,t,{once:!0}),()=>n.removeEventListener(`change`,t)}},wi=(e=[])=>(t,n)=>{_(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 Ti(e,t){if(si(e)&&e.data===`[`){let n=1,r=e.nextSibling;for(;r;){if(r.nodeType===1){if(t(r)===!1)break}else if(si(r)){if(r.data===`]`){if(--n===0)break}else r.data===`[`&&n++}r=r.nextSibling}}else t(e)}var Ei=e=>!!e.type.__asyncLoader;function Di(e){g(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 Jr({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=>Ti(e,t));n&&(t.bum||=[]).push(n)}:o;u?s():p().then(()=>!t.isUnmounted&&s())},get __asyncResolved(){return u},setup(){let e=J;if(Xr(e),u)return()=>Oi(u,e);let t=t=>{l=null,Mn(t,e,13,!r)};if(s&&e.suspense||Ns)return p().then(t=>()=>Oi(t,e)).catch(e=>(t(e),()=>r?q(r,{error:e}):null));let a=Xt(!1),c=Xt(),d=Xt(!!i),f,m;return Gi(()=>{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&&ki(e.parent.vnode)&&e.parent.update())}).catch(n=>{if(e.isUnmounted){l=null;return}t(n),c.value=n}),()=>{if(a.value&&u)return Oi(u,e);if(c.value&&r)return q(r,{error:c.value});if(n&&!d.value)return Oi(n,e)}}})}function Oi(e,t){let{ref:n,props:r,children:i,ce:a}=t.vnode,o=q(e,r,i);return o.ref=n,o.ce=a,delete t.vnode.ce,o}var ki=e=>e.type.__isKeepAlive,Ai={name:`KeepAlive`,__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(e,{slots:t}){let n=Y(),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),W(()=>{a.isDeactivated=!1,a.a&&M(a.a);let t=e.props&&e.props.onVnodeMounted;t&&ws(t,a.parent,e)},s)},r.deactivate=e=>{let t=e.component;Io(t.m),Io(t.a),l(e,f,null,1,s),W(()=>{t.da&&M(t.da);let n=e.props&&e.props.onVnodeUnmounted;n&&ws(n,t.parent,e),t.isDeactivated=!0},s)};function p(e){Ii(e),u(e,n,s,!0)}function m(e){i.forEach((t,n)=>{let r=Gs(Ei(t)?t.type.__asyncResolved||{}:t.type);r&&!e(r)&&h(n)})}function h(e){let t=i.get(e);t&&(!o||!ls(t,o))?p(t):o&&Ii(o),i.delete(e),a.delete(e)}hr(()=>[e.include,e.exclude],([e,t])=>{e&&m(t=>ji(e,t)),t&&m(e=>!ji(t,e))},{flush:`post`,deep:!0});let g=null,_=()=>{g!=null&&(Ro(n.subTree.type)?W(()=>{i.set(g,Li(n.subTree))},n.subTree.suspense):i.set(g,Li(n.subTree)))};return Vi(_),Ui(_),Wi(()=>{i.forEach(e=>{let{subTree:t,suspense:r}=n,i=Li(t);if(e.type===i.type&&e.key===i.key){Ii(i);let e=i.component.da;e&&W(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(!cs(r)||!(r.shapeFlag&4)&&!(r.shapeFlag&128))return o=null,r;let s=Li(r);if(s.type===K)return o=null,s;let c=s.type,l=Gs(Ei(s)?s.type.__asyncResolved||{}:c),{include:u,exclude:d,max:f}=e;if(u&&(!l||!ji(u,l))||d&&l&&ji(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=gs(s),r.shapeFlag&128&&(r.ssContent=s)),g=p,m?(s.el=m.el,s.component=m.component,s.transition&&Kr(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,Ro(r.type)?r:s}}};function ji(e,t){return d(e)?e.some(e=>ji(e,t)):_(e)?e.split(`,`).includes(t):h(e)?(e.lastIndex=0,e.test(t)):!1}function Mi(e,t){Pi(e,`a`,t)}function Ni(e,t){Pi(e,`da`,t)}function Pi(e,t,n=J){let r=e.__wdc||=()=>{let t=n;for(;t;){if(t.isDeactivated)return;t=t.parent}return e()};if(Ri(t,r,n),n){let e=n.parent;for(;e&&e.parent;)ki(e.parent.vnode)&&Fi(r,t,n,e),e=e.parent}}function Fi(e,t,n,r){let i=Ri(t,e,r,!0);Gi(()=>{c(r[t],i)},n)}function Ii(e){e.shapeFlag&=-257,e.shapeFlag&=-513}function Li(e){return e.shapeFlag&128?e.ssContent:e}function Ri(e,t,n=J,r=!1){if(n){let i=n[e]||(n[e]=[]),a=t.__weh||=(...r)=>{We();let i=As(n),a=jn(t,n,e,r);return i(),Ge(),a};return r?i.unshift(a):i.push(a),a}}var zi=e=>(t,n=J)=>{(!Ns||e===`sp`)&&Ri(e,(...e)=>t(...e),n)},Bi=zi(`bm`),Vi=zi(`m`),Hi=zi(`bu`),Ui=zi(`u`),Wi=zi(`bum`),Gi=zi(`um`),Ki=zi(`sp`),qi=zi(`rtg`),Ji=zi(`rtc`);function Yi(e,t=J){Ri(`ec`,e,t)}var Xi=`components`,Zi=`directives`;function Qi(e,t){return na(Xi,e,!0,t)||e}var $i=Symbol.for(`v-ndc`);function ea(e){return _(e)?na(Xi,e,!1)||e:e||$i}function ta(e){return na(Zi,e)}function na(e,t,n=!0,r=!1){let i=U||J;if(i){let n=i.type;if(e===Xi){let e=Gs(n,!1);if(e&&(e===t||e===O(t)||e===A(O(t))))return n}let a=ra(i[e]||n[e],t)||ra(i.appContext[e],t);return!a&&r?n:a}}function ra(e,t){return e&&(e[t]||e[O(t)]||e[A(O(t))])}function ia(e,t,n,r){let i,a=n&&n[r],o=d(e);if(o||_(e)){let n=o&&Ut(e),r=!1,s=!1;n&&(r=!Gt(e),s=Wt(e),e=it(e)),i=Array(e.length);for(let n=0,o=e.length;n<o;n++)i[n]=t(r?s?Yt(Jt(e[n])):Jt(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(y(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 aa(e,t){for(let n=0;n<t.length;n++){let r=t[n];if(d(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 oa(e,t,n,r,i,a){if(n??={},U.ce||U.parent&&Ei(U.parent)&&U.parent.ce){let e=a!=null&&n.key==null?s({},n,{key:a}):n,i=Object.keys(e).length>0;return t!=="default"&&(e.name=t),ts(),ss(G,null,[q(`slot`,e,r&&r())],i?-2:64)}let o=e[t];o&&o._c&&(o._d=!1);let c=$o.length;ts();let l;try{let i=o&&sa(o(n)),s=n.key||a||i&&i.key;l=ss(G,{key:(s&&!v(s)?s:`_${t}`)+(!i&&r?`_fb`:``)},i||(r?r():[]),i&&e._===1?64:-2)}catch(e){for(let e=$o.length;e>c;e--)ns();throw e}finally{o&&o._c&&(o._d=!0)}return!i&&l.scopeId&&(l.slotScopeIds=[l.scopeId+`-s`]),l}function sa(e){return e.some(e=>!cs(e)||!(e.type===K||e.type===G&&!sa(e.children)))?e:null}function ca(e,t){let n={};for(let r in e)n[t&&/[A-Z]/.test(r)?`on:${r}`:ne(r)]=e[r];return n}var la=e=>e?Ms(e)?Ws(e):la(e.parent):null,ua=s(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=>la(e.parent),$root:e=>la(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>Pa(e),$forceUpdate:e=>e.f||=()=>{Un(e.update)},$nextTick:e=>e.n||=Vn.bind(e.proxy),$watch:e=>_r.bind(e)}),da=(e,n)=>e!==t&&!e.__isScriptSetup&&u(e,n),fa={get({_:e},n){if(n===`__v_skip`)return!0;let{ctx:r,setupState:i,data:a,props:o,accessCache:s,type:c,appContext:l}=e;if(n[0]!==`$`){let e=s[n];if(e!==void 0)switch(e){case 1:return i[n];case 2:return a[n];case 4:return r[n];case 3:return o[n]}else if(da(i,n))return s[n]=1,i[n];else if(a!==t&&u(a,n))return s[n]=2,a[n];else if(u(o,n))return s[n]=3,o[n];else if(r!==t&&u(r,n))return s[n]=4,r[n];else ka&&(s[n]=0)}let d=ua[n],f,p;if(d)return n===`$attrs`&&B(e.attrs,`get`,``),d(e);if((f=c.__cssModules)&&(f=f[n]))return f;if(r!==t&&u(r,n))return s[n]=4,r[n];if(p=l.config.globalProperties,u(p,n))return p[n]},set({_:e},n,r){let{data:i,setupState:a,ctx:o}=e;return da(a,n)?(a[n]=r,!0):i!==t&&u(i,n)?(i[n]=r,!0):u(e.props,n)||n[0]===`$`&&n.slice(1)in e?!1:(o[n]=r,!0)},has({_:{data:e,setupState:n,accessCache:r,ctx:i,appContext:a,props:o,type:s}},c){let l;return!!(r[c]||e!==t&&c[0]!==`$`&&u(e,c)||da(n,c)||u(o,c)||u(i,c)||u(ua,c)||u(a.config.globalProperties,c)||(l=s.__cssModules)&&l[c])},defineProperty(e,t,n){return n.get==null?u(n,`value`)&&this.set(e,t,n.value,null):e._.accessCache[t]=0,Reflect.defineProperty(e,t,n)}},pa=s({},fa,{get(e,t){if(t!==Symbol.unscopables)return fa.get(e,t,e)},has(e,t){return t[0]!==`_`&&!P(t)}});function ma(){return null}function ha(){return null}function ga(e){}function _a(e){}function va(){return null}function ya(){}function ba(e,t){return null}function xa(){return Ca(`useSlots`).slots}function Sa(){return Ca(`useAttrs`).attrs}function Ca(e){let t=Y();return t.setupContext||=Us(t)}function wa(e){return d(e)?e.reduce((e,t)=>(e[t]=null,e),{}):e}function Ta(e,t){let n=wa(e);for(let e in t){if(e.startsWith(`__skip`))continue;let r=n[e];r?d(r)||g(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 Ea(e,t){return!e||!t?e||t:d(e)&&d(t)?e.concat(t):s({},wa(e),wa(t))}function Da(e,t){let n={};for(let r in e)t.includes(r)||Object.defineProperty(n,r,{enumerable:!0,get:()=>e[r]});return n}function Oa(e){let t=Y(),n=Ns,r=e();js(),n&&ks(!1);let i=()=>{As(t),n&&ks(!0)},a=()=>{Y()!==t&&t.scope.off(),js(),n&&ks(!1)};return b(r)&&(r=r.catch(e=>{throw i(),Promise.resolve().then(()=>Promise.resolve().then(a)),e})),[r,()=>{i(),Promise.resolve().then(a)}]}var ka=!0;function Aa(e){let t=Pa(e),n=e.proxy,i=e.ctx;ka=!1,t.beforeCreate&&Ma(t.beforeCreate,e,`bc`);let{data:a,computed:o,methods:s,watch:c,provide:l,inject:u,created:f,beforeMount:p,mounted:m,beforeUpdate:h,updated:_,activated:v,deactivated:b,beforeDestroy:x,beforeUnmount:S,destroyed:C,unmounted:w,render:T,renderTracked:E,renderTriggered:D,errorCaptured:ee,serverPrefetch:O,expose:te,inheritAttrs:k,components:A,directives:ne,filters:j}=t;if(u&&ja(u,i,null),s)for(let e in s){let t=s[e];g(t)&&(i[e]=t.bind(n))}if(a){let t=a.call(n,n);y(t)&&(e.data=Rt(t))}if(ka=!0,o)for(let e in o){let t=o[e],a=qs({get:g(t)?t.bind(n,n):g(t.get)?t.get.bind(n,n):r,set:!g(t)&&g(t.set)?t.set.bind(n):r});Object.defineProperty(i,e,{enumerable:!0,configurable:!0,get:()=>a.value,set:e=>a.value=e})}if(c)for(let e in c)Na(c[e],i,n,e);if(l){let e=g(l)?l.call(n):l;Reflect.ownKeys(e).forEach(t=>{sr(t,e[t])})}f&&Ma(f,e,`c`);function M(e,t){d(t)?t.forEach(t=>e(t.bind(n))):t&&e(t.bind(n))}if(M(Bi,p),M(Vi,m),M(Hi,h),M(Ui,_),M(Mi,v),M(Ni,b),M(Yi,ee),M(Ji,E),M(qi,D),M(Wi,S),M(Gi,w),M(Ki,O),d(te)){if(te.length){let t=e.exposed||={};te.forEach(e=>{Object.defineProperty(t,e,{get:()=>n[e],set:t=>n[e]=t,enumerable:!0})})}else e.exposed||={}}T&&e.render===r&&(e.render=T),k!=null&&(e.inheritAttrs=k),A&&(e.components=A),ne&&(e.directives=ne),O&&Xr(e)}function ja(e,t,n=r){d(e)&&(e=za(e));for(let n in e){let r=e[n],i;i=y(r)?`default`in r?cr(r.from||n,r.default,!0):cr(r.from||n):cr(r),H(i)?Object.defineProperty(t,n,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e}):t[n]=i}}function Ma(e,t,n){jn(d(e)?e.map(e=>e.bind(t.proxy)):e.bind(t.proxy),t,n)}function Na(e,t,n,r){let i=r.includes(`.`)?vr(n,r):()=>n[r];if(_(e)){let n=t[e];g(n)&&hr(i,n)}else if(g(e))hr(i,e.bind(n));else if(y(e)){if(d(e))e.forEach(e=>Na(e,t,n,r));else{let r=g(e.handler)?e.handler.bind(n):t[e.handler];g(r)&&hr(i,r,e)}}}function Pa(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=>Fa(c,e,o,!0)),Fa(c,t,o)),y(t)&&a.set(t,c),c}function Fa(e,t,n,r=!1){let{mixins:i,extends:a}=t;a&&Fa(e,a,n,!0),i&&i.forEach(t=>Fa(e,t,n,!0));for(let i in t)if(!(r&&i===`expose`)){let r=Ia[i]||n&&n[i];e[i]=r?r(e[i],t[i]):t[i]}return e}var Ia={data:La,props:Ha,emits:Ha,methods:Va,computed:Va,beforeCreate:Ba,created:Ba,beforeMount:Ba,mounted:Ba,beforeUpdate:Ba,updated:Ba,beforeDestroy:Ba,beforeUnmount:Ba,destroyed:Ba,unmounted:Ba,activated:Ba,deactivated:Ba,errorCaptured:Ba,serverPrefetch:Ba,components:Va,directives:Va,watch:Ua,provide:La,inject:Ra};function La(e,t){return t?e?function(){return s(g(e)?e.call(this,this):e,g(t)?t.call(this,this):t)}:t:e}function Ra(e,t){return Va(za(e),za(t))}function za(e){if(d(e)){let t={};for(let n=0;n<e.length;n++)t[e[n]]=e[n];return t}return e}function Ba(e,t){return e?[...new Set([].concat(e,t))]:t}function Va(e,t){return e?s(Object.create(null),e,t):t}function Ha(e,t){return e?d(e)&&d(t)?[...new Set([...e,...t])]:s(Object.create(null),wa(e),wa(t??{})):t}function Ua(e,t){if(!e)return t;if(!t)return e;let n=s(Object.create(null),e);for(let r in t)n[r]=Ba(e[r],t[r]);return n}function Wa(){return{app:null,config:{isNativeTag:i,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 Ga=0;function Ka(e,t){return function(n,r=null){g(n)||(n=s({},n)),r!=null&&!y(r)&&(r=null);let i=Wa(),a=new WeakSet,o=[],c=!1,l=i.app={_uid:Ga++,_component:n,_props:r,_container:null,_context:i,_instance:null,version:Qs,get config(){return i.config},set config(e){},use(e,...t){return a.has(e)||(e&&g(e.install)?(a.add(e),e.install(l,...t)):g(e)&&(a.add(e),e(l,...t))),l},mixin(e){return i.mixins.includes(e)||i.mixins.push(e),l},component(e,t){return t?(i.components[e]=t,l):i.components[e]},directive(e,t){return t?(i.directives[e]=t,l):i.directives[e]},mount(a,o,s){if(!c){let u=l._ceVNode||q(n,r);return u.appContext=i,s===!0?s=`svg`:s===!1&&(s=void 0),o&&t?t(u,a):e(u,a,s),c=!0,l._container=a,a.__vue_app__=l,Ws(u.component)}},onUnmount(e){o.push(e)},unmount(){c&&(jn(o,l._instance,16),e(null,l._container),delete l._container.__vue_app__)},provide(e,t){return i.provides[e]=t,l},runWithContext(e){let t=qa;qa=l;try{return e()}finally{qa=t}}};return l}}var qa=null;function Ja(e,n,r=t){let i=Y(),a=O(n),o=k(n),s=Ya(e,a),c=sn((s,c)=>{let l,u=t,d;return mr(()=>{let t=e[a];j(l,t)&&(l=t,c())}),{get(){return s(),r.get?r.get(l):l},set(e){let s=r.set?r.set(e):e;if(!j(s,l)&&!(u!==t&&j(e,u)))return;let f=i.vnode.props,p=!!(f&&(n in f||a in f||o in f)&&(`onUpdate:${n}`in f||`onUpdate:${a}`in f||`onUpdate:${o}`in f));p||(l=e,c()),i.emit(`update:${n}`,s),j(e,u)&&(j(e,s)&&!j(s,d)||p&&u!==t&&!j(s,l))&&c(),u=e,d=s}}});return c[Symbol.iterator]=()=>{let e=0;return{next(){return e<2?{value:e++?s||t:c,done:!1}:{done:!0}}}},c}var Ya=(e,t)=>t===`modelValue`||t===`model-value`?e.modelModifiers:e[`${t}Modifiers`]||e[`${O(t)}Modifiers`]||e[`${k(t)}Modifiers`];function Xa(e,n,...r){if(e.isUnmounted)return;let i=e.vnode.props||t,a=r,o=n.startsWith(`update:`),s=o&&Ya(i,n.slice(7));s&&(s.trim&&(a=r.map(e=>_(e)?e.trim():e)),s.number&&(a=r.map(re)));let c,l=i[c=ne(n)]||i[c=ne(O(n))];!l&&o&&(l=i[c=ne(k(n))]),l&&jn(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,jn(u,e,6,a)}}var Za=new WeakMap;function Qa(e,t,n=!1){let r=n?Za:t.emitsCache,i=r.get(e);if(i!==void 0)return i;let a=e.emits,o={},c=!1;if(!g(e)){let r=e=>{let n=Qa(e,t,!0);n&&(c=!0,s(o,n))};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}return!a&&!c?(y(e)&&r.set(e,null),null):(d(a)?a.forEach(e=>o[e]=null):s(o,a),y(e)&&r.set(e,o),o)}function $a(e,t){return!e||!a(t)?!1:(t=t.slice(2),t=t===`Once`?t:t.replace(/Once$/,``),u(e,t[0].toLowerCase()+t.slice(1))||u(e,k(t))||u(e,t))}function eo(e){let{type:t,vnode:n,proxy:r,withProxy:i,propsOptions:[a],slots:s,attrs:c,emit:l,render:u,renderCache:d,props:f,data:p,setupState:m,ctx:h,inheritAttrs:g}=e,_=er(e),v,y;try{if(n.shapeFlag&4){let e=i||r,t=e;v=bs(u.call(t,e,d,f,m,p,h)),y=c}else{let e=t;v=bs(e.length>1?e(f,{attrs:c,slots:s,emit:l}):e(f,null)),y=t.props?c:no(c)}}catch(t){$o.length=0,Mn(t,e,1),v=q(K)}let b=v;if(y&&g!==!1){let e=Object.keys(y),{shapeFlag:t}=b;e.length&&t&7&&(a&&e.some(o)&&(y=ro(y,a)),b=gs(b,y,!1,!0))}return n.dirs&&(b=gs(b,null,!1,!0),b.dirs=b.dirs?b.dirs.concat(n.dirs):n.dirs),n.transition&&Kr(xr(b.type)&&Gr(b)||b,n.transition),v=b,er(_),v}function to(e,t=!0){let n;for(let t=0;t<e.length;t++){let r=e[t];if(cs(r)){if(r.type!==K||r.children===`v-if`){if(n)return;n=r}}else return}return n}var no=e=>{let t;for(let n in e)(n===`class`||n===`style`||a(n))&&((t||={})[n]=e[n]);return t},ro=(e,t)=>{let n={};for(let r in e)(!o(r)||!(r.slice(9)in t))&&(n[r]=e[r]);return n};function io(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?ao(r,o,l):!!o;if(c&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let n=e[t];if(oo(o,r,n)&&!$a(l,n))return!0}}}else return(i||s)&&(!s||!s.$stable)?!0:r===o?!1:r?!o||ao(r,o,l):!!o;return!1}function ao(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(oo(t,e,a)&&!$a(n,a))return!0}return!1}function oo(e,t,n){let r=e[n],i=t[n];return n===`style`&&y(r)&&y(i)?!he(r,i):r!==i}function so({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 co={},lo=()=>Object.create(co),uo=e=>Object.getPrototypeOf(e)===co;function fo(e,t,n,r=!1){let i={},a=lo();e.propsDefaults=Object.create(null),mo(e,t,i,a);for(let t in e.propsOptions[0])t in i||(i[t]=void 0);e.props=n?r?i:zt(i):e.type.props?i:a,e.attrs=a}function po(e,t,n,r){let{props:i,attrs:a,vnode:{patchFlag:o}}=e,s=V(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($a(e.emitsOptions,o))continue;let d=t[o];if(c){if(u(a,o))d!==a[o]&&(a[o]=d,l=!0);else{let t=O(o);i[t]=ho(c,s,t,d,e,!1)}}else d!==a[o]&&(a[o]=d,l=!0)}}}else{mo(e,t,i,a)&&(l=!0);let r;for(let a in s)(!t||!u(t,a)&&((r=k(a))===a||!u(t,r)))&&(c?n&&(n[a]!==void 0||n[r]!==void 0)&&(i[a]=ho(c,s,a,void 0,e,!0)):delete i[a]);if(a!==s)for(let e in a)(!t||!u(t,e))&&(delete a[e],l=!0)}l&&tt(e.attrs,`set`,``)}function mo(e,n,r,i){let[a,o]=e.propsOptions,s=!1,c;if(n)for(let t in n){if(E(t))continue;let l=n[t],d;a&&u(a,d=O(t))?!o||!o.includes(d)?r[d]=l:(c||={})[d]=l:$a(e.emitsOptions,t)||(!(t in i)||l!==i[t])&&(i[t]=l,s=!0)}if(o){let n=V(r),i=c||t;for(let t=0;t<o.length;t++){let s=o[t];r[s]=ho(a,n,s,i[s],e,!u(i,s))}}return s}function ho(e,t,n,r,i,a){let o=e[n];if(o!=null){let e=u(o,`default`);if(e&&r===void 0){let e=o.default;if(o.type!==Function&&!o.skipFactory&&g(e)){let{propsDefaults:a}=i;if(n in a)r=a[n];else{let o=As(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===k(n))&&(r=!0))}return r}var go=new WeakMap;function _o(e,r,i=!1){let a=i?go:r.propsCache,o=a.get(e);if(o)return o;let c=e.props,l={},f=[],p=!1;if(!g(e)){let t=e=>{p=!0;let[t,n]=_o(e,r,!0);s(l,t),n&&f.push(...n)};!i&&r.mixins.length&&r.mixins.forEach(t),e.extends&&t(e.extends),e.mixins&&e.mixins.forEach(t)}if(!c&&!p)return y(e)&&a.set(e,n),n;if(d(c))for(let e=0;e<c.length;e++){let n=O(c[e]);vo(n)&&(l[n]=t)}else if(c)for(let e in c){let t=O(e);if(vo(t)){let n=c[e],r=l[t]=d(n)||g(n)?{type:n}:s({},n),i=r.type,a=!1,o=!0;if(d(i))for(let e=0;e<i.length;++e){let t=i[e],n=g(t)&&t.name;if(n===`Boolean`){a=!0;break}n===`String`&&(o=!1)}else a=g(i)&&i.name===`Boolean`;r[0]=a,r[1]=o,(a||u(r,`default`))&&f.push(t)}}let m=[l,f];return y(e)&&a.set(e,m),m}function vo(e){return e[0]!==`$`&&!E(e)}var yo=e=>e===`_`||e===`_ctx`||e===`$stable`,bo=e=>d(e)?e.map(bs):[bs(e)],xo=(e,t,n)=>{if(t._n)return t;let r=ir((...e)=>bo(t(...e)),n);return r._c=!1,r},So=(e,t,n)=>{let r=e._ctx;for(let n in e){if(yo(n))continue;let i=e[n];if(g(i))t[n]=xo(n,i,r);else if(i!=null){let e=bo(i);t[n]=()=>e}}},Co=(e,t)=>{let n=bo(t);e.slots.default=()=>n},wo=(e,t,n)=>{for(let r in t)(n||!yo(r))&&(e[r]=t[r])},To=(e,t,n)=>{let r=e.slots=lo();if(e.vnode.shapeFlag&32){let e=t._;e?(wo(r,t,n),n&&N(r,`_`,e,!0)):So(t,r)}else t&&Co(e,t)},Eo=(e,n,r)=>{let{vnode:i,slots:a}=e,o=!0,s=t;if(i.shapeFlag&32){let e=n._;e?r&&e===1?o=!1:wo(a,n,r):(o=!n.$stable,So(n,a)),s=n}else n&&(Co(e,n),s={default:1});if(o)for(let e in a)!yo(e)&&s[e]==null&&delete a[e]},W=Jo;function Do(e){return ko(e)}function Oo(e){return ko(e,ci)}function ko(e,i){let a=oe();a.__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=r,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&&!ls(e,t)&&(r=de(e),ce(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 Zo:y(e,t,n,r);break;case K:b(e,t,n,r);break;case Qo:e??x(t,n,r,o);break;case G:A(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?ne(e,t,n,r,i,a,o,s,c):(d&64||d&128)&&l.process(e,t,n,r,i,a,o,s,c,me)}u!=null&&i?ei(u,e&&e.ref,a,t||e,!t):u==null&&e&&e.ref!=null&&ei(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)T(t,n,r,i,a,o,s,c);else{let n=e.el&&e.el._isVueCE?e.el:null;try{n&&n._beginPatch(),O(e,t,i,a,o,s,c)}finally{n&&n._endPatch()}}},T=(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&&ee(e.children,d,null,r,i,Ao(e,a),s,u),_&&or(e,null,r,`created`),D(d,e,e.scopeId,s,r),m){for(let e in m)e!==`value`&&!E(e)&&c(d,e,null,m[e],a,r);`value`in m&&c(d,`value`,null,m.value,a),(f=m.onVnodeBeforeMount)&&ws(f,r,e)}_&&or(e,null,r,`beforeMount`);let v=Mo(i,g);v&&g.beforeEnter(d),o(d,t,n),((f=m&&m.onVnodeMounted)||v||_)&&W(()=>{try{f&&ws(f,r,e),v&&g.enter(d),_&&or(e,null,r,`mounted`)}finally{}},i)},D=(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||Ro(n.type)&&(n.ssContent===t||n.ssFallback===t)){let t=i.vnode;D(e,t,t.scopeId,t.slotScopeIds,i.parent)}}},ee=(e,t,n,r,i,a,o,s,c=0)=>{for(let l=c;l<e.length;l++){let c=e[l]=s?xs(e[l]):bs(e[l]);v(null,c,t,n,r,i,a,o,s)}},O=(e,n,r,i,a,o,s)=>{let l=n.el=e.el,{patchFlag:u,dynamicChildren:d,dirs:f}=n;u|=e.patchFlag&16;let m=e.props||t,h=n.props||t,g;if(r&&jo(r,!1),(g=h.onVnodeBeforeUpdate)&&ws(g,r,n,e),f&&or(n,e,r,`beforeUpdate`),r&&jo(r,!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?te(e.dynamicChildren,d,l,r,i,Ao(n,a),o):s||ae(e,n,l,null,r,i,Ao(n,a),o,!1),u>0){if(u&16)k(l,m,h,r,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=n.dynamicProps;for(let t=0;t<e.length;t++){let n=e[t],i=m[n],o=h[n];(o!==i||n===`value`)&&c(l,n,i,o,a,r)}}u&1&&e.children!==n.children&&p(l,n.children)}else!s&&d==null&&k(l,m,h,r,a);((g=h.onVnodeUpdated)||f)&&W(()=>{g&&ws(g,r,n,e),f&&or(n,e,r,`updated`)},i)},te=(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===G||!ls(c,l)||c.shapeFlag&198)?m(c.el):n;v(c,l,u,null,r,i,a,o,!0)}},k=(e,n,r,i,a)=>{if(n!==r){if(n!==t)for(let t in n)!E(t)&&!(t in r)&&c(e,t,n[t],null,a,i);for(let t in r){if(E(t))continue;let o=r[t],s=n[t];o!==s&&t!==`value`&&c(e,t,s,o,a,i)}`value`in r&&c(e,`value`,n.value,r.value,a)}},A=(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),ee(t.children||[],n,f,i,a,s,c,l)):p>0&&p&64&&m&&e.dynamicChildren&&e.dynamicChildren.length===m.length?(te(e.dynamicChildren,m,n,i,a,s,c),(t.key!=null||i&&t===i.subTree)&&No(e,t,!0)):ae(e,t,n,f,i,a,s,c,l)},ne=(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):j(t,n,r,i,a,o,c):N(e,t,c)},j=(e,t,n,r,i,a,o)=>{let s=e.component=Ds(e,r,i);if(ki(e)&&(s.ctx.renderer=me),Ps(s,!1,o),s.asyncDep){if(i&&i.registerDep(s,re,o),!e.el){let r=s.subTree=q(K);b(null,r,t,n),e.placeholder=r.el}}else re(s,e,t,n,i,a,o)},N=(e,t,n)=>{let r=t.component=e.component;if(io(e,t,n)){if(r.asyncDep&&!r.asyncResolved){ie(r,t,n);return}r.next=t,r.update()}else t.el=e.el,r.vnode=t},re=(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=Fo(e);if(n){t&&(t.el=c.el,ie(e,t,o)),n.asyncDep.then(()=>{W(()=>{e.isUnmounted||l()},i)});return}}let u=t,d;jo(e,!1),t?(t.el=c.el,ie(e,t,o)):t=c,n&&M(n),(d=t.props&&t.props.onVnodeBeforeUpdate)&&ws(d,s,t,c),jo(e,!0);let f=eo(e),p=e.subTree;e.subTree=f,v(p,f,m(p.el),de(p),e,i,a),t.el=f.el,u===null&&so(e,f.el),r&&W(r,i),(d=t.props&&t.props.onVnodeUpdated)&&W(()=>ws(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=Ei(t);if(jo(e,!1),l&&M(l),!m&&(o=c&&c.onVnodeBeforeMount)&&ws(o,d,t),jo(e,!0),s&&ge){let t=()=>{e.subTree=eo(e),ge(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=eo(e);v(null,o,n,r,e,i,a),t.el=o.el}if(u&&W(u,i),!m&&(o=c&&c.onVnodeMounted)){let e=t;W(()=>ws(o,d,e),i)}(t.shapeFlag&256||d&&Ei(d.vnode)&&d.vnode.shapeFlag&256)&&e.a&&W(e.a,i),e.isMounted=!0,t=n=r=null}};e.scope.on();let c=e.effect=new De(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=()=>Un(u),jo(e,!0),l()},ie=(e,t,n)=>{t.component=e;let r=e.vnode.props;e.vnode=t,e.next=null,po(e,t.props,r,n),Eo(e,t.children,n),We(),Kn(e),Ge()},ae=(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){F(l,d,n,r,i,a,o,s,c);return}if(f&256){P(l,d,n,r,i,a,o,s,c);return}}m&8?(u&16&&ue(l,i,a),d!==l&&p(n,d)):u&16?m&16?F(l,d,n,r,i,a,o,s,c):ue(l,i,a,!0):(u&8&&p(n,``),m&16&&ee(d,n,r,i,a,o,s,c))},P=(e,t,r,i,a,o,s,c,l)=>{e||=n,t||=n;let u=e.length,d=t.length,f=Math.min(u,d),p;for(p=0;p<f;p++){let n=t[p]=l?xs(t[p]):bs(t[p]);v(e[p],n,r,null,a,o,s,c,l)}u>d?ue(e,a,o,!0,!1,f):ee(t,r,i,a,o,s,c,l,f)},F=(e,t,r,i,a,o,s,c,l)=>{let u=0,d=t.length,f=e.length-1,p=d-1;for(;u<=f&&u<=p;){let n=e[u],i=t[u]=l?xs(t[u]):bs(t[u]);if(ls(n,i))v(n,i,r,null,a,o,s,c,l);else break;u++}for(;u<=f&&u<=p;){let n=e[f],i=t[p]=l?xs(t[p]):bs(t[p]);if(ls(n,i))v(n,i,r,null,a,o,s,c,l);else break;f--,p--}if(u>f){if(u<=p){let e=p+1,n=e<d?t[e].el:i;for(;u<=p;)v(null,t[u]=l?xs(t[u]):bs(t[u]),r,n,a,o,s,c,l),u++}}else if(u>p)for(;u<=f;)ce(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?xs(t[u]):bs(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 n=e[u];if(y>=b){ce(n,a,o,!0);continue}let i;if(n.key!=null)i=g.get(n.key);else for(_=h;_<=p;_++)if(C[_-h]===0&&ls(n,t[_])){i=_;break}i===void 0?ce(n,a,o,!0):(C[i-h]=u+1,i>=S?S=i:x=!0,v(n,t[i],r,null,a,o,s,c,l),y++)}let w=x?Po(C):n;for(_=w.length-1,u=b-1;u>=0;u--){let e=h+u,n=t[e],f=t[e+1],p=e+1<d?f.el||Lo(f):i;C[u]===0?v(null,n,r,p,a,o,s,c,l):x&&(_<0||u!==w[_]?se(n,r,p,2):_--)}}},se=(e,t,n,r,i=null)=>{let{el:a,type:c,transition:l,children:u,shapeFlag:d}=e;if(d&6){se(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,me);return}if(c===G){o(a,t,n);for(let e=0;e<u.length;e++)se(u[e],t,n,r);o(e.anchor,t,n);return}if(c===Qo){S(e,t,n);return}if(r!==2&&d&1&&l){if(r===0)l.persisted&&!a[Nr]?o(a,t,n):(l.beforeEnter(a),o(a,t,n),W(()=>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[Nr];a._isLeaving&&a[Nr](!0),l.persisted&&!e?u():r(a,()=>{u(),c&&c()})};i?i(a,u,d):d()}}else o(a,t,n)},ce=(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&&(We(),ei(s,null,n,e,!0),Ge()),p!=null&&(t.renderCache[p]=void 0),u&256){t.ctx.deactivate(e);return}let h=u&1&&f,g=!Ei(e),_;if(g&&(_=o&&o.onVnodeBeforeUnmount)&&ws(_,t,e),u&6)L(e.component,n,r);else{if(u&128){e.suspense.unmount(n,r);return}h&&or(e,null,t,`beforeUnmount`),u&64?e.type.remove(e,t,n,me,r):l&&!l.hasOnce&&(a!==G||d>0&&d&64)?ue(l,t,n,!1,!0):(a===G&&d&384||!i&&u&16)&&ue(c,t,n),r&&I(e)}let v=m!=null&&p==null;(g&&(_=o&&o.onVnodeUnmounted)||h||v)&&W(()=>{_&&ws(_,t,e),h&&or(e,null,t,`unmounted`),v&&(e.el=null)},n)},I=e=>{let{type:t,el:n,anchor:r,transition:i}=e;if(t===G){le(n,r);return}if(t===Qo){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()},le=(e,t)=>{let n;for(;e!==t;)n=h(e),s(e),e=n;s(t)},L=(e,t,n)=>{let{bum:r,scope:i,job:a,subTree:o,um:s,m:c,a:l}=e;Io(c),Io(l),r&&M(r),i.stop(),a&&(a.flags|=8,ce(o,e,t,n)),s&&W(s,t),W(()=>{e.isUnmounted=!0},t)},ue=(e,t,n,r=!1,i=!1,a=0)=>{for(let o=a;o<e.length;o++)ce(e[o],t,n,r,i)},de=e=>{if(e.shapeFlag&6)return de(e.component.subTree);if(e.shapeFlag&128)return e.suspense.next();let t=h(e.anchor||e.el),n=t&&t[br];return n?h(n):t},fe=!1,pe=(e,t,n)=>{let r;e==null?t._vnode&&(ce(t._vnode,null,null,!0),r=t._vnode.component):v(t._vnode||null,e,t,null,null,null,n),t._vnode=e,fe||=(fe=!0,Kn(r),qn(),!1)},me={p:v,um:ce,m:se,r:I,mt:j,mc:ee,pc:ae,pbc:te,n:de,o:e},he,ge;return i&&([he,ge]=i(me)),{render:pe,hydrate:he,createApp:Ka(pe,he)}}function Ao({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 jo({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function Mo(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function No(e,t,n=!1){let r=e.children,i=t.children;if(d(r)&&d(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]=xs(i[e]),a.el=t.el),!n&&a.patchFlag!==-2&&No(t,a)),a.type===Zo&&(a.patchFlag===-1&&(a=i[e]=xs(a)),a.el=t.el),a.type===K&&!a.el&&(a.el=t.el)}}function Po(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 Fo(e){let t=e.subTree.component;if(t)return t.asyncDep&&!t.asyncResolved?t:Fo(t)}function Io(e){if(e)for(let t=0;t<e.length;t++)e[t].flags|=8}function Lo(e){if(e.placeholder)return e.placeholder;let t=e.component;return t?Lo(t.subTree):null}var Ro=e=>e.__isSuspense,zo=0,Bo={name:`Suspense`,__isSuspense:!0,process(e,t,n,r,i,a,o,s,c,l){if(e==null)Ho(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}Uo(e,t,n,r,i,o,s,c,l)}},hydrate:Go,normalize:Ko};function Vo(e,t){let n=e.props&&e.props[t];g(n)&&n()}function Ho(e,t,n,r,i,a,o,s,c){let{p:l,o:{createElement:u}}=c,d=u(`div`),f=e.suspense=Wo(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?(Vo(e,`onPending`),Vo(e,`onFallback`),l(null,e.ssFallback,t,n,r,null,a,o),Yo(f,e.ssFallback)):f.resolve(!1,!0)}function Uo(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,ls(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),Yo(d,p)))):(d.pendingId=zo++,_?(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),Yo(d,p))):m&&ls(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&&ls(m,f))c(m,f,n,r,i,d,a,o,s),Yo(d,f);else if(Vo(t,`onPending`),d.pendingBranch=f,d.pendingId=f.shapeFlag&512?f.component.suspenseId:zo++,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 Wo(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=Xo(e);v&&t&&t.pendingBranch&&(_=t.pendingId,t.deps++);let y=e.props?ie(e.props.timeout):void 0,b=a,x={vnode:e,parent:t,parentComponent:n,namespace:o,container:r,hiddenContainer:i,deps:0,pendingId:zo++,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),Gn(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&&W(()=>r.ssFallback.el=null,x)),g||f(o,u,a,0)}x.isFallbackMountPending=!1,Yo(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&&Gn(c),x.effects=[],v&&t&&t.pendingBranch&&_===t.pendingId&&(t.deps--,t.deps===0&&!n&&t.resolve()),Vo(r,`onResolve`)},fallback(e){if(!x.pendingBranch)return;let{vnode:t,activeBranch:n,parentComponent:r,container:i,namespace:a}=x;Vo(t,`onFallback`);let o=m(n),l=()=>{x.isFallbackMountPending=!1,x.isInFallback&&(d(null,e,i,o,r,null,a,s,c),Yo(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=>{Mn(t,e,0)}).then(a=>{if(e.isUnmounted||x.isUnmounted||x.pendingId!==e.suspenseId)return;js(),e.asyncResolved=!0;let{vnode:s}=e;Is(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)),so(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 Go(e,t,n,r,i,a,o,s,c){let l=t.suspense=Wo(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 Ko(e){let{shapeFlag:t,children:n}=e,r=t&32;e.ssContent=qo(r?n.default:n),e.ssFallback=r?qo(n.fallback):q(K)}function qo(e){let t;if(g(e)){let n=rs&&e._c;n&&(e._d=!1,ts()),e=e(),n&&(e._d=!0,t=es,ns())}return d(e)&&(e=to(e)),e=bs(e),t&&!e.dynamicChildren&&(e.dynamicChildren=t.filter(t=>t!==e)),e}function Jo(e,t){t&&t.pendingBranch?d(e)?t.effects.push(...e):t.effects.push(e):Gn(e)}function Yo(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,so(r,i))}function Xo(e){let t=e.props&&e.props.suspensible;return t!=null&&t!==!1}var G=Symbol.for(`v-fgt`),Zo=Symbol.for(`v-txt`),K=Symbol.for(`v-cmt`),Qo=Symbol.for(`v-stc`),$o=[],es=null;function ts(e=!1){$o.push(es=e?null:[])}function ns(){$o.pop(),es=$o[$o.length-1]||null}var rs=1;function is(e,t=!1){rs+=e,e<0&&es&&t&&(es.hasOnce=!0)}function as(e){return e.dynamicChildren=rs>0?es||n:null,ns(),rs>0&&es&&es.push(e),e}function os(e,t,n,r,i,a){return as(ps(e,t,n,r,i,a,!0))}function ss(e,t,n,r,i){return as(q(e,t,n,r,i,!0))}function cs(e){return e?e.__v_isVNode===!0:!1}function ls(e,t){return e.type===t.type&&e.key===t.key}function us(e){}var ds=({key:e})=>e??null,fs=({ref:e,ref_key:t,ref_for:n})=>(typeof e==`number`&&(e=``+e),e==null?null:_(e)||H(e)||g(e)?{i:U,r:e,k:t,f:!!n}:e);function ps(e,t=null,n=null,r=0,i=null,a=e===G?0:1,o=!1,s=!1){let c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&ds(t),ref:t&&fs(t),scopeId:$n,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:U};return s?(Ss(c,n),a&128&&e.normalize(c)):n&&(c.shapeFlag|=_(n)?8:16),rs>0&&!o&&es&&(c.patchFlag>0||a&6)&&c.patchFlag!==32&&es.push(c),c}var q=ms;function ms(e,t=null,n=null,r=0,i=null,a=!1){if((!e||e===$i)&&(e=K),cs(e)){let r=gs(e,t,!0);return n&&Ss(r,n),rs>0&&!a&&es&&(r.shapeFlag&6?es[es.indexOf(e)]=r:es.push(r)),r.patchFlag=-2,r}if(Ks(e)&&(e=e.__vccOpts),t){t=hs(t);let{class:e,style:n}=t;e&&!_(e)&&(t.class=L(e)),y(n)&&(Kt(n)&&!d(n)&&(n=s({},n)),t.style=F(n))}let o=_(e)?1:Ro(e)?128:xr(e)?64:y(e)?4:g(e)?2:0;return ps(e,t,n,r,i,o,a,!0)}function hs(e){return e?Kt(e)||uo(e)?s({},e):e:null}function gs(e,t,n=!1,r=!1){let{props:i,ref:a,patchFlag:o,children:s,transition:c}=e,l=t?Cs(i||{},t):i,u={__v_isVNode:!0,__v_skip:!0,type:e.type,props:l,key:l&&ds(l),ref:t&&t.ref?n&&a?d(a)?a.concat(fs(t)):[a,fs(t)]:fs(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!==G?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&&gs(e.ssContent),ssFallback:e.ssFallback&&gs(e.ssFallback),placeholder:e.placeholder,el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce};return c&&r&&Kr(u,c.clone(u)),u}function _s(e=` `,t=0){return q(Zo,null,e,t)}function vs(e,t){let n=q(Qo,null,e);return n.staticCount=t,n}function ys(e=``,t=!1){return t?(ts(),ss(K,null,e)):q(K,null,e)}function bs(e){return e==null||typeof e==`boolean`?q(K):d(e)?q(G,null,e.slice()):cs(e)?xs(e):q(Zo,null,String(e))}function xs(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:gs(e)}function Ss(e,t){let n=0,{shapeFlag:r}=e;if(t==null)t=null;else if(d(t))n=16;else if(typeof t==`object`){if(r&65){let n=t.default;n&&(n._c&&(n._d=!1),Ss(e,n()),n._c&&(n._d=!0));return}{n=32;let r=t._;!r&&!uo(t)?t._ctx=U:r===3&&U&&(U.slots._===1?t._=1:(t._=2,e.patchFlag|=1024))}}else if(g(t)){if(r&65){Ss(e,{default:t});return}t={default:t,_ctx:U},n=32}else t=String(t),r&64?(n=16,t=[_s(t)]):n=8;e.children=t,e.shapeFlag|=n}function Cs(...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=L([t.class,r.class]));else if(e===`style`)t.style=F([t.style,r.style]);else if(a(e)){let n=t[e],i=r[e];i&&n!==i&&!(d(n)&&n.includes(i))?t[e]=n?[].concat(n,i):i:i==null&&n==null&&!o(e)&&(t[e]=i)}else e!==``&&(t[e]=r[e])}return t}function ws(e,t,n,r=null){jn(e,t,7,[n,r])}var Ts=Wa(),Es=0;function Ds(e,n,r){let i=e.type,a=(n?n.appContext:e.appContext)||Ts,o={uid:Es++,vnode:e,type:i,parent:n,appContext:a,root:null,next:null,subTree:null,effect:null,update:null,job:null,scope:new Se(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:n?n.provides:Object.create(a.provides),ids:n?n.ids:[``,0,0],accessCache:null,renderCache:[],components:null,directives:null,propsOptions:_o(i,a),emitsOptions:Qa(i,a),emit:null,emitted:null,propsDefaults:t,inheritAttrs:i.inheritAttrs,ctx:t,data:t,props:t,attrs:t,slots:t,refs:t,setupState:t,setupContext:null,suspense:r,suspenseId:r?r.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=n?n.root:o,o.emit=Xa.bind(null,o),e.ce&&e.ce(o),o}var J=null,Y=()=>J||U,Os,ks;{let e=oe(),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)}};Os=t(`__VUE_INSTANCE_SETTERS__`,e=>J=e),ks=t(`__VUE_SSR_SETTERS__`,e=>Ns=e)}var As=e=>{let t=J;return Os(e),e.scope.on(),()=>{e.scope.off(),Os(t)}},js=()=>{J&&J.scope.off(),Os(null)};function Ms(e){return e.vnode.shapeFlag&4}var Ns=!1;function Ps(e,t=!1,n=!1){t&&ks(t);let{props:r,children:i}=e.vnode,a=Ms(e);fo(e,r,a,t),To(e,i,n||t);let o=a?Fs(e,t):void 0;return t&&ks(!1),o}function Fs(e,t){let n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,fa);let{setup:r}=n;if(r){We();let n=e.setupContext=r.length>1?Us(e):null,i=As(e),a=An(r,e,0,[e.props,n]),o=b(a);if(Ge(),i(),(o||e.sp)&&!Ei(e)&&Xr(e),o){if(a.then(js,js),t)return a.then(n=>{ks(!0);try{Is(e,n,t)}finally{ks(!1)}}).catch(t=>{Mn(t,e,0)});e.asyncDep=a}else Is(e,a,t)}else Vs(e,t)}function Is(e,t,n){g(t)?e.type.__ssrInlineRender?e.ssrRender=t:e.render=t:y(t)&&(e.setupState=an(t)),Vs(e,n)}var Ls,Rs;function zs(e){Ls=e,Rs=e=>{e.render._rc&&(e.withProxy=new Proxy(e.ctx,pa))}}var Bs=()=>!Ls;function Vs(e,t,n){let i=e.type;if(!e.render){if(!t&&Ls&&!i.render){let t=i.template||Pa(e).template;if(t){let{isCustomElement:n,compilerOptions:r}=e.appContext.config,{delimiters:a,compilerOptions:o}=i,c=s(s({isCustomElement:n,delimiters:a},r),o);i.render=Ls(t,c)}}e.render=i.render||r,Rs&&Rs(e)}{let t=As(e);We();try{Aa(e)}finally{Ge(),t()}}}var Hs={get(e,t){return B(e,`get`,``),e[t]}};function Us(e){return{attrs:new Proxy(e.attrs,Hs),slots:e.slots,emit:e.emit,expose:t=>{e.exposed=t||{}}}}function Ws(e){return e.exposed?e.exposeProxy||=new Proxy(an(qt(e.exposed)),{get(t,n){if(n in t)return t[n];if(n in ua)return ua[n](e)},has(e,t){return t in e||t in ua}}):e.proxy}function Gs(e,t=!0){return g(e)?e.displayName||e.name:e.name||t&&e.__name}function Ks(e){return g(e)&&`__vccOpts`in e}var qs=(e,t)=>mn(e,t,Ns);function Js(e,t,n){try{is(-1);let r=arguments.length;return r===2?y(t)&&!d(t)?cs(t)?q(e,null,[t]):q(e,t):q(e,null,t):(r>3?n=Array.prototype.slice.call(arguments,2):r===3&&cs(n)&&(n=[n]),q(e,t,n))}finally{is(1)}}function Ys(){}function Xs(e,t,n,r){let i=n[r];if(i&&Zs(i,e))return i;let a=t();return a.memo=e.slice(),a.cacheIndex=r,n[r]=a}function Zs(e,t){let n=e.memo;if(n.length!=t.length)return!1;for(let e=0;e<n.length;e++)if(j(n[e],t[e]))return!1;return rs>0&&es&&es.push(e),!0}var Qs=`3.5.41`,$s=r,ec=kn,tc=Xn,nc=Qn,rc={createComponentInstance:Ds,setupComponent:Ps,renderComponentRoot:eo,setCurrentRenderingInstance:er,isVNode:cs,normalizeVNode:bs,getComponentPublicInstance:Ws,ensureValidVNode:sa,pushWarningContext:Tn,popWarningContext:En},ic=void 0,ac=typeof window<`u`&&window.trustedTypes;if(ac)try{ic=ac.createPolicy(`vue`,{createHTML:e=>e})}catch{}var oc=ic?e=>ic.createHTML(e):e=>e,sc=`http://www.w3.org/2000/svg`,cc=`http://www.w3.org/1998/Math/MathML`,lc=typeof document<`u`?document:null,uc=lc&&lc.createElement(`template`),dc={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`?lc.createElementNS(sc,e):t===`mathml`?lc.createElementNS(cc,e):n?lc.createElement(e,{is:n}):lc.createElement(e);return e===`select`&&r&&r.multiple!=null&&i.setAttribute(`multiple`,r.multiple),i},createText:e=>lc.createTextNode(e),createComment:e=>lc.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>lc.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{uc.innerHTML=oc(r===`svg`?`<svg>${e}</svg>`:r===`mathml`?`<math>${e}</math>`:e);let i=uc.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]}},fc=`transition`,pc=`animation`,mc=Symbol(`_vtc`),hc={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},gc=s({},Lr,hc),_c=(e=>(e.displayName=`Transition`,e.props=gc,e))((e,{slots:t})=>Js(Vr,bc(e),t)),vc=(e,t=[])=>{d(e)?e.forEach(e=>e(...t)):e&&e(...t)},yc=e=>e?d(e)?e.some(e=>e.length>1):e.length>1:!1;function bc(e){let t={};for(let n in e)n in hc||(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:c=`${n}-enter-to`,appearFromClass:l=a,appearActiveClass:u=o,appearToClass:d=c,leaveFromClass:f=`${n}-leave-from`,leaveActiveClass:p=`${n}-leave-active`,leaveToClass:m=`${n}-leave-to`}=e,h=xc(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:T=b}=t,E=(e,t,n,r)=>{e._enterCancelled=r,wc(e,t?d:c),wc(e,t?u:o),n&&n()},D=(e,t)=>{e._isLeaving=!1,wc(e,f),wc(e,m),wc(e,p),t&&t()},ee=e=>(t,n)=>{let i=e?w:y,o=()=>E(t,e,n);vc(i,[t,o]),Tc(()=>{wc(t,e?l:a),Cc(t,e?d:c),yc(i)||Dc(t,r,g,o)})};return s(t,{onBeforeEnter(e){vc(v,[e]),Cc(e,a),Cc(e,o)},onBeforeAppear(e){vc(C,[e]),Cc(e,l),Cc(e,u)},onEnter:ee(!1),onAppear:ee(!0),onLeave(e,t){e._isLeaving=!0;let n=()=>D(e,t);Cc(e,f),e._enterCancelled?(Cc(e,p),jc(e)):(jc(e),Cc(e,p)),Tc(()=>{e._isLeaving&&(wc(e,f),Cc(e,m),yc(x)||Dc(e,r,_,n))}),vc(x,[e,n])},onEnterCancelled(e){E(e,!1,void 0,!0),vc(b,[e])},onAppearCancelled(e){E(e,!0,void 0,!0),vc(T,[e])},onLeaveCancelled(e){D(e),vc(S,[e])}})}function xc(e){if(e==null)return null;if(y(e))return[Sc(e.enter),Sc(e.leave)];{let t=Sc(e);return[t,t]}}function Sc(e){return ie(e)}function Cc(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.add(t)),(e[mc]||(e[mc]=new Set)).add(t)}function wc(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.remove(t));let n=e[mc];n&&(n.delete(t),n.size||(e[mc]=void 0))}function Tc(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}var Ec=0;function Dc(e,t,n,r){let i=e._endId=++Ec,a=()=>{i===e._endId&&r()};if(n!=null)return setTimeout(a,n);let{type:o,timeout:s,propCount:c}=Oc(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 Oc(e,t){let n=window.getComputedStyle(e),r=e=>(n[e]||``).split(`, `),i=r(`${fc}Delay`),a=r(`${fc}Duration`),o=kc(i,a),s=r(`${pc}Delay`),c=r(`${pc}Duration`),l=kc(s,c),u=null,d=0,f=0;t===fc?o>0&&(u=fc,d=o,f=a.length):t===pc?l>0&&(u=pc,d=l,f=c.length):(d=Math.max(o,l),u=d>0?o>l?fc:pc:null,f=u?u===fc?a.length:c.length:0);let p=u===fc&&/\b(?:transform|all)(?:,|$)/.test(r(`${fc}Property`).toString());return{type:u,timeout:d,propCount:f,hasTransform:p}}function kc(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max(...t.map((t,n)=>Ac(t)+Ac(e[n])))}function Ac(e){return e===`auto`?0:Number(e.slice(0,-1).replace(`,`,`.`))*1e3}function jc(e){return(e?e.ownerDocument:document).body.offsetHeight}function Mc(e,t,n){let r=e[mc];r&&(t=(t?[t,...r]:[...r]).join(` `)),t==null?e.removeAttribute(`class`):n?e.setAttribute(`class`,t):e.className=t}var Nc=Symbol(`_vod`),Pc=Symbol(`_vsh`),Fc={name:`show`,beforeMount(e,{value:t},{transition:n}){e[Nc]=e.style.display===`none`?``:e.style.display,n&&t?n.beforeEnter(e):Ic(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),Ic(e,!0),r.enter(e)):r.leave(e,()=>{Ic(e,!1)}):Ic(e,t))},beforeUnmount(e,{value:t}){Ic(e,t)}};function Ic(e,t){e.style.display=t?e[Nc]:`none`,e[Pc]=!t}function Lc(){Fc.getSSRProps=({value:e})=>{if(!e)return{style:{display:`none`}}}}var Rc=Symbol(``);function zc(e){let t=Y();if(!t)return;let n=t.ut=(n=e(t.proxy))=>{Array.from(document.querySelectorAll(`[data-v-owner="${t.uid}"]`)).forEach(e=>Vc(e,n))},i=()=>{let r=e(t.proxy);t.ce?Vc(t.ce,r):Bc(t.subTree,r),n(r)};Hi(()=>{Gn(i)}),Vi(()=>{hr(i,r,{flush:`post`});let e=new MutationObserver(i);e.observe(t.subTree.el.parentNode,{childList:!0}),Gi(()=>e.disconnect())})}function Bc(e,t){if(e.shapeFlag&128){let n=e.suspense;e=n.activeBranch,n.pendingBranch&&!n.isHydrating&&n.effects.push(()=>{Bc(n.activeBranch,t)})}for(;e.component;)e=e.component.subTree;if(e.shapeFlag&1&&e.el)Vc(e.el,t);else if(e.type===G)e.children.forEach(e=>Bc(e,t));else if(e.type===Qo){let{el:n,anchor:r}=e;for(;n&&(Vc(n,t),n!==r);)n=n.nextSibling}}function Vc(e,t){if(e.nodeType===1){let n=e.style,r=``;for(let e in t){let i=xe(t[e]);n.setProperty(`--${e}`,i),r+=`--${e}: ${i};`}n[Rc]=r}}var Hc=/(?:^|;)\s*display\s*:/;function Uc(e,t,n){let r=e.style,i=_(n),a=!1;if(n&&!i){if(t){if(_(t))for(let e of t.split(`;`)){let t=e.slice(0,e.indexOf(`:`)).trim();n[t]??Gc(r,t,``)}else for(let e in t)n[e]??Gc(r,e,``)}for(let i in n){i===`display`&&(a=!0);let o=n[i];o==null?Gc(r,i,``):Yc(e,i,!_(t)&&t?t[i]:void 0,o)||Gc(r,i,o)}}else if(i){if(t!==n){let e=r[Rc];e&&(n+=`;`+e),r.cssText=n,a=Hc.test(n)}}else t&&e.removeAttribute(`style`);Nc in e&&(e[Nc]=a?r.display:``,e[Pc]&&(r.display=`none`))}var Wc=/\s*!important$/;function Gc(e,t,n){if(d(n))n.forEach(n=>Gc(e,t,n));else if(n??=``,t.startsWith(`--`))e.setProperty(t,n);else{let r=Jc(e,t);Wc.test(n)?e.setProperty(k(r),n.replace(Wc,``),`important`):e[r]=n}}var Kc=[`Webkit`,`Moz`,`ms`],qc={};function Jc(e,t){let n=qc[t];if(n)return n;let r=O(t);if(r!==`filter`&&r in e)return qc[t]=r;r=A(r);for(let n=0;n<Kc.length;n++){let i=Kc[n]+r;if(i in e)return qc[t]=i}return t}function Yc(e,t,n,r){return e.tagName===`TEXTAREA`&&(t===`width`||t===`height`)&&_(r)&&n===r}var Xc=`http://www.w3.org/1999/xlink`;function Zc(e,t,n,r,i,a=fe(t)){r&&t.startsWith(`xlink:`)?n==null?e.removeAttributeNS(Xc,t.slice(6,t.length)):e.setAttributeNS(Xc,t,n):n==null||a&&!pe(n)?e.removeAttribute(t):e.setAttribute(t,a?``:v(n)?String(n):n)}function Qc(e,t,n,r,i){if(t===`innerHTML`||t===`textContent`){n!=null&&(e[t]=t===`innerHTML`?oc(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=pe(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 $c(e,t,n,r){e.addEventListener(t,n,r)}function el(e,t,n,r){e.removeEventListener(t,n,r)}var tl=Symbol(`_vei`);function nl(e,t,n,r,i=null){let a=e[tl]||(e[tl]={}),o=a[t];if(r&&o)o.value=r;else{let[n,s]=al(t);r?$c(e,n,a[t]=ll(r,i),s):o&&(el(e,n,o,s),a[t]=void 0)}}var rl=/(Once|Passive|Capture)$/,il=/^on:?(?:Once|Passive|Capture)$/;function al(e){let t,n;for(;(n=e.match(rl))&&!il.test(e);)t||={},e=e.slice(0,e.length-n[1].length),t[n[1].toLowerCase()]=!0;return[e[2]===`:`?e.slice(3):k(e.slice(2)),t]}var ol=0,sl=Promise.resolve(),cl=()=>ol||=(sl.then(()=>ol=0),Date.now());function ll(e,t){let n=e=>{if(!e._vts)e._vts=Date.now();else if(e._vts<=n.attached)return;let r=n.value;if(d(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&&jn(e,t,5,a)}}else jn(r,t,5,[e])};return n.value=e,n.attached=cl(),n}var ul=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,dl=(e,t,n,r,i,s)=>{let c=i===`svg`;t===`class`?Mc(e,r,c):t===`style`?Uc(e,n,r):a(t)?o(t)||nl(e,t,n,r,s):(t[0]===`.`?(t=t.slice(1),!0):t[0]===`^`?(t=t.slice(1),!1):fl(e,t,r,c))?(Qc(e,t,r),!e.tagName.includes(`-`)&&(t===`value`||t===`checked`||t===`selected`)&&Zc(e,t,r,c,s,t!==`value`)):e._isVueCE&&(pl(e,t)||e._def.__asyncLoader&&(/[A-Z]/.test(t)||!_(r)))?Qc(e,O(t),r,s,t):(t===`true-value`?e._trueValue=r:t===`false-value`&&(e._falseValue=r),Zc(e,t,r,c))};function fl(e,t,n,r){if(r)return!!(t===`innerHTML`||t===`textContent`||t in e&&ul(t)&&g(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 ul(t)&&_(n)?!1:t in e}function pl(e,t){let n=e._def.props;if(!n)return!1;let r=O(t);return Array.isArray(n)?n.some(e=>O(e)===r):Object.keys(n).some(e=>O(e)===r)}var ml={};function hl(e,t,n){let r=Jr(e,t);w(r)&&(r=s({},r,t));class i extends vl{constructor(e){super(r,e,n)}}return i.def=r,i}var gl=((e,t)=>hl(e,t,lu)),_l=typeof HTMLElement<`u`?HTMLElement:class{},vl=class e extends _l{constructor(e,t={},n=cu){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!==cu?this._root=this.shadowRoot:e.shadowRoot===!1?this._root=this:(this.attachShadow(s({},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,Vn(()=>{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&&!d(n))for(let e in n){let t=n[e];(t===Number||t&&t.type===Number)&&(e in this._props&&(this._props[e]=ie(this._props[e])),(i||=Object.create(null))[O(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)u(this,e)||Object.defineProperty(this,e,{get:()=>tn(t[e])})}_resolveProps(e){let{props:t}=e,n=d(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(O))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):ml,r=O(e);t&&this._numberProps&&this._numberProps[r]&&(n=ie(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===ml?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(k(e),``):typeof t==`string`||typeof t==`number`?this.setAttribute(k(e),t+``):t||this.removeAttribute(k(e)),n&&n.observe(this,{attributes:!0})}}_update(){let e=this._createVNode();this._app&&(e.appContext=this._app._context),ou(e,this._root)}_createVNode(){let e={};this.shadowRoot||(e.onVnodeMounted=e.onVnodeUpdated=this._renderSlots.bind(this));let t=q(this._def,s(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,w(t[0])?s({detail:t},t[0]):{detail:t}))};e.emit=(e,...n)=>{t(e,n),k(e)!==e&&t(k(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 yl(e){let t=Y();return t&&t.ce||null}function bl(){let e=yl();return e&&e.shadowRoot}function xl(e=`$style`){{let n=Y();if(!n)return t;let r=n.type.__cssModules;return r&&r[e]||t}}var Sl=new WeakMap,Cl=new WeakMap,wl=Symbol(`_moveCb`),Tl=Symbol(`_enterCb`),El=(e=>(delete e.props.mode,e))({name:`TransitionGroup`,props:s({},gc,{tag:String,moveClass:String}),setup(e,{slots:t}){let n=Y(),r=Fr(),i,a;return Ui(()=>{if(!i.length)return;let t=e.moveClass||`${e.name||`v`}-move`;if(!jl(i[0].el,n.vnode.el,t)){i=[];return}i.forEach(Dl),i.forEach(Ol);let r=i.filter(kl);jc(n.vnode.el),r.forEach(e=>{let n=e.el,r=n.style;Cc(n,t),r.transform=r.webkitTransform=r.transitionDuration=``;let i=n[wl]=e=>{e&&e.target!==n||(!e||e.propertyName.endsWith(`transform`))&&(n.removeEventListener(`transitionend`,i),n[wl]=null,wc(n,t))};n.addEventListener(`transitionend`,i)}),i=[]}),()=>{let o=V(e),s=bc(o),c=o.tag||G;if(i=[],a)for(let e=0;e<a.length;e++){let t=a[e];t.el&&t.el instanceof Element&&!t.el[Pc]&&(i.push(t),Kr(t,Ur(t,s,r,n)),Sl.set(t,Al(t.el)))}a=t.default?qr(t.default()):[];for(let e=0;e<a.length;e++){let t=a[e];t.key!=null&&Kr(t,Ur(t,s,r,n))}return q(c,null,a)}}});function Dl(e){let t=e.el;t[wl]&&t[wl](),t[Tl]&&t[Tl]()}function Ol(e){Cl.set(e,Al(e.el))}function kl(e){let t=Sl.get(e),n=Cl.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 Al(e){let t=e.getBoundingClientRect();return{left:t.left,top:t.top}}function jl(e,t,n){let r=e.cloneNode(),i=e[mc];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}=Oc(r);return a.removeChild(r),o}var Ml=e=>{let t=e.props[`onUpdate:modelValue`]||!1;return d(t)?e=>M(t,e):t};function Nl(e){e.target.composing=!0}function Pl(e){let t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event(`input`)))}var Fl=Symbol(`_assign`),Il=Symbol(`_initialValue`);function Ll(e,t,n){return t&&(e=e.trim()),n&&(e=re(e)),e}var Rl={created(e,{modifiers:{lazy:t,trim:n,number:r}},i){e.parentNode&&(e.type===`text`?e[Il]=e.defaultValue.replace(/[\r\n]/g,``):e.type===`textarea`&&(e[Il]=e.defaultValue.replace(/\r\n?/g,`
`))),e[Fl]=Ml(i);let a=r||i.props&&i.props.type===`number`;$c(e,t?`change`:`input`,t=>{t.target.composing||e[Fl](Ll(e.value,n,a))}),(n||a)&&$c(e,`change`,()=>{e.value=Ll(e.value,n,a)}),t||($c(e,`compositionstart`,Nl),$c(e,`compositionend`,Pl),$c(e,`change`,Pl))},mounted(e,{value:t,modifiers:{trim:n,number:r}}){let i=t??``,a=e[Il];delete e[Il],a!==void 0&&(e.type===`text`||e.type===`textarea`)&&e.value!==a?e[Fl](Ll(e.value,n,r)):e.value=i},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:r,trim:i,number:a}},o){if(e[Fl]=Ml(o),e.composing)return;let s=(a||e.type===`number`)&&!/^0\d/.test(e.value)?re(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)}},zl={deep:!0,created(e,t,n){e[Fl]=Ml(n),$c(e,`change`,()=>{let t=e._modelValue,n=Wl(e),r=e.checked,i=e[Fl];if(d(t)){let e=ge(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(p(t)){let e=new Set(t);r?e.add(n):e.delete(n),i(e)}else i(Gl(e,r))})},mounted:Bl,beforeUpdate(e,t,n){e[Fl]=Ml(n),Bl(e,t,n)}};function Bl(e,{value:t,oldValue:n},r){e._modelValue=t;let i;if(d(t))i=ge(t,r.props.value)>-1;else if(p(t))i=t.has(r.props.value);else{if(t===n)return;i=he(t,Gl(e,!0))}e.checked!==i&&(e.checked=i)}var Vl={created(e,{value:t},n){e.checked=he(t,n.props.value),e[Fl]=Ml(n),$c(e,`change`,()=>{e[Fl](Wl(e))})},beforeUpdate(e,{value:t,oldValue:n},r){e[Fl]=Ml(r),t!==n&&(e.checked=he(t,r.props.value))}},Hl={deep:!0,created(e,{value:t,modifiers:{number:n}},r){e._modelValue=t,$c(e,`change`,()=>{let t=Array.prototype.filter.call(e.options,e=>e.selected).map(e=>n?re(Wl(e)):Wl(e));e[Fl](e.multiple?p(e._modelValue)?new Set(t):t:t[0]),e._assigning=!0,Vn(()=>{e._assigning=!1})}),e[Fl]=Ml(r)},mounted(e,{value:t}){Ul(e,t)},beforeUpdate(e,{value:t},n){e._modelValue=t,e[Fl]=Ml(n)},updated(e,{value:t}){e._assigning||Ul(e,t)}};function Ul(e,t){let n=e.multiple,r=d(t);if(!(n&&!r&&!p(t))){for(let i=0,a=e.options.length;i<a;i++){let a=e.options[i],o=Wl(a);if(n){if(r){let e=typeof o;a.selected=e===`string`||e===`number`?t.some(e=>String(e)===String(o)):ge(t,o)>-1}else a.selected=t.has(o)}else if(he(Wl(a),t)){e.selectedIndex!==i&&(e.selectedIndex=i);return}}!n&&e.selectedIndex!==-1&&(e.selectedIndex=-1)}}function Wl(e){return`_value`in e?e._value:e.value}function Gl(e,t){let n=t?`_trueValue`:`_falseValue`;return n in e?e[n]:t}var Kl={created(e,t,n){Jl(e,t,n,null,`created`)},mounted(e,t,n){Jl(e,t,n,null,`mounted`)},beforeUpdate(e,t,n,r){Jl(e,t,n,r,`beforeUpdate`)},updated(e,t,n,r){Jl(e,t,n,r,`updated`)}};function ql(e,t){switch(e){case`SELECT`:return Hl;case`TEXTAREA`:return Rl;default:switch(t){case`checkbox`:return zl;case`radio`:return Vl;default:return Rl}}}function Jl(e,t,n,r,i){let a=ql(e.tagName,n.props&&n.props.type)[i];a&&a(e,t,n,r)}function Yl(){Rl.getSSRProps=({value:e})=>({value:e}),Vl.getSSRProps=({value:e},t)=>{if(t.props&&he(t.props.value,e))return{checked:!0}},zl.getSSRProps=({value:e},t)=>{if(d(e)){if(t.props&&ge(e,t.props.value)>-1)return{checked:!0}}else if(p(e)){if(t.props&&e.has(t.props.value))return{checked:!0}}else if(e)return{checked:!0}},Kl.getSSRProps=(e,t)=>{if(typeof t.type!=`string`)return;let n=ql(t.type.toUpperCase(),t.props&&t.props.type);if(n.getSSRProps)return n.getSSRProps(e,t)}}var Xl=[`ctrl`,`shift`,`alt`,`meta`],Zl={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)=>Xl.some(n=>e[`${n}Key`]&&!t.includes(n))},Ql=(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=Zl[t[e]];if(r&&r(n,t))return}return e(n,...r)}))},$l={esc:`escape`,space:` `,up:`arrow-up`,left:`arrow-left`,right:`arrow-right`,down:`arrow-down`,delete:`backspace`},eu=(e,t)=>{let n=e._withKeys||={},r=t.join(`.`);return n[r]||(n[r]=(n=>{if(!(`key`in n))return;let r=k(n.key);if(t.some(e=>e===r||$l[e]===r))return e(n)}))},tu=s({patchProp:dl},dc),nu,ru=!1;function iu(){return nu||=Do(tu)}function au(){return nu=ru?nu:Oo(tu),ru=!0,nu}var ou=((...e)=>{iu().render(...e)}),su=((...e)=>{au().hydrate(...e)}),cu=((...e)=>{let t=iu().createApp(...e),{mount:n}=t;return t.mount=e=>{let r=du(e);if(!r)return;let i=t._component;!g(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent=``);let a=n(r,!1,uu(r));return r instanceof Element&&(r.removeAttribute(`v-cloak`),r.setAttribute(`data-v-app`,``)),a},t}),lu=((...e)=>{let t=au().createApp(...e),{mount:n}=t;return t.mount=e=>{let t=du(e);if(t)return n(t,!0,uu(t))},t});function uu(e){if(e instanceof SVGElement)return`svg`;if(typeof MathMLElement==`function`&&e instanceof MathMLElement)return`mathml`}function du(e){return _(e)?document.querySelector(e):e}var fu=!1,pu=()=>{fu||(fu=!0,Yl(),Lc())},mu=typeof window<`u`,hu,gu=e=>hu=e,_u=Symbol();function vu(e){return e&&typeof e==`object`&&Object.prototype.toString.call(e)===`[object Object]`&&typeof e.toJSON!=`function`}var yu=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 bu(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 xu(e,t,n){let r=new XMLHttpRequest;r.open(`GET`,e),r.responseType=`blob`,r.onload=function(){Eu(r.response,t,n)},r.onerror=function(){console.error(`could not download file`)},r.send()}function Su(e){let t=new XMLHttpRequest;t.open(`HEAD`,e,!1);try{t.send()}catch{}return t.status>=200&&t.status<=299}function Cu(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 wu=typeof navigator==`object`?navigator:{userAgent:``},Tu=/Macintosh/.test(wu.userAgent)&&/AppleWebKit/.test(wu.userAgent)&&!/Safari/.test(wu.userAgent),Eu=mu?typeof HTMLAnchorElement<`u`&&`download`in HTMLAnchorElement.prototype&&!Tu?Du:`msSaveOrOpenBlob`in wu?Ou:ku:()=>{};function Du(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?Cu(r):Su(r.href)?xu(e,t,n):(r.target=`_blank`,Cu(r))):(r.href=URL.createObjectURL(e),setTimeout(function(){URL.revokeObjectURL(r.href)},4e4),setTimeout(function(){Cu(r)},0))}function Ou(e,t=`download`,n){if(typeof e==`string`){if(Su(e))xu(e,t,n);else{let t=document.createElement(`a`);t.href=e,t.target=`_blank`,setTimeout(function(){Cu(t)})}}else navigator.msSaveOrOpenBlob(bu(e,n),t)}function ku(e,t,n,r){if(r||=open(``,`_blank`),r&&(r.document.title=r.document.body.innerText=`downloading...`),typeof e==`string`)return xu(e,t,n);let i=e.type===`application/octet-stream`,a=/constructor/i.test(String(yu.HTMLElement))||`safari`in yu,o=/CriOS\/[\d]+/.test(navigator.userAgent);if((o||i&&a||Tu)&&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:Au}=Object;function ju(){let e=Ce(!0),t=e.run(()=>Xt({})),n=[],r=[],i=qt({install(e){gu(i),i._a=e,e.provide(_u,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 Mu=()=>{};function Nu(e,t,n,r=Mu){e.add(t);let i=()=>{e.delete(t)&&r()};return!n&&we()&&Te(i),i}function Pu(e,...t){e.forEach(e=>{e(...t)})}var Fu=e=>e(),Iu=Symbol(),Lu=Symbol();function Ru(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]=vu(i)&&vu(r)&&Object.hasOwn(e,n)&&!H(r)&&!Ut(r)?Ru(i,r):r}return e}var zu=Symbol();function Bu(e){return!e||typeof e!=`object`||!Object.hasOwn(e,zu)}var{assign:Vu}=Object;function Hu(e){return!!(H(e)&&e.effect)}function Uu(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():{}),Vu(cn(n.state.value[e]),a,Object.keys(o||{}).reduce((t,r)=>(t[r]=qt(qs(()=>{gu(n);let t=n._s.get(e);return o[r].call(t,t)})),t),{}))}return c=Wu(e,l,t,n,r,!0),c}function Wu(e,t,n={},r,i,a){let o,s=Vu({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}):(Ru(r.state.value[e],t),n={type:`patch object`,payload:t,storeId:e,events:p});let i=h=Symbol();Vn().then(()=>{h===i&&(l=!0)}),u=!0,Pu(d,n,r.state.value[e])}let _=a?function(){let{state:e}=n,t=e?e():{};this.$patch(e=>{Vu(e,t)})}:Mu;function v(){o.stop(),d.clear(),f.clear(),r._s.delete(e)}let y=(t,n=``)=>{if(Iu in t)return t[Lu]=n,t;let i=function(){gu(r);let n=Array.from(arguments),a=new Set,o=new Set;function s(e){a.add(e)}function c(e){o.add(e)}Pu(f,{args:n,name:i[Lu],store:b,after:s,onError:c});let l;try{l=t.apply(this&&this.$id===e?this:b,n)}catch(e){throw Pu(o,e),e}return l instanceof Promise?l.then(e=>(Pu(a,e),e)).catch(e=>(Pu(o,e),Promise.reject(e))):(Pu(a,l),l)};return i[Iu]=!0,i[Lu]=n,i},b=Rt({_p:r,$id:e,$onAction:Nu.bind(null,f),$patch:g,$reset:_,$subscribe(t,n={}){if(d.has(t))return Mu;let i=Nu(d,t,n.detached,()=>a()),a=o.run(()=>hr(()=>r.state.value[e],r=>{(n.flush===`sync`?u:l)&&t({storeId:e,type:`direct`,events:p},r)},Vu({},c,n)));return i},$dispose:v});r._s.set(e,b);let x=(r._a&&r._a.runWithContext||Fu)(()=>r._e.run(()=>(o=Ce()).run(()=>t({action:y}))));for(let t in x){let n=x[t];H(n)&&!Hu(n)||Ut(n)?a||(m&&Bu(n)&&(H(n)?n.value=m[t]:((n instanceof Set||n instanceof Map)&&n.clear(),Ru(n,m[t]))),r.state.value[e][t]=n):typeof n==`function`&&(x[t]=y(n,t),s.actions[t]=n)}return Vu(b,x),Vu(V(b),x),Object.defineProperty(b,"$state",{get:()=>r.state.value[e],set:e=>{g(t=>{Vu(t,e)})}}),r._p.forEach(e=>{let t=o.run(()=>e({store:b,app:r._a,pinia:r,options:s}));Vu(b,t)}),m&&a&&n.hydrate&&n.hydrate(b.$state,m),l=!0,u=!0,b}function Gu(e,t,n){let r,i=typeof t==`function`;r=i?n:t;function a(n,a){let o=lr();return n||=o?cr(_u,null):null,n&&gu(n),n=hu,n._s.has(e)||(i?Wu(e,t,r,n):Uu(e,r,n)),n._s.get(e)}return a.$id=e,a}function Ku(e){let t=V(e),n={};for(let r in t){let i=t[r];i?.effect?n[r]=qs({get:()=>e[r],set(t){e[r]=t}}):(H(i)||Ut(i))&&(n[r]=dn(e,r))}return n}var qu={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`]},Ju={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`]},Yu={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`]},Xu={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`]},Zu={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`]},Qu={prefix:`fas`,iconName:`chevron-right`,icon:[320,512,[9002],`f054`,`M311.1 233.4c12.5 12.5 12.5 32.8 0 45.3l-192 192c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3L243.2 256 73.9 86.6c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0l192 192z`]},$u={prefix:`fas`,iconName:`users`,icon:[640,512,[],`f0c0`,`M320 16a104 104 0 1 1 0 208 104 104 0 1 1 0-208zM96 88a72 72 0 1 1 0 144 72 72 0 1 1 0-144zM0 416c0-70.7 57.3-128 128-128 12.8 0 25.2 1.9 36.9 5.4-32.9 36.8-52.9 85.4-52.9 138.6l0 16c0 11.4 2.4 22.2 6.7 32L32 480c-17.7 0-32-14.3-32-32l0-32zm521.3 64c4.3-9.8 6.7-20.6 6.7-32l0-16c0-53.2-20-101.8-52.9-138.6 11.7-3.5 24.1-5.4 36.9-5.4 70.7 0 128 57.3 128 128l0 32c0 17.7-14.3 32-32 32l-86.7 0zM472 160a72 72 0 1 1 144 0 72 72 0 1 1 -144 0zM160 432c0-88.4 71.6-160 160-160s160 71.6 160 160l0 16c0 17.7-14.3 32-32 32l-256 0c-17.7 0-32-14.3-32-32l0-16z`]},ed={prefix:`fas`,iconName:`heart-pulse`,icon:[512,512,[`heartbeat`],`f21e`,`M256 107.9L241 87.1C216 52.5 175.9 32 133.1 32 59.6 32 0 91.6 0 165.1l0 2.6c0 23.6 6.2 48 16.6 72.3l106 0c3.2 0 6.1-1.9 7.4-4.9l31.8-76.3c3.7-8.8 12.3-14.6 21.8-14.8s18.3 5.4 22.2 14.1l51.3 113.9 41.4-82.8c4.1-8.1 12.4-13.3 21.5-13.3s17.4 5.1 21.5 13.3l23.2 46.3c1.4 2.7 4.1 4.4 7.2 4.4l123.6 0c10.5-24.3 16.6-48.7 16.6-72.3l0-2.6C512 91.6 452.4 32 378.9 32 336.2 32 296 52.5 271 87.1l-15 20.7zM469.6 288l-97.8 0c-21.2 0-40.6-12-50.1-31l-1.7-3.4-42.5 85.1c-4.1 8.3-12.7 13.5-22 13.3s-17.6-5.7-21.4-14.1l-49.3-109.5-10.5 25.2c-8.7 20.9-29.1 34.5-51.7 34.5l-80.2 0c47.2 73.8 123 141.7 170.4 177.9 12.4 9.4 27.6 14.1 43.1 14.1s30.8-4.6 43.1-14.1C346.6 429.7 422.4 361.8 469.6 288z`]},td={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`]},nd={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`]},rd={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`]},id={prefix:`fas`,iconName:`house`,icon:[512,512,[127968,63498,63500,`home`,`home-alt`,`home-lg-alt`],`f015`,`M277.8 8.6c-12.3-11.4-31.3-11.4-43.5 0l-224 208c-9.6 9-12.8 22.9-8 35.1S18.8 272 32 272l16 0 0 176c0 35.3 28.7 64 64 64l288 0c35.3 0 64-28.7 64-64l0-176 16 0c13.2 0 25-8.1 29.8-20.3s1.6-26.2-8-35.1l-224-208zM240 320l32 0c26.5 0 48 21.5 48 48l0 96-128 0 0-96c0-26.5 21.5-48 48-48z`]},ad={prefix:`fas`,iconName:`sliders`,icon:[512,512,[`sliders-h`],`f1de`,`M32 64C14.3 64 0 78.3 0 96s14.3 32 32 32l86.7 0c12.3 28.3 40.5 48 73.3 48s61-19.7 73.3-48L480 128c17.7 0 32-14.3 32-32s-14.3-32-32-32L265.3 64C253 35.7 224.8 16 192 16s-61 19.7-73.3 48L32 64zm0 160c-17.7 0-32 14.3-32 32s14.3 32 32 32l246.7 0c12.3 28.3 40.5 48 73.3 48s61-19.7 73.3-48l54.7 0c17.7 0 32-14.3 32-32s-14.3-32-32-32l-54.7 0c-12.3-28.3-40.5-48-73.3-48s-61 19.7-73.3 48L32 224zm0 160c-17.7 0-32 14.3-32 32s14.3 32 32 32l54.7 0c12.3 28.3 40.5 48 73.3 48s61-19.7 73.3-48L480 448c17.7 0 32-14.3 32-32s-14.3-32-32-32l-246.7 0c-12.3-28.3-40.5-48-73.3-48s-61 19.7-73.3 48L32 384z`]},od={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`]},sd={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`]},cd={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`]},ld={prefix:`fas`,iconName:`cubes`,icon:[512,512,[],`f1b3`,`M284-1.3c-17.3-10-38.7-10-56 0L143.8 47.3c-17.3 10-28 28.5-28 48.5l0 101.9-88.3 51c-17.3 10-28 28.5-28 48.5l0 97.3c0 20 10.7 38.5 28 48.5l84.3 48.6c17.3 10 38.7 10 56 0l88.3-51 88.3 51c17.3 10 38.7 10 56 0L484.5 443c17.3-10 28-28.5 28-48.5l0-97.3c0-20-10.7-38.5-28-48.5l-88.3-51 0-101.9c0-20-10.7-38.5-28-48.5L284-1.3zM232 292.6l0 106.5-88.3 51c-1.2 .7-2.6 1.1-4 1.1l0-105.3 92.3-53.3zm231.4 .6c.7 1.2 1.1 2.6 1.1 4l0 97.3c0 2.9-1.5 5.5-4 6.9l-84.3 48.6c-1.2 .7-2.6 1.1-4 1.1l0-105.3 91.2-52.6zM348.3 95.8l0 101.9-92.3 53.3 0-106.5 91.2-52.6c.7 1.2 1.1 2.6 1.1 4z`]},ud={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`]},dd={prefix:`fas`,iconName:`plug`,icon:[448,512,[128268],`f1e6`,`M128-32c17.7 0 32 14.3 32 32l0 96 128 0 0-96c0-17.7 14.3-32 32-32s32 14.3 32 32l0 96 64 0c17.7 0 32 14.3 32 32s-14.3 32-32 32l0 64c0 95.1-69.2 174.1-160 189.3l0 66.7c0 17.7-14.3 32-32 32s-32-14.3-32-32l0-66.7C101.2 398.1 32 319.1 32 224l0-64c-17.7 0-32-14.3-32-32S14.3 96 32 96l64 0 0-96c0-17.7 14.3-32 32-32z`]},fd={prefix:`fas`,iconName:`inbox`,icon:[512,512,[],`f01c`,`M91.8 32C59.9 32 32.9 55.4 28.4 86.9L.6 281.2c-.4 3-.6 6-.6 9.1L0 416c0 35.3 28.7 64 64 64l384 0c35.3 0 64-28.7 64-64l0-125.7c0-3-.2-6.1-.6-9.1L483.6 86.9C479.1 55.4 452.1 32 420.2 32L91.8 32zm0 64l328.5 0 27.4 192-59.9 0c-12.1 0-23.2 6.8-28.6 17.7l-14.3 28.6c-5.4 10.8-16.5 17.7-28.6 17.7l-120.4 0c-12.1 0-23.2-6.8-28.6-17.7l-14.3-28.6c-5.4-10.8-16.5-17.7-28.6-17.7L64.3 288 91.8 96z`]},pd={prefix:`fas`,iconName:`file-csv`,icon:[576,512,[],`f6dd`,`M96 0C60.7 0 32 28.7 32 64l0 384c0 35.3 28.7 64 64 64l80 0 0-112c0-35.3 28.7-64 64-64l176 0 0-165.5c0-17-6.7-33.3-18.7-45.3L290.7 18.7C278.7 6.7 262.5 0 245.5 0L96 0zM357.5 176L264 176c-13.3 0-24-10.7-24-24L240 58.5 357.5 176zM264 380c-24.3 0-44 19.7-44 44l0 80c0 24.3 19.7 44 44 44l16 0c24.3 0 44-19.7 44-44l0-8c0-11-9-20-20-20s-20 9-20 20l0 8c0 2.2-1.8 4-4 4l-16 0c-2.2 0-4-1.8-4-4l0-80c0-2.2 1.8-4 4-4l16 0c2.2 0 4 1.8 4 4l0 8c0 11 9 20 20 20s20-9 20-20l0-8c0-24.3-19.7-44-44-44l-16 0zm136 0c-28.7 0-52 23.3-52 52s23.3 52 52 52c6.6 0 12 5.4 12 12s-5.4 12-12 12l-32 0c-11 0-20 9-20 20s9 20 20 20l32 0c28.7 0 52-23.3 52-52s-23.3-52-52-52c-6.6 0-12-5.4-12-12s5.4-12 12-12l24 0c11 0 20-9 20-20s-9-20-20-20l-24 0zm96 0c-11 0-20 9-20 20l0 31.6c0 35.5 10.5 70.3 30.2 99.8l5.1 7.7c3.7 5.6 10 8.9 16.6 8.9s12.9-3.3 16.6-8.9l5.1-7.7c19.7-29.6 30.2-64.3 30.2-99.8l0-31.6c0-11-9-20-20-20s-20 9-20 20l0 31.6c0 19.6-4.1 38.9-12 56.7-7.9-17.8-12-37.1-12-56.7l0-31.6c0-11-9-20-20-20z`]},md={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`]},hd={prefix:`fas`,iconName:`arrow-right-arrow-left`,icon:[512,512,[8644,`exchange`],`f0ec`,`M502.6 150.6l-96 96c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3L402.7 160 32 160c-17.7 0-32-14.3-32-32S14.3 96 32 96l370.7 0-41.4-41.4c-12.5-12.5-12.5-32.8 0-45.3s32.8-12.5 45.3 0l96 96c12.5 12.5 12.5 32.8 0 45.3zm-397.3 352l-96-96c-12.5-12.5-12.5-32.8 0-45.3l96-96c12.5-12.5 32.8-12.5 45.3 0s12.5 32.8 0 45.3L109.3 352 480 352c17.7 0 32 14.3 32 32s-14.3 32-32 32l-370.7 0 41.4 41.4c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0z`]},gd={prefix:`fas`,iconName:`arrow-left`,icon:[512,512,[8592],`f060`,`M9.4 233.4c-12.5 12.5-12.5 32.8 0 45.3l160 160c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L109.3 288 480 288c17.7 0 32-14.3 32-32s-14.3-32-32-32l-370.7 0 105.4-105.4c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0l-160 160z`]},_d={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`]},vd={prefix:`fas`,iconName:`arrow-rotate-right`,icon:[512,512,[8635,`arrow-right-rotate`,`arrow-rotate-forward`,`redo`],`f01e`,`M436.7 74.7L448 85.4 448 32c0-17.7 14.3-32 32-32s32 14.3 32 32l0 128c0 17.7-14.3 32-32 32l-128 0c-17.7 0-32-14.3-32-32s14.3-32 32-32l47.9 0-7.6-7.2c-.2-.2-.4-.4-.6-.6-75-75-196.5-75-271.5 0s-75 196.5 0 271.5 196.5 75 271.5 0c8.2-8.2 15.5-16.9 21.9-26.1 10.1-14.5 30.1-18 44.6-7.9s18 30.1 7.9 44.6c-8.5 12.2-18.2 23.8-29.1 34.7-100 100-262.1 100-362 0S-25 175 75 75c99.9-99.9 261.7-100 361.7-.3z`]},yd={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`]},bd={prefix:`fas`,iconName:`arrow-up-right-from-square`,icon:[512,512,[`external-link`],`f08e`,`M320 0c-17.7 0-32 14.3-32 32s14.3 32 32 32l82.7 0-201.4 201.4c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0L448 109.3 448 192c0 17.7 14.3 32 32 32s32-14.3 32-32l0-160c0-17.7-14.3-32-32-32L320 0zM80 96C35.8 96 0 131.8 0 176L0 432c0 44.2 35.8 80 80 80l256 0c44.2 0 80-35.8 80-80l0-80c0-17.7-14.3-32-32-32s-32 14.3-32 32l0 80c0 8.8-7.2 16-16 16L80 448c-8.8 0-16-7.2-16-16l0-256c0-8.8 7.2-16 16-16l80 0c17.7 0 32-14.3 32-32s-14.3-32-32-32L80 96z`]},xd={prefix:`fas`,iconName:`coins`,icon:[512,512,[],`f51e`,`M128 96l0-16c0-44.2 86-80 192-80S512 35.8 512 80l0 16c0 30.6-41.3 57.2-102 70.7-2.4-2.8-4.9-5.5-7.4-8-15.5-15.3-35.5-26.9-56.4-35.5-41.9-17.5-96.5-27.1-154.2-27.1-21.9 0-43.3 1.4-63.8 4.1-.2-1.3-.2-2.7-.2-4.1zM432 353l0-46.2c15.1-3.9 29.3-8.5 42.2-13.9 13.2-5.5 26.1-12.2 37.8-20.3l0 15.4c0 26.8-31.5 50.5-80 65zm0-96l0-33c0-4.5-.4-8.8-1-13 15.5-3.9 30-8.6 43.2-14.2s26.1-12.2 37.8-20.3l0 15.4c0 26.8-31.5 50.5-80 65zM0 240l0-16c0-44.2 86-80 192-80s192 35.8 192 80l0 16c0 44.2-86 80-192 80S0 284.2 0 240zm384 96c0 44.2-86 80-192 80S0 380.2 0 336l0-15.4c11.6 8.1 24.5 14.7 37.8 20.3 41.9 17.5 96.5 27.1 154.2 27.1s112.3-9.7 154.2-27.1c13.2-5.5 26.1-12.2 37.8-20.3l0 15.4zm0 80.6l0 15.4c0 44.2-86 80-192 80S0 476.2 0 432l0-15.4c11.6 8.1 24.5 14.7 37.8 20.3 41.9 17.5 96.5 27.1 154.2 27.1s112.3-9.7 154.2-27.1c13.2-5.5 26.1-12.2 37.8-20.3z`]},Sd={prefix:`fas`,iconName:`circle-info`,icon:[512,512,[`info-circle`],`f05a`,`M256 512a256 256 0 1 0 0-512 256 256 0 1 0 0 512zM224 160a32 32 0 1 1 64 0 32 32 0 1 1 -64 0zm-8 64l48 0c13.3 0 24 10.7 24 24l0 88 8 0c13.3 0 24 10.7 24 24s-10.7 24-24 24l-80 0c-13.3 0-24-10.7-24-24s10.7-24 24-24l24 0 0-64-24 0c-13.3 0-24-10.7-24-24s10.7-24 24-24z`]},Cd={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 wd(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=wd(e[t]))&&(r&&(r+=` `),r+=n)}else for(n in e)e[n]&&(r&&(r+=` `),r+=n)}return r}function Td(){for(var e,t,n=0,r=``,i=arguments.length;n<i;n++)(e=arguments[n])&&(t=wd(e))&&(r&&(r+=` `),r+=t);return r}var Ed=e=>typeof e==`boolean`?`${e}`:e===0?`0`:e,Dd=Td,Od=(e,t)=>n=>{if(t?.variants==null)return Dd(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=Ed(t)||Ed(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 Dd(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)},kd=(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},Ad=(e,t)=>({classGroupId:e,validator:t}),jd=(e=new Map,t=null,n)=>({nextPart:e,validators:t,classGroupId:n}),Md=`-`,Nd=[],Pd=`arbitrary..`,Fd=e=>{let t=Rd(e),{conflictingClassGroups:n,conflictingClassGroupModifiers:r}=e;return{getClassGroupId:e=>{if(e.startsWith(`[`)&&e.endsWith(`]`))return Ld(e);let n=e.split(Md);return Id(n,+(n[0]===``&&n.length>1),t)},getConflictingClassGroupIds:(e,t)=>{if(t){let t=r[e],i=n[e];return t?i?kd(i,t):t:i||Nd}return n[e]||Nd}}},Id=(e,t,n)=>{if(e.length-t===0)return n.classGroupId;let r=e[t],i=n.nextPart.get(r);if(i){let n=Id(e,t+1,i);if(n)return n}let a=n.validators;if(a===null)return;let o=t===0?e.join(Md):e.slice(t).join(Md),s=a.length;for(let e=0;e<s;e++){let t=a[e];if(t.validator(o))return t.classGroupId}},Ld=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?Pd+r:void 0})(),Rd=e=>{let{theme:t,classGroups:n}=e;return zd(n,t)},zd=(e,t)=>{let n=jd();for(let r in e){let i=e[r];Bd(i,n,r,t)}return n},Bd=(e,t,n,r)=>{let i=e.length;for(let a=0;a<i;a++){let i=e[a];Vd(i,t,n,r)}},Vd=(e,t,n,r)=>{if(typeof e==`string`){Hd(e,t,n);return}if(typeof e==`function`){Ud(e,t,n,r);return}Wd(e,t,n,r)},Hd=(e,t,n)=>{let r=e===``?t:Gd(t,e);r.classGroupId=n},Ud=(e,t,n,r)=>{if(Kd(e)){Bd(e(r),t,n,r);return}t.validators===null&&(t.validators=[]),t.validators.push(Ad(n,e))},Wd=(e,t,n,r)=>{let i=Object.entries(e),a=i.length;for(let e=0;e<a;e++){let[a,o]=i[e];Bd(o,Gd(t,a),n,r)}},Gd=(e,t)=>{let n=e,r=t.split(Md),i=r.length;for(let e=0;e<i;e++){let t=r[e],i=n.nextPart.get(t);i||(i=jd(),n.nextPart.set(t,i)),n=i}return n},Kd=e=>`isThemeGetter`in e&&e.isThemeGetter===!0,qd=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)}}},Jd=`!`,Yd=`:`,Xd=[],Zd=(e,t,n,r,i)=>({modifiers:e,hasImportantModifier:t,baseClassName:n,maybePostfixModifierPosition:r,isExternal:i}),Qd=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===Yd){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(Jd)?(c=s.slice(0,-1),l=!0):s.startsWith(Jd)&&(c=s.slice(1),l=!0);let u=a&&a>i?a-i:void 0;return Zd(t,l,c,u)};if(t){let e=t+Yd,n=r;r=t=>t.startsWith(e)?n(t.slice(e.length)):Zd(Xd,!1,t,void 0,!0)}if(n){let e=r;r=t=>n({className:t,parseClassName:e})}return r},$d=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}},ef=e=>({cache:qd(e.cacheSize),parseClassName:Qd(e),sortModifiers:$d(e),postfixLookupClassGroupIds:tf(e),...Fd(e)}),tf=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},nf=/\s+/,rf=(e,t)=>{let{parseClassName:n,getClassGroupId:r,getConflictingClassGroupIds:i,sortModifiers:a,postfixLookupClassGroupIds:o}=t,s=[],c=e.trim().split(nf),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?_+Jd:_,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},af=(...e)=>{let t=0,n,r,i=``;for(;t<e.length;)(n=e[t++])&&(r=of(n))&&(i&&(i+=` `),i+=r);return i},of=e=>{if(typeof e==`string`)return e;let t,n=``;for(let r=0;r<e.length;r++)e[r]&&(t=of(e[r]))&&(n&&(n+=` `),n+=t);return n},sf=(e,...t)=>{let n,r,i,a,o=o=>(n=ef(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=rf(e,n);return i(e,a),a};return a=o,(...e)=>a(af(...e))},cf=[],X=e=>{let t=t=>t[e]||cf;return t.isThemeGetter=!0,t},lf=/^\[(?:(\w[\w-]*):)?(.+)\]$/i,uf=/^\((?:(\w[\w-]*):)?(.+)\)$/i,df=/^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/,ff=/^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/,pf=/\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$/,mf=/^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/,hf=/^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/,gf=/^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/,_f=e=>df.test(e),Z=e=>!!e&&!Number.isNaN(Number(e)),vf=e=>!!e&&Number.isInteger(Number(e)),yf=e=>e.endsWith(`%`)&&Z(e.slice(0,-1)),bf=e=>ff.test(e),xf=()=>!0,Sf=e=>pf.test(e)&&!mf.test(e),Cf=()=>!1,wf=e=>hf.test(e),Tf=e=>gf.test(e),Ef=e=>!Q(e)&&!$(e),Df=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)),Of=e=>Uf(e,qf,Cf),Q=e=>lf.test(e),kf=e=>Uf(e,Jf,Sf),Af=e=>Uf(e,Yf,Z),jf=e=>Uf(e,Zf,xf),Mf=e=>Uf(e,Xf,Cf),Nf=e=>Uf(e,Gf,Cf),Pf=e=>Uf(e,Kf,Tf),Ff=e=>Uf(e,Qf,wf),$=e=>uf.test(e),If=e=>Wf(e,Jf),Lf=e=>Wf(e,Xf),Rf=e=>Wf(e,Gf),zf=e=>Wf(e,qf),Bf=e=>Wf(e,Kf),Vf=e=>Wf(e,Qf,!0),Hf=e=>Wf(e,Zf,!0),Uf=(e,t,n)=>{let r=lf.exec(e);return r?r[1]?t(r[1]):n(r[2]):!1},Wf=(e,t,n=!1)=>{let r=uf.exec(e);return r?r[1]?t(r[1]):n:!1},Gf=e=>e===`position`||e===`percentage`,Kf=e=>e===`image`||e===`url`,qf=e=>e===`length`||e===`size`||e===`bg-size`,Jf=e=>e===`length`,Yf=e=>e===`number`,Xf=e=>e===`family-name`,Zf=e=>e===`number`||e===`weight`,Qf=e=>e===`shadow`,$f=sf(()=>{let e=X(`color`),t=X(`font`),n=X(`text`),r=X(`font-weight`),i=X(`tracking`),a=X(`leading`),o=X(`breakpoint`),s=X(`container`),c=X(`spacing`),l=X(`radius`),u=X(`shadow`),d=X(`inset-shadow`),f=X(`text-shadow`),p=X(`drop-shadow`),m=X(`blur`),h=X(`perspective`),g=X(`aspect`),_=X(`ease`),v=X(`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(),$,Q],S=()=>[`auto`,`hidden`,`clip`,`visible`,`scroll`],C=()=>[`auto`,`contain`,`none`],w=()=>[$,Q,c],T=()=>[_f,`full`,`auto`,...w()],E=()=>[vf,`none`,`subgrid`,$,Q],D=()=>[`auto`,{span:[`full`,vf,$,Q]},vf,$,Q],ee=()=>[vf,`auto`,$,Q],O=()=>[`auto`,`min`,`max`,`fr`,$,Q],te=()=>[`start`,`end`,`center`,`between`,`around`,`evenly`,`stretch`,`baseline`,`center-safe`,`end-safe`],k=()=>[`start`,`end`,`center`,`stretch`,`center-safe`,`end-safe`],A=()=>[`auto`,...w()],ne=()=>[_f,`auto`,`full`,`dvw`,`dvh`,`lvw`,`lvh`,`svw`,`svh`,`min`,`max`,`fit`,...w()],j=()=>[_f,`screen`,`full`,`dvw`,`lvw`,`svw`,`min`,`max`,`fit`,...w()],M=()=>[_f,`screen`,`full`,`lh`,`dvh`,`lvh`,`svh`,`min`,`max`,`fit`,...w()],N=()=>[e,$,Q],re=()=>[...b(),Rf,Nf,{position:[$,Q]}],ie=()=>[`no-repeat`,{repeat:[``,`x`,`y`,`space`,`round`]}],ae=()=>[`auto`,`cover`,`contain`,zf,Of,{size:[$,Q]}],oe=()=>[yf,If,kf],P=()=>[``,`none`,`full`,l,$,Q],F=()=>[``,Z,If,kf],se=()=>[`solid`,`dashed`,`dotted`,`double`],ce=()=>[`normal`,`multiply`,`screen`,`overlay`,`darken`,`lighten`,`color-dodge`,`color-burn`,`hard-light`,`soft-light`,`difference`,`exclusion`,`hue`,`saturation`,`color`,`luminosity`],I=()=>[Z,yf,Rf,Nf],le=()=>[``,`none`,m,$,Q],L=()=>[`none`,Z,$,Q],ue=()=>[`none`,Z,$,Q],de=()=>[Z,$,Q],fe=()=>[_f,`full`,...w()];return{cacheSize:500,theme:{animate:[`spin`,`ping`,`pulse`,`bounce`],aspect:[`video`],blur:[bf],breakpoint:[bf],color:[xf],container:[bf],"drop-shadow":[bf],ease:[`in`,`out`,`in-out`],font:[Ef],"font-weight":[`thin`,`extralight`,`light`,`normal`,`medium`,`semibold`,`bold`,`extrabold`,`black`],"inset-shadow":[bf],leading:[`none`,`tight`,`snug`,`normal`,`relaxed`,`loose`],perspective:[`dramatic`,`near`,`normal`,`midrange`,`distant`,`none`],radius:[bf],shadow:[bf],spacing:[`px`,Z],text:[bf],"text-shadow":[bf],tracking:[`tighter`,`tight`,`normal`,`wide`,`wider`,`widest`]},classGroups:{aspect:[{aspect:[`auto`,`square`,_f,Q,$,g]}],container:[`container`],"container-type":[{"@container":[``,`normal`,`size`,$,Q]}],"container-named":[Df],columns:[{columns:[Z,Q,$,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:T()}],"inset-x":[{"inset-x":T()}],"inset-y":[{"inset-y":T()}],start:[{"inset-s":T(),start:T()}],end:[{"inset-e":T(),end:T()}],"inset-bs":[{"inset-bs":T()}],"inset-be":[{"inset-be":T()}],top:[{top:T()}],right:[{right:T()}],bottom:[{bottom:T()}],left:[{left:T()}],visibility:[`visible`,`invisible`,`collapse`],z:[{z:[vf,`auto`,$,Q]}],basis:[{basis:[_f,`full`,`auto`,s,...w()]}],"flex-direction":[{flex:[`row`,`row-reverse`,`col`,`col-reverse`]}],"flex-wrap":[{flex:[`nowrap`,`wrap`,`wrap-reverse`]}],flex:[{flex:[Z,_f,`auto`,`initial`,`none`,Q]}],grow:[{grow:[``,Z,$,Q]}],shrink:[{shrink:[``,Z,$,Q]}],order:[{order:[vf,`first`,`last`,`none`,$,Q]}],"grid-cols":[{"grid-cols":E()}],"col-start-end":[{col:D()}],"col-start":[{"col-start":ee()}],"col-end":[{"col-end":ee()}],"grid-rows":[{"grid-rows":E()}],"row-start-end":[{row:D()}],"row-start":[{"row-start":ee()}],"row-end":[{"row-end":ee()}],"grid-flow":[{"grid-flow":[`row`,`col`,`dense`,`row-dense`,`col-dense`]}],"auto-cols":[{"auto-cols":O()}],"auto-rows":[{"auto-rows":O()}],gap:[{gap:w()}],"gap-x":[{"gap-x":w()}],"gap-y":[{"gap-y":w()}],"justify-content":[{justify:[...te(),`normal`]}],"justify-items":[{"justify-items":[...k(),`normal`]}],"justify-self":[{"justify-self":[`auto`,...k()]}],"align-content":[{content:[`normal`,...te()]}],"align-items":[{items:[...k(),{baseline:[``,`last`]}]}],"align-self":[{self:[`auto`,...k(),{baseline:[``,`last`]}]}],"place-content":[{"place-content":te()}],"place-items":[{"place-items":[...k(),`baseline`]}],"place-self":[{"place-self":[`auto`,...k()]}],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:A()}],mx:[{mx:A()}],my:[{my:A()}],ms:[{ms:A()}],me:[{me:A()}],mbs:[{mbs:A()}],mbe:[{mbe:A()}],mt:[{mt:A()}],mr:[{mr:A()}],mb:[{mb:A()}],ml:[{ml:A()}],"space-x":[{"space-x":w()}],"space-x-reverse":[`space-x-reverse`],"space-y":[{"space-y":w()}],"space-y-reverse":[`space-y-reverse`],size:[{size:ne()}],"inline-size":[{inline:[`auto`,...j()]}],"min-inline-size":[{"min-inline":[`auto`,...j()]}],"max-inline-size":[{"max-inline":[`none`,...j()]}],"block-size":[{block:[`auto`,...M()]}],"min-block-size":[{"min-block":[`auto`,...M()]}],"max-block-size":[{"max-block":[`none`,...M()]}],w:[{w:[s,`screen`,...ne()]}],"min-w":[{"min-w":[s,`screen`,`none`,...ne()]}],"max-w":[{"max-w":[s,`screen`,`none`,`prose`,{screen:[o]},...ne()]}],h:[{h:[`screen`,`lh`,...ne()]}],"min-h":[{"min-h":[`screen`,`lh`,`none`,...ne()]}],"max-h":[{"max-h":[`screen`,`lh`,...ne()]}],"font-size":[{text:[`base`,n,If,kf]}],"font-smoothing":[`antialiased`,`subpixel-antialiased`],"font-style":[`italic`,`not-italic`],"font-weight":[{font:[r,Hf,jf]}],"font-stretch":[{"font-stretch":[`ultra-condensed`,`extra-condensed`,`condensed`,`semi-condensed`,`normal`,`semi-expanded`,`expanded`,`extra-expanded`,`ultra-expanded`,yf,Q]}],"font-family":[{font:[Lf,Mf,t]}],"font-features":[{"font-features":[Q]}],"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,$,Q]}],"line-clamp":[{"line-clamp":[Z,`none`,$,Af]}],leading:[{leading:[a,...w()]}],"list-image":[{"list-image":[`none`,$,Q]}],"list-style-position":[{list:[`inside`,`outside`]}],"list-style-type":[{list:[`disc`,`decimal`,`none`,$,Q]}],"text-alignment":[{text:[`left`,`center`,`right`,`justify`,`start`,`end`]}],"placeholder-color":[{placeholder:N()}],"text-color":[{text:N()}],"text-decoration":[`underline`,`overline`,`line-through`,`no-underline`],"text-decoration-style":[{decoration:[...se(),`wavy`]}],"text-decoration-thickness":[{decoration:[Z,`from-font`,`auto`,$,kf]}],"text-decoration-color":[{decoration:N()}],"underline-offset":[{"underline-offset":[Z,`auto`,$,Q]}],"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:[vf,$,Q]}],"vertical-align":[{align:[`baseline`,`top`,`middle`,`bottom`,`text-top`,`text-bottom`,`sub`,`super`,$,Q]}],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`,$,Q]}],"bg-attachment":[{bg:[`fixed`,`local`,`scroll`]}],"bg-clip":[{"bg-clip":[`border`,`padding`,`content`,`text`]}],"bg-origin":[{"bg-origin":[`border`,`padding`,`content`]}],"bg-position":[{bg:re()}],"bg-repeat":[{bg:ie()}],"bg-size":[{bg:ae()}],"bg-image":[{bg:[`none`,{linear:[{to:[`t`,`tr`,`r`,`br`,`b`,`bl`,`l`,`tl`]},vf,$,Q],radial:[``,$,Q],conic:[vf,$,Q]},Bf,Pf]}],"bg-color":[{bg:N()}],"gradient-from-pos":[{from:oe()}],"gradient-via-pos":[{via:oe()}],"gradient-to-pos":[{to:oe()}],"gradient-from":[{from:N()}],"gradient-via":[{via:N()}],"gradient-to":[{to:N()}],rounded:[{rounded:P()}],"rounded-s":[{"rounded-s":P()}],"rounded-e":[{"rounded-e":P()}],"rounded-t":[{"rounded-t":P()}],"rounded-r":[{"rounded-r":P()}],"rounded-b":[{"rounded-b":P()}],"rounded-l":[{"rounded-l":P()}],"rounded-ss":[{"rounded-ss":P()}],"rounded-se":[{"rounded-se":P()}],"rounded-ee":[{"rounded-ee":P()}],"rounded-es":[{"rounded-es":P()}],"rounded-tl":[{"rounded-tl":P()}],"rounded-tr":[{"rounded-tr":P()}],"rounded-br":[{"rounded-br":P()}],"rounded-bl":[{"rounded-bl":P()}],"border-w":[{border:F()}],"border-w-x":[{"border-x":F()}],"border-w-y":[{"border-y":F()}],"border-w-s":[{"border-s":F()}],"border-w-e":[{"border-e":F()}],"border-w-bs":[{"border-bs":F()}],"border-w-be":[{"border-be":F()}],"border-w-t":[{"border-t":F()}],"border-w-r":[{"border-r":F()}],"border-w-b":[{"border-b":F()}],"border-w-l":[{"border-l":F()}],"divide-x":[{"divide-x":F()}],"divide-x-reverse":[`divide-x-reverse`],"divide-y":[{"divide-y":F()}],"divide-y-reverse":[`divide-y-reverse`],"border-style":[{border:[...se(),`hidden`,`none`]}],"divide-style":[{divide:[...se(),`hidden`,`none`]}],"border-color":[{border:N()}],"border-color-x":[{"border-x":N()}],"border-color-y":[{"border-y":N()}],"border-color-s":[{"border-s":N()}],"border-color-e":[{"border-e":N()}],"border-color-bs":[{"border-bs":N()}],"border-color-be":[{"border-be":N()}],"border-color-t":[{"border-t":N()}],"border-color-r":[{"border-r":N()}],"border-color-b":[{"border-b":N()}],"border-color-l":[{"border-l":N()}],"divide-color":[{divide:N()}],"outline-style":[{outline:[...se(),`none`,`hidden`]}],"outline-offset":[{"outline-offset":[Z,$,Q]}],"outline-w":[{outline:[``,Z,If,kf]}],"outline-color":[{outline:N()}],shadow:[{shadow:[``,`none`,u,Vf,Ff]}],"shadow-color":[{shadow:N()}],"inset-shadow":[{"inset-shadow":[`none`,d,Vf,Ff]}],"inset-shadow-color":[{"inset-shadow":N()}],"ring-w":[{ring:F()}],"ring-w-inset":[`ring-inset`],"ring-color":[{ring:N()}],"ring-offset-w":[{"ring-offset":[Z,kf]}],"ring-offset-color":[{"ring-offset":N()}],"inset-ring-w":[{"inset-ring":F()}],"inset-ring-color":[{"inset-ring":N()}],"text-shadow":[{"text-shadow":[`none`,f,Vf,Ff]}],"text-shadow-color":[{"text-shadow":N()}],opacity:[{opacity:[Z,$,Q]}],"mix-blend":[{"mix-blend":[...ce(),`plus-darker`,`plus-lighter`]}],"bg-blend":[{"bg-blend":ce()}],"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":[Z]}],"mask-image-linear-from-pos":[{"mask-linear-from":I()}],"mask-image-linear-to-pos":[{"mask-linear-to":I()}],"mask-image-linear-from-color":[{"mask-linear-from":N()}],"mask-image-linear-to-color":[{"mask-linear-to":N()}],"mask-image-t-from-pos":[{"mask-t-from":I()}],"mask-image-t-to-pos":[{"mask-t-to":I()}],"mask-image-t-from-color":[{"mask-t-from":N()}],"mask-image-t-to-color":[{"mask-t-to":N()}],"mask-image-r-from-pos":[{"mask-r-from":I()}],"mask-image-r-to-pos":[{"mask-r-to":I()}],"mask-image-r-from-color":[{"mask-r-from":N()}],"mask-image-r-to-color":[{"mask-r-to":N()}],"mask-image-b-from-pos":[{"mask-b-from":I()}],"mask-image-b-to-pos":[{"mask-b-to":I()}],"mask-image-b-from-color":[{"mask-b-from":N()}],"mask-image-b-to-color":[{"mask-b-to":N()}],"mask-image-l-from-pos":[{"mask-l-from":I()}],"mask-image-l-to-pos":[{"mask-l-to":I()}],"mask-image-l-from-color":[{"mask-l-from":N()}],"mask-image-l-to-color":[{"mask-l-to":N()}],"mask-image-x-from-pos":[{"mask-x-from":I()}],"mask-image-x-to-pos":[{"mask-x-to":I()}],"mask-image-x-from-color":[{"mask-x-from":N()}],"mask-image-x-to-color":[{"mask-x-to":N()}],"mask-image-y-from-pos":[{"mask-y-from":I()}],"mask-image-y-to-pos":[{"mask-y-to":I()}],"mask-image-y-from-color":[{"mask-y-from":N()}],"mask-image-y-to-color":[{"mask-y-to":N()}],"mask-image-radial":[{"mask-radial":[$,Q]}],"mask-image-radial-from-pos":[{"mask-radial-from":I()}],"mask-image-radial-to-pos":[{"mask-radial-to":I()}],"mask-image-radial-from-color":[{"mask-radial-from":N()}],"mask-image-radial-to-color":[{"mask-radial-to":N()}],"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":[Z]}],"mask-image-conic-from-pos":[{"mask-conic-from":I()}],"mask-image-conic-to-pos":[{"mask-conic-to":I()}],"mask-image-conic-from-color":[{"mask-conic-from":N()}],"mask-image-conic-to-color":[{"mask-conic-to":N()}],"mask-mode":[{mask:[`alpha`,`luminance`,`match`]}],"mask-origin":[{"mask-origin":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]}],"mask-position":[{mask:re()}],"mask-repeat":[{mask:ie()}],"mask-size":[{mask:ae()}],"mask-type":[{"mask-type":[`alpha`,`luminance`]}],"mask-image":[{mask:[`none`,$,Q]}],filter:[{filter:[``,`none`,$,Q]}],blur:[{blur:le()}],brightness:[{brightness:[Z,$,Q]}],contrast:[{contrast:[Z,$,Q]}],"drop-shadow":[{"drop-shadow":[``,`none`,p,Vf,Ff]}],"drop-shadow-color":[{"drop-shadow":N()}],grayscale:[{grayscale:[``,Z,$,Q]}],"hue-rotate":[{"hue-rotate":[Z,$,Q]}],invert:[{invert:[``,Z,$,Q]}],saturate:[{saturate:[Z,$,Q]}],sepia:[{sepia:[``,Z,$,Q]}],"backdrop-filter":[{"backdrop-filter":[``,`none`,$,Q]}],"backdrop-blur":[{"backdrop-blur":le()}],"backdrop-brightness":[{"backdrop-brightness":[Z,$,Q]}],"backdrop-contrast":[{"backdrop-contrast":[Z,$,Q]}],"backdrop-grayscale":[{"backdrop-grayscale":[``,Z,$,Q]}],"backdrop-hue-rotate":[{"backdrop-hue-rotate":[Z,$,Q]}],"backdrop-invert":[{"backdrop-invert":[``,Z,$,Q]}],"backdrop-opacity":[{"backdrop-opacity":[Z,$,Q]}],"backdrop-saturate":[{"backdrop-saturate":[Z,$,Q]}],"backdrop-sepia":[{"backdrop-sepia":[``,Z,$,Q]}],"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`,$,Q]}],"transition-behavior":[{transition:[`normal`,`discrete`]}],duration:[{duration:[Z,`initial`,$,Q]}],ease:[{ease:[`linear`,`initial`,_,$,Q]}],delay:[{delay:[Z,$,Q]}],animate:[{animate:[`none`,v,$,Q]}],backface:[{backface:[`hidden`,`visible`]}],perspective:[{perspective:[h,$,Q]}],"perspective-origin":[{"perspective-origin":x()}],rotate:[{rotate:L()}],"rotate-x":[{"rotate-x":L()}],"rotate-y":[{"rotate-y":L()}],"rotate-z":[{"rotate-z":L()}],scale:[{scale:ue()}],"scale-x":[{"scale-x":ue()}],"scale-y":[{"scale-y":ue()}],"scale-z":[{"scale-z":ue()}],"scale-3d":[`scale-3d`],skew:[{skew:de()}],"skew-x":[{"skew-x":de()}],"skew-y":[{"skew-y":de()}],transform:[{transform:[$,Q,``,`none`,`gpu`,`cpu`]}],"transform-origin":[{origin:x()}],"transform-style":[{transform:[`3d`,`flat`]}],translate:[{translate:fe()}],"translate-x":[{"translate-x":fe()}],"translate-y":[{"translate-y":fe()}],"translate-z":[{"translate-z":fe()}],"translate-none":[`translate-none`],zoom:[{zoom:[vf,$,Q]}],accent:[{accent:N()}],appearance:[{appearance:[`none`,`auto`]}],"caret-color":[{caret:N()}],"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`,$,Q]}],"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":N()}],"scrollbar-track-color":[{"scrollbar-track":N()}],"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`,$,Q]}],fill:[{fill:[`none`,...N()]}],"stroke-w":[{stroke:[Z,If,kf,Af]}],stroke:[{stroke:[`none`,...N()]}],"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 ep(...e){return $f(Td(e))}function tp(e,t){return we()?(Te(e,t),!0):!1}function np(e){let t=!1,n,r=Ce(!0);return((...i)=>(t||=(n=r.run(()=>e(...i)),!0),n))}var rp=typeof window<`u`&&typeof document<`u`;typeof WorkerGlobalScope<`u`&&globalThis instanceof WorkerGlobalScope;var ip=e=>e!==void 0,ap=Object.prototype.toString,op=e=>ap.call(e)===`[object Object]`,sp=cp();function cp(){var e,t;return rp&&!!((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 lp(e){return Array.isArray(e)?e:[e]}function up(e){return e||Y()}function dp(e){if(!rp)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=Ce(!0),n=r.run(()=>e(...a))),tp(i),n))}function fp(e){return Rt(H(e)?new Proxy({},{get(t,n,r){return tn(Reflect.get(e.value,n,r))},set(t,n,r){return H(e.value[n])&&!H(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 pp(e){return fp(qs(e))}function mp(e,...t){let n=t.flat(),r=n[0];return pp(()=>Object.fromEntries(typeof r==`function`?Object.entries(cn(e)).filter(([e,t])=>!r(nn(t),e)):Object.entries(cn(e)).filter(e=>!n.includes(e[0]))))}function hp(e,t=1e4){return sn((n,r)=>{let i=nn(e),a,o=()=>setTimeout(()=>{i=nn(e),r()},nn(t));return tp(()=>{clearTimeout(a)}),{get(){return n(),i},set(e){i=e,r(),clearTimeout(a),a=o()}}})}function gp(e,t){up(t)&&Wi(e,t)}function _p(e,t,n){return hr(e,t,{...n,immediate:!0})}var vp=rp?window:void 0;rp&&window.document,rp&&window.navigator,rp&&window.location;function yp(e){let t=nn(e);return t?.$el??t}function bp(...e){let t=(e,t,n,r)=>(e.addEventListener(t,n,r),()=>e.removeEventListener(t,n,r)),n=qs(()=>{let t=lp(nn(e[0])).filter(e=>e!=null);return t.every(e=>typeof e!=`string`)?t:void 0});return _p(()=>[n.value?.map(e=>yp(e))??[vp].filter(e=>e!=null),lp(nn(n.value?e[1]:e[0])),lp(tn(n.value?e[2]:e[1])),nn(n.value?e[3]:e[2])],([e,n,r,i],a,o)=>{if(!e?.length||!n?.length||!r?.length)return;let s=op(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 xp(){let e=Zt(!1),t=Y();return t&&Vi(()=>{e.value=!0},t),e}function Sp(e){let t=xp();return qs(()=>(t.value,!!e()))}function Cp(e){return typeof e==`function`?e:typeof e==`string`?t=>t.key===e:Array.isArray(e)?t=>e.includes(t.key):()=>!0}function wp(...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=vp,eventName:a=`keydown`,passive:o=!1,dedupe:s=!1}=r,c=Cp(t);return bp(i,a,e=>{e.repeat&&nn(s)||c(e)&&n(e)},o)}function Tp(e){return JSON.parse(JSON.stringify(e))}function Ep(e,t,n={}){let{window:r=vp,...i}=n,a,o=Sp(()=>r&&`ResizeObserver`in r),s=()=>{a&&=(a.disconnect(),void 0)},c=hr(qs(()=>{let t=nn(e);return Array.isArray(t)?t.map(e=>yp(e)):[yp(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 tp(l),{isSupported:o,stop:l}}function Dp(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=Y(),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):Tp(e):e,g=()=>ip(e[t])?h(e[t]):u,_=e=>{d?d(e)&&p(m,e):p(m,e)};if(s){let n=Xt(g()),r=!1;return hr(()=>e[t],e=>{r||(r=!0,n.value=h(e),Vn(()=>r=!1))}),hr(n,n=>{!r&&(n!==e[t]||l)&&_(n)},{deep:l}),n}return qs({get(){return g()},set(e){_(e)}})}function Op(e){return e?e.flatMap(e=>e.type===G?Op(e.children):[e]):[]}var kp=Jr({name:`PrimitiveSlot`,inheritAttrs:!1,setup(e,{attrs:t,slots:n}){return()=>{if(!n.default)return null;let e=Op(n.default()),r=e.findIndex(e=>e.type!==K);if(r===-1)return e;let i=e[r];delete i.props?.ref;let a=i.props?Cs(t,i.props):t,o=gs({...i,props:{}},a);return e.length===1?o:(e[r]=o,e)}}}),Ap=[`area`,`img`,`input`],jp=Jr({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`&&Ap.includes(r)?()=>Js(r,t):r===`template`?()=>Js(kp,t,{default:n.default}):()=>Js(e.as,t,{default:n.default})}}),Mp=Jr({__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)=>(ts(),ss(tn(jp),{"data-slot":`button`,"data-variant":e.variant,"data-size":e.size,as:e.as,"as-child":e.asChild,class:L(tn(ep)(tn(Np)({variant:e.variant,size:e.size}),t.class))},{default:ir(()=>[oa(n.$slots,`default`)]),_:3},8,[`data-variant`,`data-size`,`as`,`as-child`,`class`]))}}),Np=Od(`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`}}),Pp=[`data-size`],Fp=Jr({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e;return(n,r)=>(ts(),os(`div`,{"data-slot":`card`,"data-size":e.size,class:L(tn(ep)(`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))},[oa(n.$slots,`default`)],10,Pp))}}),Ip=Jr({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(ts(),os(`div`,{"data-slot":`card-content`,class:L(tn(ep)(`px-4 group-data-[size=sm]/card:px-3`,t.class))},[oa(e.$slots,`default`)],2))}}),Lp=Jr({__name:`CardHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(ts(),os(`div`,{"data-slot":`card-header`,class:L(tn(ep)(`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))},[oa(e.$slots,`default`)],2))}}),Rp=Jr({__name:`CardTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(ts(),os(`div`,{"data-slot":`card-title`,class:L(tn(ep)(`text-base leading-snug font-medium group-data-[size=sm]/card:text-sm font-heading`,t.class))},[oa(e.$slots,`default`)],2))}}),zp=`llmgwAdminKey`;function Bp(){try{return sessionStorage.getItem(zp)??``}catch{return``}}function Vp(e){try{sessionStorage.setItem(zp,e)}catch{}}function Hp(){try{sessionStorage.removeItem(zp)}catch{}}var Up=Gu(`auth`,{state:()=>({apiKey:Bp(),error:``}),getters:{isAuthenticated:e=>e.apiKey!==``},actions:{submit(e){e&&(this.apiKey=e,this.error=``,Vp(e))},reject(e){this.apiKey=``,this.error=e,Hp()}}}),Wp=class extends Error{status;constructor(e,t){super(e),this.name=`AdminApiError`,this.status=t}};async function Gp(e,t){let n=`${t}: HTTP ${e.status}`;try{return(await e.json()).error?.message||n}catch{return n}}async function Kp(e){let t=Up(),n=t.apiKey,r=await fetch(e,{credentials:`same-origin`,headers:n?{"x-api-key":n}:{}});if(!r.ok){let i=await Gp(r,e);throw(r.status===401||r.status===403)&&t.apiKey===n&&t.reject(`invalid key, or not an admin`),new Wp(i,r.status)}return await r.json()}function qp(e){return e||(typeof document>`u`?void 0:document)}function Jp({intervalMs:e,tick:t,doc:n}){let r=qp(n),i,a=!1;function o(){i!==void 0&&(clearInterval(i),i=void 0)}function s(){o(),i=setInterval(t,e)}function c(){r&&(r.hidden?o():(t(),s()))}function l(){a||(a=!0,r?.hidden||(t(),s()),r?.addEventListener(`visibilitychange`,c))}function u(){a=!1,o(),r?.removeEventListener(`visibilitychange`,c)}return{start:l,stop:u}}var Yp={success:3e3,info:3e3,error:6e3},Xp=Gu(`toasts`,{state:()=>({toasts:[],nextId:1,timers:{}}),actions:{push({kind:e,message:t,timeoutMs:n}){let r=this.toasts[this.toasts.length-1];if(r&&r.kind===e&&r.message===t)return;let i=this.nextId++,a={id:i,kind:e,message:t,timeoutMs:n??Yp[e]};if(this.toasts.push(a),this.toasts.length>3){let e=this.toasts.shift();e&&this.clearTimer(e.id)}this.timers[i]=setTimeout(()=>this.dismiss(i),a.timeoutMs)},dismiss(e){this.clearTimer(e),this.toasts=this.toasts.filter(t=>t.id!==e)},clearTimer(e){let t=this.timers[e];t!==void 0&&(clearTimeout(t),delete this.timers[e])}}}),Zp=5e3,Qp=Gu(`dashboard`,{state:()=>({overview:null,usage:null,targets:null,lastUpdated:null,error:``,poller:void 0,refreshing:!1,toastedForFailure:!1}),actions:{async refresh(){if(Up().isAuthenticated&&!this.refreshing){this.refreshing=!0;try{await this.doRefresh()}finally{this.refreshing=!1}}},async doRefresh(){let e=this.overview!==null||this.usage!==null||this.targets!==null,[t,n,r]=await Promise.allSettled([Kp(`/admin/api/overview`),Kp(`/admin/api/usage`),Kp(`/admin/api/targets`)]);t.status===`fulfilled`&&(this.overview=t.value),n.status===`fulfilled`&&(this.usage=n.value),r.status===`fulfilled`&&(this.targets=r.value);let i=[];if(t.status===`rejected`&&i.push({label:`overview`,reason:t.reason}),n.status===`rejected`&&i.push({label:`usage`,reason:n.reason}),r.status===`rejected`&&i.push({label:`targets`,reason:r.reason}),i.length===0){this.lastUpdated=new Date,this.error=``,this.toastedForFailure=!1;return}i.some(({reason:e})=>e instanceof Wp&&(e.status===401||e.status===403))||(i.length<3&&(this.lastUpdated=new Date),this.error=i.map(({label:e,reason:t})=>`${e}: ${t instanceof Error?t.message:String(t)}`).join(`; `),e&&!this.toastedForFailure&&Xp().push({kind:`error`,message:`Dashboard refresh failed: ${this.error}`}),this.toastedForFailure=!0)},startPolling(){this.poller||(this.poller=Jp({intervalMs:Zp,tick:()=>void this.refresh()}),this.poller.start())}}}),$p=[`home`,`spend`,`consumers`,`models`,`reliability`,`config`,`targets`],em=`home`,tm=[{id:`home`,label:`Home`,icon:id},{id:`spend`,label:`Spend`,icon:xd},{id:`consumers`,label:`Consumers`,icon:$u},{id:`models`,label:`Models`,icon:ld},{id:`reliability`,label:`Reliability`,icon:ed},{id:`config`,label:`Config`,icon:ad},{id:`targets`,label:`MCP & Agents`,icon:dd}];function nm(e){return $p.includes(e)}var rm=[`24h`,`48h`,`7d`,`14d`,`30d`,`3mo`,`6mo`,`12mo`],im={"24h":{window:`hour`,span:24},"48h":{window:`hour`,span:48},"7d":{window:`day`,span:7},"14d":{window:`day`,span:14},"30d":{window:`day`,span:30},"3mo":{window:`month`,span:3},"6mo":{window:`month`,span:6},"12mo":{window:`month`,span:12}},am={hour:48,day:35,month:13},om=[`none`,`prev`],sm=`none`;function cm(e){let{window:t,span:n}=im[e],r=am[t];return 2*n>r?{available:!1,offset:n,reason:`retention limit`}:{available:!0,offset:n}}function lm(e,t){return e===`month`?{window:`month`,span:t}:e===`day`?{window:`day`,span:t}:{window:`day`,span:7}}function um(e,t){return e===`hour`?`Showing last ${lm(e,t).span} days — per-hour data is not kept for this view.`:null}function dm(e){return rm.includes(e)}function fm(e){return om.includes(e)}function pm(e){let t=new URLSearchParams;for(let n of e.scope)t.append(`scope`,n);return t.set(`metric`,e.metric),t.set(`window`,e.window),t.set(`span`,String(e.span)),e.offset&&t.set(`offset`,String(e.offset)),`/admin/api/usage/series?${t.toString()}`}function mm(e){let t=new URLSearchParams;return t.set(`kind`,e.kind),e.window&&t.set(`window`,e.window),e.span!==void 0&&t.set(`span`,String(e.span)),e.offset&&t.set(`offset`,String(e.offset)),e.metrics&&e.metrics.length>0&&t.set(`metrics`,e.metrics.join(`,`)),e.limit!==void 0&&t.set(`limit`,String(e.limit)),e.group&&t.set(`group`,e.group),e.user&&t.set(`user`,e.user),e.model&&t.set(`model`,e.model),e.target&&t.set(`target`,e.target),`/admin/api/usage/totals?${t.toString()}`}var hm=Gu(`nav`,{state:()=>({page:em,params:{}}),actions:{goTo(e,t={}){this.page=e,this.params=t}}}),gm=Jr({__name:`Skeleton`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(ts(),os(`div`,{"data-slot":`skeleton`,class:L(tn(ep)(`animate-pulse rounded-md bg-muted motion-reduce:animate-none`,t.class))},null,2))}});export{Zu as $,Ki as $n,Gt as $r,Zo as $t,vp as A,lr as An,hr as Ar,ou as At,sp as B,Ta as Bn,Se as Br,Fc as Bt,Lp as C,ne as Ci,va as Cn,Ja as Cr,lu as Ct,jp as D,hs as Dn,Fr as Dr,pu as Dt,Mp as E,qr as En,Zr as Er,su as Et,Ep as F,Ys as Fn,ir as Fr,zl as Ft,Od as G,Bi as Gn,Be as Gr,K as Gt,hp as H,Cs as Hn,hn as Hr,Ql as Ht,Dp as I,cr as In,ba as Ir,Kl as It,vd as J,Ni as Jn,bn as Jr,G as Jt,gd as K,Wi as Kn,Ce as Kr,On as Kt,np as L,Zs as Ln,ar as Lr,Vl as Lt,yp as M,wi as Mn,pr as Mr,zc as Mt,bp as N,Ci as Nn,mr as Nr,yl as Nt,kp as O,Js as On,Qs as Or,dc as Ot,xp as P,Si as Pn,Oa as Pr,bl as Pt,Qu as Q,qi as Qn,H as Qr,Ar as Qt,dp as R,Bs as Rn,Xs as Rr,Hl as Rt,Rp as S,ve as Si,ma as Sn,Yr as Sr,cu as St,Fp as T,Y as Tn,xa as Tr,gl as Tt,gp as U,Vn as Un,gn as Ur,Vr as Ut,mp as V,Ea as Vn,De as Vr,eu as Vt,ep as W,Mi as Wn,sn as Wr,Lr as Wt,rd as X,Vi as Xn,Ut as Xr,Qo as Xt,bd as Y,Yi as Yn,Kt as Yr,Ai as Yt,ud as Z,Ji as Zn,Wt as Zr,Bo as Zt,Xp as _,O as _i,Jr as _n,ur as _r,Gu as _t,im as a,Bt as ai,ps as an,tr as ar,Xu as at,Kp as b,ue as bi,ya as bn,us as br,El as bt,lm as c,Vt as ci,os as cn,ia as cr,fd as ct,pm as d,V as di,Do as dn,ta as dr,od as dt,qt as ei,Dn as en,Gi as er,cd as et,mm as f,dn as fi,aa as fn,ea as fr,Cd as ft,Qp as g,tn as gi,Di as gn,Kr as gr,ju as gt,nm as h,en as hi,q as hn,nc as hr,sd as ht,rm as i,Rt as ii,qs as in,sr as ir,_d as it,wp as j,bi as jn,fr as jr,xl as jt,Op as k,Mn as kn,$s as kr,dl as kt,fm as l,Zt as li,Oo as ln,oa as lr,Ju as lt,tm as m,nn as mi,_s as mn,is as mr,md as mt,hm as n,xn as ni,An as nn,ts as nr,Sd as nt,cm as o,Xt as oi,ss as on,Gn as or,yd as ot,em as p,cn as pi,vs as pn,Ur as pr,Yu as pt,hd as q,Hi as qn,we as qr,ec as qt,sm as r,an as ri,gs as rn,nr as rr,td as rt,um as s,zt as si,ys as sn,zs as sr,pd as st,gm as t,Te as ti,jn as tn,Ui as tr,nd as tt,dm as u,Ve as ui,Da as un,Qi as ur,qu as ut,Jp as v,A as vi,ha as vn,rc as vr,Ku as vt,Ip as w,tc as wn,dr as wr,hl as wt,Up as x,F as xi,_a as xn,Sa as xr,vl as xt,Wp as y,L as yi,ga as yn,ca as yr,_c as yt,rp as z,cs as zn,rr as zr,Rl as zt};",
		),
	},
	"SkeletonList-Cmqz3hfa.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"aW1wb3J0e0p0IGFzIGUsX24gYXMgdCxhbiBhcyBuLGNuIGFzIHIsY3IgYXMgaSxnaSBhcyBhLGhuIGFzIG8sbnIgYXMgcyx0IGFzIGN9ZnJvbSIuL1NrZWxldG9uLUIwemlCNk9kLmpzIjt2YXIgbD17Y2xhc3M6YGZsZXggZmxleC1jb2wgZ2FwLTEuNWB9LHU9e2NsYXNzOmBmbGV4IG1pbi13LTAgZmxleC0xIGl0ZW1zLWNlbnRlciBnYXAtMmB9LGQ9dCh7X19uYW1lOmBTa2VsZXRvbkxpc3RgLHByb3BzOntyb3dzOntkZWZhdWx0OjV9fSxzZXR1cCh0KXtyZXR1cm4oZCxmKT0+KHMoKSxyKGBvbGAsbCxbKHMoITApLHIoZSxudWxsLGkodC5yb3dzLGU9PihzKCkscihgbGlgLHtrZXk6ZSxjbGFzczpgZmxleCBpdGVtcy1jZW50ZXIganVzdGlmeS1iZXR3ZWVuIGdhcC0zYH0sW24oYHNwYW5gLHUsW28oYShjKSx7Y2xhc3M6YGgtMyB3LTQgc2hyaW5rLTBgfSksbyhhKGMpLHtjbGFzczpgaC00IHctZnVsbCBtYXgtdy00MGB9KV0pLG8oYShjKSx7Y2xhc3M6YGgtNCB3LTEyIHNocmluay0wYH0pXSkpKSwxMjgpKV0pKX19KTtleHBvcnR7ZCBhcyB0fTs=",
		),
	},
	"SpendPage-6ZX2q3Zv.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{Ar as e,C as t,E as n,Fr as r,Jt as i,On as a,Q as o,S as s,Si as c,T as l,Xn as u,_n as d,_t as f,an as p,b as m,c as h,cn as g,cr as _,d as v,er as y,f as b,g as x,gi as S,hn as C,in as w,mn as T,n as ee,nr as E,oi as D,on as O,sn as k,v as A,w as j,x as M,y as N,yi as P}from"./Skeleton-B0ziB6Od.js";import{n as te,r as ne,t as re}from"./tabs-YlhnHpK-.js";import{_ as F,a as ie,c as I,g as L,h as ae,i as oe,m as se,n as ce,o as le,r as ue,t as R}from"./index-dywS8OpT.js";import{t as z}from"./ErrorState-ym6eSlj2.js";import{_ as B,a as de,d as fe,i as pe,o as V,r as me,t as H,v as U}from"./badge-DUiBTDyA.js";import{o as W,t as G}from"./DataTable-CQxRVDSY.js";import{t as K}from"./CompactNumber-pr8cJ4cv.js";import{t as q}from"./TryLongerRangeButton-CjkUnaOz.js";import{a as he,i as ge,n as _e,o as J,r as ve,s as ye,t as be}from"./burndown-Bz44x7-d.js";import{t as Y}from"./EntityLink-Dg93KGVT.js";import{t as xe}from"./ClampedRangeNotice-D2walnXf.js";import{n as Se,t as Ce}from"./TimeSeriesChart-BFcT6woA.js";import{o as we}from"./kpi-chm3BiuF.js";import{t as Te}from"./catalog-lU41irIq.js";import{i as Ee,r as De,t as Oe}from"./series-NIRVBXMP.js";var ke=[`model`,`provider`,`group`];function Ae(e){return ke.includes(e)}var je=[`cost`,`req`,`tokin`,`tokout`],X={cost:`Cost`,req:`Requests`,tokin:`Tokens in`,tokout:`Tokens out`};function Me(e){return je.includes(e)}var Ne=100,Z=100,Pe=6e4,Fe=f(`spend`,{state:()=>({by:`model`,metric:`cost`,drill:``,buckets:[],breakdown:[],otherPoints:null,totalPoints:[],comparisonPoints:null,comparisonUnavailableReason:null,modelRanking:[],pricingHealthRanking:[],burndownBuckets:[],burndownPoints:[],burndownBudgetMicros:null,drilldownRows:[],drilldownMetrics:[],drilldownDisabled:!1,loading:!1,breakdownError:``,rankingError:``,pricingHealthError:``,drilldownError:``,burndownError:``,pricingHealthLoading:!1,drilldownLoading:!1,burndownLoading:!1,pricingHealthLoaded:!1,drilldownLoaded:!1,pricingHealthWindow:null,pricingHealthSpan:null,drilldownWindow:null,drilldownSpan:null,drilldownDrillFetchedFor:null,breakdownByFetchedFor:null,breakdownMetricFetchedFor:null,breakdownWindow:null,breakdownSpan:null,breakdownScope:null,breakdownReqId:0,rankingReqId:0,pricingHealthReqId:0,burndownReqId:0,drilldownReqId:0,refreshReqId:0,poller:void 0}),getters:{burndownAvailable:()=>Le(R().scope)!==null},actions:{setSelection(e){let t=!1;e.by!==void 0&&e.by!==this.by&&(this.by=e.by,t=!0),e.metric!==void 0&&e.metric!==this.metric&&(this.metric=e.metric,t=!0),e.drill!==void 0&&e.drill!==this.drill&&(this.drill=e.drill,t=!0),t&&this.refresh()},async refresh(){if(!M().isAuthenticated)return;let e=++this.refreshReqId;this.loading=!0;try{await Promise.all([this.fetchModelRanking().then(()=>this.fetchBreakdown()),this.fetchPricingHealthRanking(),this.fetchBurndown(),this.fetchDrilldown()])}finally{e===this.refreshReqId&&(this.loading=!1)}},async fetchModelRanking(){let e=R(),t=++this.rankingReqId;try{let n=await m(`/admin/api/usage/models?metric=${this.metric}&window=${e.window}&span=${e.span}&limit=${Ne}&detail=1`);if(t!==this.rankingReqId)return;this.modelRanking=n.models,this.rankingError=``}catch(e){if(t!==this.rankingReqId||Q(e))return;this.rankingError=$(e)}},async fetchPricingHealthRanking(){let e=R();(this.pricingHealthWindow!==e.window||this.pricingHealthSpan!==e.span)&&(this.pricingHealthLoaded=!1),this.pricingHealthWindow=e.window,this.pricingHealthSpan=e.span;let t=++this.pricingHealthReqId;this.pricingHealthLoading=!0;try{let n=await m(`/admin/api/usage/models?metric=req&window=${e.window}&span=${e.span}&limit=${Ne}&detail=1`);if(t!==this.pricingHealthReqId)return;this.pricingHealthRanking=n.models,this.pricingHealthError=``,this.pricingHealthLoaded=!0}catch(e){if(t!==this.pricingHealthReqId||Q(e))return;this.pricingHealthError=$(e)}finally{t===this.pricingHealthReqId&&(this.pricingHealthLoading=!1)}},async fetchBreakdown(){let e=R();(this.breakdownByFetchedFor!==this.by||this.breakdownMetricFetchedFor!==this.metric||this.breakdownWindow!==e.window||this.breakdownSpan!==e.span||this.breakdownScope!==e.scope)&&(this.buckets=[]),this.breakdownByFetchedFor=this.by,this.breakdownMetricFetchedFor=this.metric,this.breakdownWindow=e.window,this.breakdownSpan=e.span,this.breakdownScope=e.scope;let t=++this.breakdownReqId;try{if(e.scope===`all`?await this.fetchBreakdownFleetWide(e.window,e.span,t):e.scope.startsWith(`group:`)||e.scope.startsWith(`user:`)?await this.fetchBreakdownSingleScope(e.scope,e.window,e.span,t):await this.fetchBreakdownProviderScope(e.scope.slice(9),e.window,e.span,t),t!==this.breakdownReqId)return;this.breakdownError=``,e.cmpSpec.requested?await this.fetchComparison(e.scope,e.window,e.span,e.cmpSpec.offset,t):(this.comparisonPoints=null,this.comparisonUnavailableReason=null)}catch(e){if(t!==this.breakdownReqId||Q(e))return;this.breakdownError=$(e)}},async fetchBreakdownFleetWide(e,t,n){let r=await this.fetchSeries([`total`],this.metric,e,t,0);if(n!==this.breakdownReqId)return;this.buckets=r.buckets;let i=r.series.find(e=>e.scope===`total`)?.points??Array(r.buckets.length).fill(0);if(this.totalPoints=i,this.by===`model`){let r=this.modelRanking.slice(0,10).map(e=>`model:${e.id}`);if(r.length===0){this.breakdown=[],this.otherPoints=Oe(i,[]);return}let a=await this.fetchSeries(r,this.metric,e,t,0);if(n!==this.breakdownReqId)return;let o=De(a.series,10);this.breakdown=o,this.otherPoints=Oe(i,o);return}if(this.by===`provider`){let r=this.modelRanking.slice(0,Z).map(e=>`model:${e.id}`);if(r.length===0){this.breakdown=[],this.otherPoints=null;return}let i=await this.fetchSeries(r,this.metric,e,t,0);if(n!==this.breakdownReqId)return;this.breakdown=Ee(i.series),this.otherPoints=null;return}let a=await m(b({kind:`group`,window:e,span:t,metrics:[this.metric]}));if(n!==this.breakdownReqId)return;let o=a.rows.slice(0,Z).map(e=>`group:${e.id}`);if(o.length===0){this.breakdown=[],this.otherPoints=null;return}let s=await this.fetchSeries(o,this.metric,e,t,0);n===this.breakdownReqId&&(this.breakdown=s.series,this.otherPoints=null)},async fetchBreakdownSingleScope(e,t,n,r){let i=await this.fetchSeries([e],this.metric,t,n,0);if(r!==this.breakdownReqId)return;this.buckets=i.buckets;let a=i.series.find(t=>t.scope===e)?.points??Array(i.buckets.length).fill(0);this.breakdown=[{scope:e,points:a}],this.otherPoints=null,this.totalPoints=a},async fetchBreakdownProviderScope(e,t,n,r){let i=this.modelRanking.filter(t=>t.id.startsWith(`${e}/`)).slice(0,Z).map(e=>`model:${e.id}`);if(i.length===0){this.buckets=[],this.breakdown=[],this.otherPoints=null,this.totalPoints=[];return}let a=await this.fetchSeries(i,this.metric,t,n,0);if(r!==this.breakdownReqId)return;this.buckets=a.buckets;let[o]=Ee(a.series),s=o?.points??Array(a.buckets.length).fill(0);this.breakdown=[{scope:`provider:${e}`,points:s}],this.otherPoints=null,this.totalPoints=s},async fetchComparison(e,t,n,r,i){let a=e===`all`?`total`:e.startsWith(`provider:`)?null:e;if(a===null){this.comparisonPoints=null,this.comparisonUnavailableReason=`Comparison is not available for a single-provider scope.`;return}let o=await this.fetchSeries([a],this.metric,t,n,r);i===this.breakdownReqId&&(this.comparisonPoints=o.series.find(e=>e.scope===a)?.points??null,this.comparisonUnavailableReason=null)},async fetchSeries(e,t,n,r,i){return m(v({scope:e,metric:t,window:n,span:r,offset:i||void 0}))},async fetchBurndown(){let e=R(),t=++this.burndownReqId,n=Le(e.scope);if(n===null){this.burndownBuckets=[],this.burndownPoints=[],this.burndownBudgetMicros=null,this.burndownError=``,this.burndownLoading=!1;return}this.burndownLoading=!0;try{let e=_e(new Date),r=await this.fetchSeries([n],`cost`,`day`,e,0);if(t!==this.burndownReqId)return;this.burndownBuckets=r.buckets,this.burndownPoints=r.series.find(e=>e.scope===n)?.points??Array(r.buckets.length).fill(0),this.burndownBudgetMicros=Re(n),this.burndownError=``}catch(e){if(t!==this.burndownReqId||Q(e))return;this.burndownError=$(e)}finally{t===this.burndownReqId&&(this.burndownLoading=!1)}},async fetchDrilldown(){let e=R();(this.drilldownWindow!==e.window||this.drilldownSpan!==e.span||this.drilldownDrillFetchedFor!==this.drill)&&(this.drilldownLoaded=!1),this.drilldownWindow=e.window,this.drilldownSpan=e.span,this.drilldownDrillFetchedFor=this.drill;let t=++this.drilldownReqId,n=Ie(this.drill);this.drilldownLoading=!0;try{let r=n.kind===`usermodel`?{kind:`usermodel`,...h(e.window,e.span),user:n.user}:n.kind===`user`?{kind:`user`,window:e.window,span:e.span,group:n.group,metrics:[`req`,`tokin`,`tokout`,`cost`]}:{kind:`group`,window:e.window,span:e.span,metrics:[`req`,`tokin`,`tokout`,`cost`]},i=await m(b(r));if(t!==this.drilldownReqId)return;this.drilldownRows=i.rows,this.drilldownMetrics=i.metrics,this.drilldownDisabled=!1,this.drilldownError=``,this.drilldownLoaded=!0}catch(e){if(t!==this.drilldownReqId||Q(e))return;if(e instanceof N&&e.status===404){this.drilldownRows=[],this.drilldownMetrics=[],this.drilldownDisabled=!0,this.drilldownError=``,this.drilldownLoaded=!0;return}this.drilldownError=$(e)}finally{t===this.drilldownReqId&&(this.drilldownLoading=!1)}},startPolling(){this.poller||(this.poller=A({intervalMs:Pe,tick:()=>void this.refresh()}),this.poller.start())},stopPolling(){this.poller?.stop(),this.poller=void 0}}});function Ie(e){return e===``?{kind:`group`}:e.startsWith(`group:`)?{kind:`user`,group:e.slice(6)}:{kind:`usermodel`,user:e.slice(5)}}function Le(e){return e===`all`?`total`:e.startsWith(`group:`)||e.startsWith(`user:`)?e:null}function Re(e){let t=x();if(e===`total`){let e=we(t.overview?.groups??[]);return e>0?e:null}if(e.startsWith(`group:`)){let n=e.slice(6),r=t.overview?.groups.find(e=>e.name===n)?.limits?.costPerMonthUSD;return r&&r>0?Math.round(r*1e6):null}let n=e.slice(5),r=t.usage?.users.find(e=>e.id===n)?.limits?.costPerMonthUSD;return r&&r>0?Math.round(r*1e6):null}function Q(e){return e instanceof N&&(e.status===401||e.status===403)}function $(e){return e instanceof Error?e.message:String(e)}var ze={"aria-label":`Breadcrumb`,class:`flex flex-wrap items-center gap-1.5 text-sm text-muted-foreground`},Be=[`disabled`],Ve={class:`font-medium text-foreground`},He={class:`font-medium text-foreground`},Ue=d({__name:`AttributionDrilldown`,props:{rows:{},metrics:{},drill:{},disabled:{type:Boolean},userModelStatsEnabled:{type:Boolean},window:{},span:{},loading:{type:Boolean},loaded:{type:Boolean},error:{},onRetry:{type:Function}},emits:[`update:drill`],setup(e,{emit:u}){let d=e,f=u,m=ee(),h=w(()=>d.drill===``?{kind:`group`}:d.drill.startsWith(`group:`)?{kind:`user`,group:d.drill.slice(6)}:{kind:`usermodel`,user:d.drill.slice(5)}),_=D(``);function v(){f(`update:drill`,``)}function y(){_.value&&f(`update:drill`,`group:${_.value}`)}function b(e){let t=h.value;t.kind===`group`?f(`update:drill`,`group:${e}`):t.kind===`user`&&d.userModelStatsEnabled&&(_.value=t.group,f(`update:drill`,`user:${e}`))}let x=w(()=>h.value.kind===`group`?`Group`:h.value.kind===`user`?`User`:`Model`);function A(e){let t=h.value;return t.kind===`usermodel`?a(Y,{label:e.id,kind:`model`,id:e.id}):t.kind===`group`||d.userModelStatsEnabled?a(`button`,{type:`button`,class:`inline-flex cursor-pointer items-center gap-1 rounded-sm hover:text-primary hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50`,onClick:()=>b(e.id)},[e.id,a(F,{icon:o,class:`size-3`,"aria-hidden":`true`})]):a(`span`,{},e.id)}let M=w(()=>[{id:`id`,header:x.value,accessorFn:e=>e.id,cell:({row:e})=>A(e.original)},...d.metrics.map(e=>({id:e,header:X[e]??e,meta:{align:`right`},accessorFn:t=>t.values[e]??0,cell:({row:t})=>{let n=t.original.values[e]??0;return e===`cost`?V(n):a(K,{value:n})}}))]),N=w(()=>h.value.kind===`user`&&(!d.userModelStatsEnabled||d.disabled)),P=w(()=>B({loading:d.loading,hasData:d.loaded,error:d.error})),te=w(()=>!N.value&&d.rows.length===0);return(a,u)=>(E(),O(S(l),null,{default:r(()=>[C(S(t),null,{default:r(()=>[C(S(s),null,{default:r(()=>[...u[1]||=[T(`Attribution`,-1)]]),_:1}),C(S(I),null,{default:r(()=>[...u[2]||=[T(`Drill from groups into users into the models they used.`,-1)]]),_:1}),p(`nav`,ze,[p(`button`,{type:`button`,class:`hover:text-foreground hover:underline`,disabled:h.value.kind===`group`,onClick:v},` All groups `,8,Be),h.value.kind===`user`?(E(),g(i,{key:0},[C(S(F),{icon:S(o),class:`size-3`,"aria-hidden":`true`},null,8,[`icon`]),p(`span`,Ve,c(h.value.group),1)],64)):k(``,!0),h.value.kind===`usermodel`?(E(),g(i,{key:1},[C(S(F),{icon:S(o),class:`size-3`,"aria-hidden":`true`},null,8,[`icon`]),_.value?(E(),g(`button`,{key:0,type:`button`,class:`hover:text-foreground hover:underline`,onClick:y},c(_.value),1)):k(``,!0),C(S(F),{icon:S(o),class:`size-3`,"aria-hidden":`true`},null,8,[`icon`]),p(`span`,He,c(h.value.user),1)],64)):k(``,!0)])]),_:1}),C(S(j),{class:`flex flex-col gap-3`},{default:r(()=>[h.value.kind===`usermodel`?(E(),O(xe,{key:0,window:e.window,span:e.span},null,8,[`window`,`span`])):k(``,!0),N.value?(E(),O(S(L),{key:1,variant:`warn`},{default:r(()=>[C(S(se),null,{default:r(()=>[...u[3]||=[T(`Per-user-model statistics are off`,-1)]]),_:1}),C(S(ae),{class:`flex flex-wrap items-center gap-2`},{default:r(()=>[u[5]||=p(`span`,null,[T(`Enable `),p(`code`,{class:`font-mono text-xs`},`admin.stats.userModel`),T(` in the middleware config to see per-model attribution for this user.`)],-1),C(S(n),{type:`button`,variant:`outline`,size:`sm`,onClick:u[0]||=e=>S(m).goTo(`config`)},{default:r(()=>[...u[4]||=[T(`Open Config`,-1)]]),_:1})]),_:1})]),_:1})):P.value===`skeleton`?(E(),O(W,{key:2,rows:5,cols:e.metrics.length+1},null,8,[`cols`])):P.value===`error`?(E(),O(z,{key:3,message:e.error,"on-retry":e.onRetry},null,8,[`message`,`on-retry`])):te.value?(E(),O(U,{key:4,title:`No traffic in this range.`},{default:r(()=>[C(q)]),_:1})):(E(),O(G,{key:5,columns:M.value,data:e.rows,"empty-message":`none`},null,8,[`columns`,`data`]))]),_:1})]),_:1}))}}),We={class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-3`},Ge={key:0},Ke={class:`text-lg font-semibold tabular-nums`},qe={key:1},Je={key:0,class:`text-sm text-muted-foreground`},Ye={key:0,class:`text-sm text-muted-foreground`},Xe=d({__name:`BurnDownChart`,props:{buckets:{},points:{},budgetMicros:{},now:{},loading:{type:Boolean},error:{},onRetry:{type:Function}},setup(e){let n=e,a=w(()=>B({loading:n.loading??!1,hasData:n.buckets.length>0,error:n.error??``})),o=w(()=>n.buckets.map(e=>me(e,`day`))),u=w(()=>be(n.points)),d=w(()=>u.value.at(-1)??0),f=w(()=>[{label:`Spent (MTD)`,data:u.value,color:`--chart-cost`}]),m=w(()=>n.budgetMicros===null?[]:[{label:`Budget`,data:Array(u.value.length).fill(n.budgetMicros),color:`--destructive`}]),h=w(()=>n.budgetMicros===null?null:ve(d.value,n.budgetMicros,n.now)),_=w(()=>n.budgetMicros!==null&&d.value>=n.budgetMicros);return(n,u)=>(E(),O(S(l),null,{default:r(()=>[C(S(t),null,{default:r(()=>[C(S(s),null,{default:r(()=>[...u[0]||=[T(`Burn-down`,-1)]]),_:1}),C(S(I),null,{default:r(()=>[...u[1]||=[T(`Cumulative spend this UTC calendar month against the configured budget.`,-1)]]),_:1})]),_:1}),C(S(j),{class:`flex flex-col gap-4`},{default:r(()=>[a.value===`skeleton`?(E(),O(Se,{key:0})):a.value===`error`?(E(),O(z,{key:1,message:e.error??``,"on-retry":e.onRetry},null,8,[`message`,`on-retry`])):(E(),g(i,{key:2},[p(`div`,We,[p(`div`,null,[u[2]||=p(`p`,{class:`text-muted-foreground`},`Spent so far`,-1),p(`p`,{class:P([`text-lg font-semibold tabular-nums`,_.value?`text-destructive`:void 0])},c(S(V)(d.value)),3)]),e.budgetMicros===null?k(``,!0):(E(),g(`div`,Ge,[u[3]||=p(`p`,{class:`text-muted-foreground`},`Budget`,-1),p(`p`,Ke,c(S(V)(e.budgetMicros)),1)])),e.budgetMicros===null?k(``,!0):(E(),g(`div`,qe,[u[4]||=p(`p`,{class:`text-muted-foreground`},`Projected run-out`,-1),h.value===null?(E(),g(`p`,Je,`not enough data yet`)):(E(),g(`p`,{key:1,class:P([`text-lg font-semibold tabular-nums`,_.value?`text-destructive`:void 0])},c(h.value.toLocaleDateString(void 0,{month:`short`,day:`numeric`})),3))]))]),e.budgetMicros===null?(E(),g(`p`,Ye,`No budget configured for this scope.`)):k(``,!0),C(Ce,{labels:o.value,datasets:f.value,"comparison-datasets":m.value,"value-formatter":S(V),ariaLabel:`Cumulative spend this month against the configured budget`},null,8,[`labels`,`datasets`,`comparison-datasets`,`value-formatter`])],64))]),_:1})]),_:1}))}});function Ze(e){return e.filter(e=>e.free).map(e=>({tokensIn:e.tokensIn??0,tokensOut:e.tokensOut??0}))}function Qe(e,t,n){let r=0;for(let i of e)r+=i.tokensIn*t+i.tokensOut*n;return Math.round(r)}var $e=new Set([`free`,`unpriced`]);function et(e,t){let n=null;for(let r of e){if(r.requests===void 0)continue;let e=t.get(r.id);!e||$e.has(e.priceSource)||(n===null||r.requests>(n.requests??0))&&(n=r)}return n?.id??null}var tt={key:0,class:`flex flex-col gap-1`},nt={key:0,class:`text-sm text-muted-foreground`},rt={key:1,class:`text-lg font-semibold tabular-nums text-chart-requests`},it={key:0},at={key:0,class:`text-lg font-semibold tabular-nums text-muted-foreground`},ot={key:1,class:`text-lg font-semibold tabular-nums text-chart-requests`},st={key:2,class:`text-xs text-status-warn`},ct=d({__name:`CostAvoidedCard`,props:{models:{},catalog:{},refModel:{},cacheStatsEnabled:{type:Boolean},cacheSavingsAvailable:{type:Boolean},cacheSavingsNote:{}},emits:[`update:refModel`],setup(e,{emit:n}){let a=e,o=n,u=w(()=>{let e=[];for(let t of a.models){let n=a.catalog.get(t.id);!n||n.priceSource===`free`||n.priceSource===`unpriced`||e.push({id:t.id,requests:t.requests??0})}return e.sort((e,t)=>t.requests-e.requests)}),d=w(()=>et(a.models,a.catalog)),f=w(()=>a.refModel||d.value),m=w(()=>f.value?a.catalog.get(f.value):void 0),h=w(()=>{let e=m.value;return!e||e.inputPerMTokUsd===void 0||e.outputPerMTokUsd===void 0?null:Qe(Ze(a.models),e.inputPerMTokUsd,e.outputPerMTokUsd)}),v=w(()=>{let e=0;for(let t of a.models)e+=t.cacheSavedMicroUsd??0;return e});function y(e){typeof e==`string`&&o(`update:refModel`,e)}return(n,a)=>(E(),O(S(l),null,{default:r(()=>[C(S(t),{class:`flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between`},{default:r(()=>[p(`div`,null,[C(S(s),null,{default:r(()=>[...a[0]||=[T(`Cost avoided`,-1)]]),_:1}),C(S(I),null,{default:r(()=>[...a[1]||=[T(`What free-tier traffic in range would have cost at a real model's own rates.`,-1)]]),_:1})]),u.value.length>0?(E(),g(`div`,tt,[a[2]||=p(`label`,{id:`cost-avoided-ref-label`,class:`text-xs font-medium text-muted-foreground`},`Reference model`,-1),C(S(le),{"model-value":f.value??void 0,"onUpdate:modelValue":y},{default:r(()=>[C(S(ue),{"aria-labelledby":`cost-avoided-ref-label`,class:`w-56`},{default:r(()=>[C(S(ce),{placeholder:`Pick a reference model`})]),_:1}),C(S(ie),null,{default:r(()=>[(E(!0),g(i,null,_(u.value,e=>(E(),O(S(oe),{key:e.id,value:e.id},{default:r(()=>[T(c(e.id),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])):k(``,!0)]),_:1}),C(S(j),{class:`grid grid-cols-2 gap-4 text-sm`},{default:r(()=>[p(`div`,null,[a[3]||=p(`p`,{class:`text-muted-foreground`},`Cost avoided (free-tier traffic)`,-1),h.value===null?(E(),g(`p`,nt,c(u.value.length===0?`No priced model served in range to compare against.`:`Pick a reference model above.`),1)):(E(),g(`p`,rt,c(S(V)(h.value)),1))]),e.cacheStatsEnabled?(E(),g(`div`,it,[a[4]||=p(`p`,{class:`text-muted-foreground`},`Cache savings`,-1),e.cacheSavingsAvailable?(E(),g(`p`,ot,c(S(V)(v.value)),1)):(E(),g(`p`,at,`n/a`)),e.cacheSavingsNote?(E(),g(`p`,st,c(e.cacheSavingsNote),1)):k(``,!0)])):k(``,!0)]),_:1})]),_:1}))}});function lt(e,t){let n=[];for(let r of e){let e=t.get(r.id);e&&n.push({id:r.id,priceSource:e.priceSource,displayFree:e.displayFree??!1,requests:r.requests??0,tokensIn:r.tokensIn??0,tokensOut:r.tokensOut??0,costMicroUsd:r.costMicroUsd??0,contextTokens:e.contextTokens,inputPerMTokUsd:e.inputPerMTokUsd,outputPerMTokUsd:e.outputPerMTokUsd,aliases:e.aliases})}return n}var ut={unpriced:0,override:1,builtin:2,litellm:3,free:4};function dt(e){return[...e].sort((e,t)=>{let n=ut[e.priceSource]-ut[t.priceSource];return n===0?t.requests-e.requests:n})}var ft={class:`flex justify-end`},pt=d({__name:`PricingHealthTable`,props:{models:{},catalog:{},loading:{type:Boolean},loaded:{type:Boolean},error:{},onRetry:{type:Function}},setup(e){let n=e,o=w(()=>dt(lt(n.models,n.catalog))),u=w(()=>B({loading:n.loading,hasData:n.loaded,error:n.error})),d=w(()=>o.value.filter(e=>e.priceSource===`unpriced`).length),f={unpriced:`destructive`,free:`secondary`,override:`outline`,builtin:`outline`,litellm:`outline`};function m(e){return a(H,{as:`span`,variant:f[e.priceSource],class:`font-normal`},()=>e.priceSource)}function h(e){return e.inputPerMTokUsd===void 0||e.outputPerMTokUsd===void 0?a(`span`,{class:`text-muted-foreground`},`—`):a(`span`,{},fe(e.inputPerMTokUsd,e.outputPerMTokUsd))}let _=[{id:`id`,header:`Model`,accessorFn:e=>e.id,cell:({row:e})=>a(Y,{label:e.original.id,kind:`model`,id:e.original.id})},{id:`source`,header:`Source`,accessorFn:e=>e.priceSource,cell:({row:e})=>m(e.original)},{id:`price`,header:`Price`,enableSorting:!1,cell:({row:e})=>h(e.original)},{id:`context`,header:`Context`,meta:{align:`right`},accessorFn:e=>e.contextTokens??0,cell:({row:e})=>a(`span`,{class:`tabular-nums`},e.original.contextTokens===void 0?`—`:de(e.original.contextTokens))},{id:`requests`,header:`Requests`,meta:{align:`right`},accessorFn:e=>e.requests,cell:({row:e})=>a(K,{value:e.original.requests})},{id:`tokensIn`,header:`Tokens in`,meta:{align:`right`},accessorFn:e=>e.tokensIn,cell:({row:e})=>a(K,{value:e.original.tokensIn})},{id:`tokensOut`,header:`Tokens out`,meta:{align:`right`},accessorFn:e=>e.tokensOut,cell:({row:e})=>a(K,{value:e.original.tokensOut})},{id:`cost`,header:`Cost`,meta:{align:`right`},accessorFn:e=>e.costMicroUsd,cell:({row:e})=>V(e.original.costMicroUsd)}];function v(){return ge([`id`,`priceSource`,`displayFree`,`requests`,`tokensIn`,`tokensOut`,`costMicroUsd`,`contextTokens`,`inputPerMTokUsd`,`outputPerMTokUsd`],o.value.map(e=>[e.id,e.priceSource,e.displayFree,e.requests,e.tokensIn,e.tokensOut,e.costMicroUsd,e.contextTokens??``,e.inputPerMTokUsd??``,e.outputPerMTokUsd??``]))}return(n,a)=>(E(),O(S(l),null,{default:r(()=>[C(S(t),null,{default:r(()=>[C(S(s),{class:`flex items-center gap-2`},{default:r(()=>[a[0]||=T(` Pricing health `,-1),d.value>0?(E(),O(S(H),{key:0,variant:`destructive`,class:`font-normal`},{default:r(()=>[T(c(d.value)+` unpriced`,1)]),_:1})):k(``,!0)]),_:1}),C(S(I),null,{default:r(()=>[...a[1]||=[T(`Every model served in range, joined with its billing price source.`,-1)]]),_:1})]),_:1}),C(S(j),{class:`flex flex-col gap-3`},{default:r(()=>[u.value===`skeleton`?(E(),O(W,{key:0,rows:5,cols:_.length},null,8,[`cols`])):u.value===`error`?(E(),O(z,{key:1,message:e.error,"on-retry":e.onRetry},null,8,[`message`,`on-retry`])):o.value.length===0?(E(),O(U,{key:2,title:`No traffic in this range.`},{default:r(()=>[C(q)]),_:1})):(E(),g(i,{key:3},[C(G,{columns:_,data:o.value,"empty-message":`none`},null,8,[`data`]),p(`div`,ft,[C(J,{filename:`pricing-health.csv`,build:v})])],64))]),_:1})]),_:1}))}});function mt(e){return e===`hour`?{available:!1,note:`Cache savings are not tracked per hour — pick a day or month range instead.`}:e===`month`?{available:!0,note:`Covers only the most recent 35 days (day-bucket retention), not the full selected range.`}:{available:!0,note:null}}var ht={class:`flex flex-col gap-4`},gt={class:`flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between`},_t={class:`flex flex-wrap items-center gap-3`},vt={class:`flex flex-col gap-1`},yt={class:`flex flex-col gap-1`},bt={class:`text-right`},xt={class:`text-xs font-medium text-muted-foreground`},St={class:`text-2xl font-semibold tabular-nums`},Ct={key:0,class:`text-sm text-muted-foreground`},wt={class:`font-mono text-xs`},Tt={key:1,class:`text-sm break-words text-destructive`},Et={key:2,class:`text-sm break-words text-destructive`},Dt={key:3,class:`text-sm text-muted-foreground`},Ot={key:7,class:`text-sm break-words text-destructive`},kt={class:`grid grid-cols-1 gap-4 lg:grid-cols-2`},At=d({__name:`SpendPage`,setup(t){let n={model:`By model`,provider:`By provider`,group:`By group`},a=ee(),o=R(),s=x(),l=Te(),d=Fe(),{now:f,start:m,stop:h}=he(),v=w(()=>a.params.by&&Ae(a.params.by)?a.params.by:`model`),b=w(()=>a.params.metric&&Me(a.params.metric)?a.params.metric:`cost`),D=w(()=>a.params.ref??``),A=w(()=>a.params.drill??``);function j(e){let t={by:e.by??v.value,metric:e.metric??b.value,ref:e.ref??D.value,drill:e.drill??A.value},n={};t.by!==`model`&&(n.by=t.by),t.metric!==`cost`&&(n.metric=t.metric),t.ref!==``&&(n.ref=t.ref),t.drill!==``&&(n.drill=t.drill),a.goTo(`spend`,n)}function M(e){typeof e==`string`&&Ae(e)&&j({by:e})}function N(e){typeof e==`string`&&Me(e)&&j({metric:e})}function P(e){j({ref:e})}function F(e){j({drill:e})}let I=w(()=>o.scope!==`all`);e([v,b,A],([e,t,n])=>{d.setSelection({by:e,metric:t,drill:n})}),e(()=>[o.range,o.cmp,o.scope],()=>void d.refresh()),u(()=>{d.$patch({by:v.value,metric:b.value,drill:A.value}),l.ensureLoaded(),d.startPolling(),m()}),y(()=>{d.stopPolling(),h()});let L=[`--chart-requests`,`--chart-tokens-in`,`--chart-tokens-out`,`--chart-cost`,`--chart-series-a`,`--chart-series-b`,`--chart-series-c`,`--chart-series-d`];function ae(e){return L[e%L.length]}function se(e){return e.startsWith(`model:`)||e.startsWith(`group:`)?e.slice(6):e.startsWith(`provider:`)?e.slice(9):e}let de=w(()=>d.buckets.map(e=>me(e,o.window))),fe=w(()=>{let e=d.breakdown.map((e,t)=>({label:se(e.scope),data:e.points,color:ae(t)}));return d.otherPoints&&e.push({label:`Other`,data:d.otherPoints,color:`--muted-foreground`}),e}),H=w(()=>d.comparisonPoints?[{label:`Total`,data:d.comparisonPoints,color:`--foreground`,labelSuffix:` (previous period)`}]:[]),U=w(()=>b.value===`cost`?V:pe),W=w(()=>d.totalPoints.reduce((e,t)=>e+t,0)),G=w(()=>{if(o.scope===`all`)return s.usage?.total.costPerMonthMicroUsd??0;if(o.scope.startsWith(`group:`)){let e=o.scope.slice(6);return s.usage?.groups.find(t=>t.id===e)?.costPerMonthMicroUsd??0}if(o.scope.startsWith(`user:`)){let e=o.scope.slice(5);return s.usage?.users.find(t=>t.id===e)?.costPerMonthMicroUsd??0}return 0}),K=w(()=>{if(o.scope===`all`){let e=(s.overview?.groups??[]).filter(e=>(e.limits?.costPerMonthUSD??0)>0);return e.length===0?void 0:{costPerMonthUSD:e.reduce((e,t)=>e+(t.limits?.costPerMonthUSD??0),0)}}if(o.scope.startsWith(`group:`)){let e=o.scope.slice(6);return s.overview?.groups.find(t=>t.name===e)?.limits}if(o.scope.startsWith(`user:`)){let e=o.scope.slice(5);return s.usage?.users.find(t=>t.id===e)?.limits}}),q=w(()=>o.scope===`all`||o.scope.startsWith(`group:`)||o.scope.startsWith(`user:`)),ge=w(()=>s.overview?.features.userModelStats??!1),_e=w(()=>s.overview?.features.cacheStats??!1),J=w(()=>mt(o.window)),ve=w(()=>J.value.available),be=w(()=>J.value.note),Y=w(()=>B({loading:d.loading,hasData:d.buckets.length>0,error:d.breakdownError}));function xe(){let e=[d.fetchPricingHealthRanking()];return l.error&&e.push(l.fetch()),Promise.all(e).then(()=>void 0)}return(e,t)=>(E(),g(`div`,ht,[p(`div`,gt,[p(`div`,_t,[p(`div`,vt,[t[0]||=p(`span`,{class:`text-xs font-medium text-muted-foreground`},`Breakdown`,-1),C(S(ne),{"model-value":v.value,"onUpdate:modelValue":M},{default:r(()=>[C(S(te),null,{default:r(()=>[(E(!0),g(i,null,_(S(ke),e=>(E(),O(S(re),{key:e,value:e,disabled:I.value},{default:r(()=>[T(c(n[e]),1)]),_:2},1032,[`value`,`disabled`]))),128))]),_:1})]),_:1},8,[`model-value`])]),p(`div`,yt,[t[1]||=p(`label`,{id:`spend-metric-label`,class:`text-xs font-medium text-muted-foreground`},`Metric`,-1),C(S(le),{"model-value":b.value,"onUpdate:modelValue":N},{default:r(()=>[C(S(ue),{"aria-labelledby":`spend-metric-label`,class:`w-40`},{default:r(()=>[C(S(ce))]),_:1}),C(S(ie),null,{default:r(()=>[(E(!0),g(i,null,_(S(je),e=>(E(),O(S(oe),{key:e,value:e},{default:r(()=>[T(c(S(X)[e]),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),p(`div`,bt,[p(`p`,xt,c(S(X)[b.value])+` in range`,1),p(`p`,St,c(U.value(W.value)),1)])]),I.value?(E(),g(`p`,Ct,[t[2]||=T(` Showing `,-1),p(`span`,wt,c(S(o).scope),1),t[3]||=T(` directly — clear the scope filter to break spend down by model, provider, or group. `,-1)])):k(``,!0),S(l).error?(E(),g(`p`,Tt,c(S(l).error),1)):k(``,!0),S(d).rankingError?(E(),g(`p`,Et,c(S(d).rankingError),1)):k(``,!0),S(o).cmpSpec.requested&&S(d).comparisonUnavailableReason?(E(),g(`p`,Dt,c(S(d).comparisonUnavailableReason),1)):k(``,!0),Y.value===`skeleton`?(E(),O(Se,{key:4})):Y.value===`error`?(E(),O(z,{key:5,message:S(d).breakdownError,"on-retry":S(d).refresh},null,8,[`message`,`on-retry`])):(E(),O(Ce,{key:6,labels:de.value,datasets:fe.value,"comparison-datasets":H.value,stacked:``,"value-formatter":U.value,ariaLabel:`${S(X)[b.value]} breakdown ${n[v.value].toLowerCase()} over time`},null,8,[`labels`,`datasets`,`comparison-datasets`,`value-formatter`,`ariaLabel`])),S(d).breakdownError&&Y.value===`ready`?(E(),g(`p`,Ot,c(S(d).breakdownError),1)):k(``,!0),p(`div`,kt,[S(d).burndownAvailable?(E(),O(Xe,{key:0,buckets:S(d).burndownBuckets,points:S(d).burndownPoints,"budget-micros":S(d).burndownBudgetMicros,now:S(f),loading:S(d).burndownLoading,error:S(d).burndownError,"on-retry":S(d).refresh},null,8,[`buckets`,`points`,`budget-micros`,`now`,`loading`,`error`,`on-retry`])):k(``,!0),q.value?(E(),O(ye,{key:1,"mtd-micros":G.value,limits:K.value,now:S(f)},null,8,[`mtd-micros`,`limits`,`now`])):k(``,!0)]),C(ct,{models:S(d).modelRanking,catalog:S(l).modelsById,"ref-model":D.value,"cache-stats-enabled":_e.value,"cache-savings-available":ve.value,"cache-savings-note":be.value,"onUpdate:refModel":P},null,8,[`models`,`catalog`,`ref-model`,`cache-stats-enabled`,`cache-savings-available`,`cache-savings-note`]),C(pt,{models:S(d).pricingHealthRanking,catalog:S(l).modelsById,loading:S(d).pricingHealthLoading,loaded:S(d).pricingHealthLoaded,error:S(d).pricingHealthError||S(l).error,"on-retry":xe},null,8,[`models`,`catalog`,`loading`,`loaded`,`error`]),C(Ue,{rows:S(d).drilldownRows,metrics:S(d).drilldownMetrics,drill:A.value,disabled:S(d).drilldownDisabled,"user-model-stats-enabled":ge.value,window:S(o).window,span:S(o).span,loading:S(d).drilldownLoading,loaded:S(d).drilldownLoaded,error:S(d).drilldownError,"on-retry":S(d).fetchDrilldown,"onUpdate:drill":F},null,8,[`rows`,`metrics`,`drill`,`disabled`,`user-model-stats-enabled`,`window`,`span`,`loading`,`loaded`,`error`,`on-retry`])]))}});export{At as default};",
		),
	},
	"TargetsPage-DYUVhhsj.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{Ar as e,C as t,Fr as n,Jt as r,On as i,Qr as a,S as o,Si as s,T as c,_n as l,b as u,c as d,cn as f,f as p,g as m,gi as h,hn as g,ii as _,in as v,mn as y,n as b,nr as x,oi as S,on as C,sn as w,w as T}from"./Skeleton-B0ziB6Od.js";import{c as E,g as D,h as O,t as k}from"./index-dywS8OpT.js";import{t as A}from"./ErrorState-ym6eSlj2.js";import{_ as j,l as M,s as N,t as P,v as F}from"./badge-DUiBTDyA.js";import{o as I,t as L}from"./DataTable-CQxRVDSY.js";import{t as R}from"./CompactNumber-pr8cJ4cv.js";import{n as z,t as B}from"./useSearchQuery-bQZP4TsZ.js";import{t as V}from"./ClampedRangeNotice-D2walnXf.js";function H(e,t,n){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>i(R,{value:n(e.original)})}}var U=`not observed yet — no traffic and probes disabled or not yet run`;function W(e){let t=N(e.lastCheck);return t?`unhealthy (${t})`:`unhealthy`}function G(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 K(e){let t=N(e.lastCheck);return t?e.source?`${t} via ${e.source}`:t:e.source?`via ${e.source}`:``}function q(e){if(e.consecutiveFailures<=0&&!e.lastError)return U;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 J(e){if(e.state===`unhealthy`)return i(P,{as:`span`,variant:`destructive`,class:`font-normal`,title:G(e)},()=>W(e));if(e.state===`healthy`){let t=e.latencyMs===void 0?``:` · ${M(e.latencyMs)}`;return i(`span`,{class:`text-muted-foreground`,title:K(e)},`healthy${t}`)}return i(P,{as:`span`,variant:`outline`,class:`font-normal`,title:q(e)},()=>`unknown`)}function Y(e){return[{id:`name`,header:`Name`,accessorFn:e=>e.name,cell:({row:t})=>e?i(`button`,{type:`button`,class:`cursor-pointer rounded-sm font-medium hover:text-primary hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50`,title:`View ${t.original.name}'s callers`,onClick:n=>{n.stopPropagation(),e(t.original)}},t.original.name):i(`span`,{class:`font-medium`},t.original.name)},{id:`url`,header:`URL`,accessorFn:e=>e.url,cell:({row:e})=>i(`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})=>J(e.original.health)},{id:`access`,header:`Access`,enableSorting:!1,accessorFn:e=>(e.access??[]).join(`, `),cell:({row:e})=>{let t=e.original.access;return t==null?i(`span`,{class:`text-muted-foreground`},`All groups`):t.length===0?i(`span`,{class:`text-muted-foreground`},`No groups`):i(`div`,{class:`flex flex-wrap gap-1.5`},t.map(e=>i(P,{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},()=>e)))}},H(`reqMin`,`req/min`,e=>e.counters.requestsPerMinute),H(`reqDay`,`req/day`,e=>e.counters.requestsPerDay),H(`reqMonth`,`req/month`,e=>e.counters.requestsPerMonth)]}function X(e,t){return`${e}/${t}`}function Z(e){let t=e.indexOf(`/`);if(t===-1)return null;let n=e.slice(0,t),r=e.slice(t+1);return r===``||n!==`mcp`&&n!==`agent`?null:{kind:n,name:r}}function ee(e,t){let n=Z(e);if(n)return{kind:`ref`,ref:X(n.kind,n.name),name:n.name};if(t===null)return{kind:`pending`};let r=t.mcpServers.some(t=>t.name===e),i=t.agents.some(t=>t.name===e);return r&&i?{kind:`notice`,message:`"${e}" matches both an MCP server and an agent — use "mcp/${e}" or "agent/${e}" to pick one.`}:r?{kind:`ref`,ref:X(`mcp`,e),name:e}:i?{kind:`ref`,ref:X(`agent`,e),name:e}:{kind:`notice`,message:`No MCP server or agent named "${e}" is configured.`}}function Q(e){let t=e.indexOf(`/`);if(t===-1)return{kind:``,target:``,caller:e};let n=e.slice(0,t),r=e.slice(t+1),i=r.indexOf(`/`);return i===-1?{kind:n,target:r,caller:``}:{kind:n,target:r.slice(0,i),caller:r.slice(i+1)}}function te(e){let t=[];return e&&t.push({id:`target`,header:`Target`,accessorFn:e=>{let t=Q(e.id);return`${t.kind}/${t.target}`},cell:({row:e})=>{let t=Q(e.original.id);return i(`span`,{class:`font-mono text-xs text-muted-foreground`},`${t.kind}/${t.target}`)}}),t.push({id:`caller`,header:`Caller`,accessorFn:e=>Q(e.id).caller||e.id,cell:({row:e})=>{let t=Q(e.original.id).caller;return i(`span`,{class:`font-medium`},t||e.original.id)}}),t.push({id:`requests`,header:`Requests`,meta:{align:`right`},accessorFn:e=>e.values.req??0,cell:({row:e})=>i(R,{value:e.original.values.req??0})}),t}var $=l({__name:`TargetCallers`,props:{target:{},title:{},limit:{default:10}},setup(r){let i=r,a=k(),l=S([]),f=S(!1),m=S(!1),_=S(``),b=0;async function w(){let e=++b;f.value=!0,l.value=[],m.value=!1,_.value=``;try{let{window:t,span:n}=d(a.window,a.span),r=await u(p({kind:`targetcaller`,window:t,span:n,metrics:[`req`],limit:i.limit,target:i.target}));if(e!==b)return;l.value=r.rows,m.value=!0}catch(t){if(e!==b)return;_.value=t instanceof Error?t.message:String(t)}finally{e===b&&(f.value=!1)}}e([()=>i.target,()=>a.window,()=>a.span],()=>void w(),{immediate:!0});let D=v(()=>te(!i.target)),O=v(()=>j({loading:f.value,hasData:m.value,error:_.value}));return(e,i)=>(x(),C(h(c),null,{default:n(()=>[g(h(t),null,{default:n(()=>[g(h(o),null,{default:n(()=>[y(s(r.title),1)]),_:1}),g(h(E),null,{default:n(()=>[...i[0]||=[y(`Ranked by requests, most recent day/month window available for the current range.`,-1)]]),_:1})]),_:1}),g(h(T),{class:`flex flex-col gap-3`},{default:n(()=>[g(V,{window:h(a).window,span:h(a).span},null,8,[`window`,`span`]),O.value===`skeleton`?(x(),C(I,{key:0,rows:5,cols:D.value.length},null,8,[`cols`])):O.value===`error`?(x(),C(A,{key:1,message:_.value,"on-retry":w},null,8,[`message`])):(x(),C(L,{key:2,columns:D.value,data:l.value,"empty-message":`no callers recorded in this window`},null,8,[`columns`,`data`]))]),_:1})]),_:1}))}}),ne={class:`flex flex-col gap-6`},re=l({__name:`TargetsView`,emits:[`select`],setup(e,{emit:i}){let s=m(),l=v(()=>s.targets),u=i;function d(e){return t=>u(`select`,X(e,t.name),t.name)}let{query:p,normalized:_,hasQuery:b}=B();function S(e){return e.name.toLowerCase().includes(_.value)}let w=v(()=>{let e=l.value?.mcpServers??[];return b.value?e.filter(S):e}),D=v(()=>{let e=l.value?.agents??[];return b.value?e.filter(S):e});function O(e,t){return e?b.value&&t===0?`no targets match "${p.value}"`:`none`:`none configured`}let k=v(()=>O(l.value?.mcpServers.length??0,w.value.length)),M=v(()=>O(l.value?.agents.length??0,D.value.length)),N=v(()=>j({loading:!0,hasData:s.targets!==null,error:s.error})),P=v(()=>N.value===`ready`&&(l.value?.mcpServers.length??0)===0&&(l.value?.agents.length??0)===0),R=Y(d(`mcp`)),V=Y(d(`agent`));return(e,i)=>(x(),f(`div`,ne,[g(z,{modelValue:h(p),"onUpdate:modelValue":i[0]||=e=>a(p)?p.value=e:null,placeholder:`Filter MCP servers or agents`,class:`max-w-sm`},null,8,[`modelValue`]),P.value?(x(),C(h(c),{key:0},{default:n(()=>[g(h(T),null,{default:n(()=>[g(F,{title:`No MCP servers or agents configured.`,description:`Add an mcpServers or agents entry to the middleware config to see them here.`})]),_:1})]),_:1})):(x(),f(r,{key:1},[g(h(c),null,{default:n(()=>[g(h(t),null,{default:n(()=>[g(h(o),null,{default:n(()=>[...i[1]||=[y(`MCP servers`,-1)]]),_:1}),g(h(E),null,{default:n(()=>[...i[2]||=[y(` Configured MCP proxy targets, the groups allowed to reach them, and their request counters. Click a name to see its callers. `,-1)]]),_:1})]),_:1}),g(h(T),null,{default:n(()=>[N.value===`skeleton`?(x(),C(I,{key:0,rows:3,cols:h(R).length},null,8,[`cols`])):N.value===`error`?(x(),C(A,{key:1,message:h(s).error},null,8,[`message`])):(x(),C(L,{key:2,columns:h(R),data:w.value,"empty-message":k.value},null,8,[`columns`,`data`,`empty-message`]))]),_:1})]),_:1}),g(h(c),null,{default:n(()=>[g(h(t),null,{default:n(()=>[g(h(o),null,{default:n(()=>[...i[3]||=[y(`Agents`,-1)]]),_:1}),g(h(E),null,{default:n(()=>[...i[4]||=[y(` Configured A2A agent proxy targets, the groups allowed to reach them, and their request counters. Click a name to see its callers. `,-1)]]),_:1})]),_:1}),g(h(T),null,{default:n(()=>[N.value===`skeleton`?(x(),C(I,{key:0,rows:3,cols:h(V).length},null,8,[`cols`])):N.value===`error`?(x(),C(A,{key:1,message:h(s).error},null,8,[`message`])):(x(),C(L,{key:2,columns:h(V),data:D.value,"empty-message":M.value},null,8,[`columns`,`data`,`empty-message`]))]),_:1})]),_:1})],64))]))}}),ie={class:`flex flex-col gap-6`},ae=l({__name:`TargetsPage`,setup(e){let t=b(),r=m(),i=v(()=>t.params.target??``),a=v(()=>i.value===``?null:ee(i.value,r.targets)),o=_({}),c=v(()=>{let e=a.value;return o[i.value]??(e?.kind===`ref`?e.name:i.value)});function l(e,n){o[e]=n,t.goTo(`targets`,{...t.params,target:e})}return(e,t)=>(x(),f(`div`,ie,[g(re,{onSelect:l}),a.value?.kind===`ref`?(x(),C($,{key:0,target:a.value.ref,title:`Callers of ${c.value}`},null,8,[`target`,`title`])):a.value?.kind===`notice`?(x(),C(h(D),{key:1,variant:`destructive`},{default:n(()=>[g(h(O),null,{default:n(()=>[y(s(a.value.message),1)]),_:1})]),_:1})):w(``,!0),g($,{title:`Top callers, across every target`})]))}});export{ae as default};",
		),
	},
	"TimeSeriesChart-BFcT6woA.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{Ar as e,Kn as t,On as n,Si as r,Sr as i,Un as a,Xn as o,Yr as s,_n as c,an as l,cn as u,di as d,er as f,gi as p,hn as m,in as h,li as g,nr as _,oi as v,t as y}from"./Skeleton-B0ziB6Od.js";import{c as b}from"./badge-DUiBTDyA.js";var x={class:`h-72 w-full`},S=c({__name:`SkeletonChart`,setup(e){return(e,t)=>(_(),u(`div`,x,[m(p(y),{class:`h-full w-full`})]))}});function C(e){return e+.5|0}var w=(e,t,n)=>Math.max(Math.min(e,n),t);function T(e){return w(C(e*2.55),0,255)}function E(e){return w(C(e*255),0,255)}function D(e){return w(C(e/2.55)/100,0,1)}function ee(e){return w(C(e*100),0,100)}var O={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},te=[...`0123456789ABCDEF`],ne=e=>te[e&15],re=e=>te[(e&240)>>4]+te[e&15],ie=e=>(e&240)>>4==(e&15),ae=e=>ie(e.r)&&ie(e.g)&&ie(e.b)&&ie(e.a);function oe(e){var t=e.length,n;return e[0]===`#`&&(t===4||t===5?n={r:255&O[e[1]]*17,g:255&O[e[2]]*17,b:255&O[e[3]]*17,a:t===5?O[e[4]]*17:255}:(t===7||t===9)&&(n={r:O[e[1]]<<4|O[e[2]],g:O[e[3]]<<4|O[e[4]],b:O[e[5]]<<4|O[e[6]],a:t===9?O[e[7]]<<4|O[e[8]]:255})),n}var se=(e,t)=>e<255?t(e):``;function ce(e){var t=ae(e)?ne:re;return e?`#`+t(e.r)+t(e.g)+t(e.b)+se(e.a,t):void 0}var le=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function ue(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 de(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 fe(e,t,n){let r=ue(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 pe(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 me(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=pe(t,n,r,l,i),s=s*60+.5),[s|0,c||0,o]}function he(e,t,n,r){return(Array.isArray(t)?e(t[0],t[1],t[2]):e(t,n,r)).map(E)}function ge(e,t,n){return he(ue,e,t,n)}function _e(e,t,n){return he(fe,e,t,n)}function ve(e,t,n){return he(de,e,t,n)}function ye(e){return(e%360+360)%360}function be(e){let t=le.exec(e),n=255,r;if(!t)return;t[5]!==r&&(n=t[6]?T(+t[5]):E(+t[5]));let i=ye(+t[2]),a=t[3]/100,o=t[4]/100;return r=t[1]===`hwb`?_e(i,a,o):t[1]===`hsv`?ve(i,a,o):ge(i,a,o),{r:r[0],g:r[1],b:r[2],a:n}}function xe(e,t){var n=me(e);n[0]=ye(n[0]+t),n=ge(n),e.r=n[0],e.g=n[1],e.b=n[2]}function Se(e){if(!e)return;let t=me(e),n=t[0],r=ee(t[1]),i=ee(t[2]);return e.a<255?`hsla(${n}, ${r}%, ${i}%, ${D(e.a)})`:`hsl(${n}, ${r}%, ${i}%)`}var Ce={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`},we={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 Te(){let e={},t=Object.keys(we),n=Object.keys(Ce),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,Ce[a]);a=parseInt(we[o],16),e[s]=[a>>16&255,a>>8&255,a&255]}return e}var Ee;function De(e){Ee||(Ee=Te(),Ee.transparent=[0,0,0,0]);let t=Ee[e.toLowerCase()];return t&&{r:t[0],g:t[1],b:t[2],a:t.length===4?t[3]:255}}var Oe=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;function ke(e){let t=Oe.exec(e),n=255,r,i,a;if(t){if(t[7]!==r){let e=+t[7];n=t[8]?T(e):w(e*255,0,255)}return r=+t[1],i=+t[3],a=+t[5],r=255&(t[2]?T(r):w(r,0,255)),i=255&(t[4]?T(i):w(i,0,255)),a=255&(t[6]?T(a):w(a,0,255)),{r,g:i,b:a,a:n}}}function Ae(e){return e&&(e.a<255?`rgba(${e.r}, ${e.g}, ${e.b}, ${D(e.a)})`:`rgb(${e.r}, ${e.g}, ${e.b})`)}var je=e=>e<=.0031308?e*12.92:e**(1/2.4)*1.055-.055,Me=e=>e<=.04045?e/12.92:((e+.055)/1.055)**2.4;function Ne(e,t,n){let r=Me(D(e.r)),i=Me(D(e.g)),a=Me(D(e.b));return{r:E(je(r+n*(Me(D(t.r))-r))),g:E(je(i+n*(Me(D(t.g))-i))),b:E(je(a+n*(Me(D(t.b))-a))),a:e.a+n*(t.a-e.a)}}function Pe(e,t,n){if(e){let r=me(e);r[t]=Math.max(0,Math.min(r[t]+r[t]*n,t===0?360:1)),r=ge(r),e.r=r[0],e.g=r[1],e.b=r[2]}}function Fe(e,t){return e&&Object.assign(t||{},e)}function Ie(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=E(e[3]))):(t=Fe(e,{r:0,g:0,b:0,a:1}),t.a=E(t.a)),t}function Le(e){return e.charAt(0)===`r`?ke(e):be(e)}var Re=class e{constructor(t){if(t instanceof e)return t;let n=typeof t,r;n===`object`?r=Ie(t):n===`string`&&(r=oe(t)||De(t)||Le(t)),this._rgb=r,this._valid=!!r}get valid(){return this._valid}get rgb(){var e=Fe(this._rgb);return e&&(e.a=D(e.a)),e}set rgb(e){this._rgb=Ie(e)}rgbString(){return this._valid?Ae(this._rgb):void 0}hexString(){return this._valid?ce(this._rgb):void 0}hslString(){return this._valid?Se(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=Ne(this._rgb,e._rgb,t)),this}clone(){return new e(this.rgb)}alpha(e){return this._rgb.a=E(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=C(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 Pe(this._rgb,2,e),this}darken(e){return Pe(this._rgb,2,-e),this}saturate(e){return Pe(this._rgb,1,e),this}desaturate(e){return Pe(this._rgb,1,-e),this}rotate(e){return xe(this._rgb,e),this}};function k(){}var ze=(()=>{let e=0;return()=>e++})();function A(e){return e==null}function j(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 M(e){return e!==null&&Object.prototype.toString.call(e)===`[object Object]`}function N(e){return(typeof e==`number`||e instanceof Number)&&isFinite(+e)}function P(e,t){return N(e)?e:t}function F(e,t){return e===void 0?t:e}var Be=(e,t)=>typeof e==`string`&&e.endsWith(`%`)?parseFloat(e)/100*t:+e;function I(e,t,n){if(e&&typeof e.call==`function`)return e.apply(n,t)}function L(e,t,n,r){let i,a,o;if(j(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(M(e))for(o=Object.keys(e),a=o.length,i=0;i<a;i++)t.call(n,e[o[i]],o[i])}function Ve(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 He(e){if(j(e))return e.map(He);if(M(e)){let t=Object.create(null),n=Object.keys(e),r=n.length,i=0;for(;i<r;++i)t[n[i]]=He(e[n[i]]);return t}return e}function Ue(e){return[`__proto__`,`prototype`,`constructor`].indexOf(e)===-1}function We(e,t,n,r){if(!Ue(e))return;let i=t[e],a=n[e];M(i)&&M(a)?Ge(i,a,r):t[e]=He(a)}function Ge(e,t,n){let r=j(t)?t:[t],i=r.length;if(!M(e))return e;n||={};let a=n.merger||We,o;for(let t=0;t<i;++t){if(o=r[t],!M(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 Ke(e,t){return Ge(e,t,{merger:qe})}function qe(e,t,n){if(!Ue(e))return;let r=t[e],i=n[e];M(r)&&M(i)?Ke(r,i):Object.prototype.hasOwnProperty.call(t,e)||(t[e]=He(i))}var Je={"":e=>e,x:e=>e.x,y:e=>e.y};function Ye(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 Xe(e){let t=Ye(e);return e=>{for(let n of t){if(n===``)break;e&&=e[n]}return e}}function Ze(e,t){return(Je[t]||(Je[t]=Xe(t)))(e)}function Qe(e){return e.charAt(0).toUpperCase()+e.slice(1)}var $e=e=>e!==void 0,et=e=>typeof e==`function`,tt=(e,t)=>{if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0};function nt(e){return e.type===`mouseup`||e.type===`click`||e.type===`contextmenu`}var R=Math.PI,z=2*R,rt=z+R,it=1/0,at=R/180,B=R/2,ot=R/4,st=R*2/3,ct=Math.log10,lt=Math.sign;function ut(e,t,n){return Math.abs(e-t)<n}function dt(e){let t=Math.round(e);e=ut(e,t,e/1e3)?t:e;let n=10**Math.floor(ct(e)),r=e/n;return(r<=1?1:r<=2?2:r<=5?5:10)*n}function ft(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 pt(e){return typeof e==`symbol`||typeof e==`object`&&!!e&&!(Symbol.toPrimitive in e||`toString`in e||`valueOf`in e)}function mt(e){return!pt(e)&&!isNaN(parseFloat(e))&&isFinite(e)}function ht(e,t){let n=Math.round(e);return n-t<=e&&n+t>=e}function gt(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 _t(e){return R/180*e}function vt(e){return 180/R*e}function yt(e){if(!N(e))return;let t=1,n=0;for(;Math.round(e*t)/t!==e;)t*=10,n++;return n}function bt(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*R&&(a+=z),{angle:a,distance:i}}function xt(e,t){return Math.sqrt((t.x-e.x)**2+(t.y-e.y)**2)}function St(e,t){return(e-t+rt)%z-R}function V(e){return(e%z+z)%z}function Ct(e,t,n,r){let i=V(e),a=V(t),o=V(n),s=V(a-i),c=V(o-i),l=V(i-a),u=V(i-o);return i===a||i===o||r&&a===o||s>c&&l<u}function H(e,t,n){return Math.max(t,Math.min(n,e))}function wt(e){return H(e,-32768,32767)}function Tt(e,t,n,r=1e-6){return e>=Math.min(t,n)-r&&e<=Math.max(t,n)+r}function Et(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 Dt=(e,t,n,r)=>Et(e,n,r?r=>{let i=e[r][t];return i<n||i===n&&e[r+1][t]===n}:r=>e[r][t]<n),Ot=(e,t,n)=>Et(e,n,r=>e[r][t]>=n);function kt(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 At=[`push`,`pop`,`shift`,`splice`,`unshift`];function jt(e,t){if(e._chartjs){e._chartjs.listeners.push(t);return}Object.defineProperty(e,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[t]}}),At.forEach(t=>{let n=`_onData`+Qe(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 Mt(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)&&(At.forEach(t=>{delete e[t]}),delete e._chartjs)}function Nt(e){let t=new Set(e);return t.size===e.length?e:Array.from(t)}var Pt=function(){return typeof window>`u`?function(e){return e()}:window.requestAnimationFrame}();function Ft(e,t){let n=[],r=!1;return function(...i){n=i,r||(r=!0,Pt.call(window,()=>{r=!1,e.apply(t,n)}))}}function It(e,t){let n;return function(...r){return t?(clearTimeout(n),n=setTimeout(e,t,r)):e.apply(this,r),t}}var Lt=e=>e===`start`?`left`:e===`end`?`right`:`center`,U=(e,t,n)=>e===`start`?t:e===`end`?n:(t+n)/2,Rt=(e,t,n,r)=>e===(r?`left`:`right`)?n:e===`center`?(t+n)/2:t;function zt(e,t,n){let r=t.length,i=0,a=r;if(e._sorted){let{iScale:o,vScale:s,_parsed:c}=e,l=e.dataset&&e.dataset.options?e.dataset.options.spanGaps:null,u=o.axis,{min:d,max:f,minDefined:p,maxDefined:m}=o.getUserBounds();if(p){if(i=Math.min(Dt(c,u,d).lo,n?r:Dt(t,u,o.getPixelForValue(d)).lo),l){let e=c.slice(0,i+1).reverse().findIndex(e=>!A(e[s.axis]));i-=Math.max(0,e)}i=H(i,0,r-1)}if(m){let e=Math.max(Dt(c,o.axis,f,!0).hi+1,n?0:Dt(t,u,o.getPixelForValue(f),!0).hi+1);if(l){let t=c.slice(e-1).findIndex(e=>!A(e[s.axis]));e+=Math.max(0,t)}a=H(e,i,r)-i}else a=r-i}return{start:i,count:a}}function Bt(e){let{xScale:t,yScale:n,_scaleRanges:r}=e,i={xmin:t.min,xmax:t.max,ymin:n.min,ymax:n.max};if(!r)return e._scaleRanges=i,!0;let a=r.xmin!==t.min||r.xmax!==t.max||r.ymin!==n.min||r.ymax!==n.max;return Object.assign(r,i),a}var Vt=e=>e===0||e===1,Ht=(e,t,n)=>-(2**(10*--e)*Math.sin((e-t)*z/n)),Ut=(e,t,n)=>2**(-10*e)*Math.sin((e-t)*z/n)+1,Wt={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*B)+1,easeOutSine:e=>Math.sin(e*B),easeInOutSine:e=>-.5*(Math.cos(R*e)-1),easeInExpo:e=>e===0?0:2**(10*(e-1)),easeOutExpo:e=>e===1?1:-(2**(-10*e))+1,easeInOutExpo:e=>Vt(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=>Vt(e)?e:Ht(e,.075,.3),easeOutElastic:e=>Vt(e)?e:Ut(e,.075,.3),easeInOutElastic(e){let t=.1125,n=.45;return Vt(e)?e:e<.5?.5*Ht(e*2,t,n):.5+.5*Ut(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-Wt.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?Wt.easeInBounce(e*2)*.5:Wt.easeOutBounce(e*2-1)*.5+.5};function Gt(e){if(e&&typeof e==`object`){let t=e.toString();return t===`[object CanvasPattern]`||t===`[object CanvasGradient]`}return!1}function Kt(e){return Gt(e)?e:new Re(e)}function qt(e){return Gt(e)?e:new Re(e).saturate(.5).darken(.1).hexString()}var Jt=[`x`,`y`,`borderWidth`,`radius`,`tension`],Yt=[`color`,`borderColor`,`backgroundColor`];function Xt(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:Yt},numbers:{type:`number`,properties:Jt}}),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 Zt(e){e.set(`layout`,{autoPadding:!0,padding:{top:0,right:0,bottom:0,left:0}})}var Qt=new Map;function $t(e,t){t||={};let n=e+JSON.stringify(t),r=Qt.get(n);return r||(r=new Intl.NumberFormat(e,t),Qt.set(n,r)),r}function en(e,t,n){return $t(t,n).format(e)}var tn={values(e){return j(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=nn(e,n)}let o=ct(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),en(e,r,c)},logarithmic(e,t,n){if(e===0)return`0`;let r=n[t].significand||e/10**Math.floor(ct(e));return[1,2,3,5,10,15].includes(r)||t>.8*n.length?tn.numeric.call(this,e,t,n):``}};function nn(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 rn={formatters:tn};function an(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:rn.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 on=Object.create(null),sn=Object.create(null);function cn(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 ln(e,t,n){return typeof t==`string`?Ge(cn(e,t),n):Ge(cn(e,``),t)}var W=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)=>qt(t.backgroundColor),this.hoverBorderColor=(e,t)=>qt(t.borderColor),this.hoverColor=(e,t)=>qt(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 ln(this,e,t)}get(e){return cn(this,e)}describe(e,t){return ln(sn,e,t)}override(e,t){return ln(on,e,t)}route(e,t,n,r){let i=cn(this,e),a=cn(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 M(e)?Object.assign({},t,e):F(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}},[Xt,Zt,an]);function un(e){return!e||A(e.size)||A(e.family)?null:(e.style?e.style+` `:``)+(e.weight?e.weight+` `:``)+e.size+`px `+e.family}function dn(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 fn(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&&!j(d))o=dn(e,i,a,o,d);else if(j(d))for(l=0,u=d.length;l<u;l++)f=d[l],f!=null&&!j(f)&&(o=dn(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 pn(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 mn(e,t){!t&&!e||(t||=e.getContext(`2d`),t.save(),t.resetTransform(),t.clearRect(0,0,e.width,e.height),t.restore())}function hn(e,t,n,r){gn(e,t,n,r,null)}function gn(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)*at;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,z):e.arc(n,r,h,0,z),e.closePath();break;case`triangle`:u=i?i/2:h,e.moveTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=st,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=st,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+ot)*c,d=Math.cos(g+ot)*(i?i/2-l:c),s=Math.sin(g+ot)*c,f=Math.sin(g+ot)*(i?i/2-l:c),e.arc(n-d,r-s,l,g-R,g-B),e.arc(n+f,r-o,l,g-B,g),e.arc(n+d,r+s,l,g,g+B),e.arc(n-f,r+o,l,g+B,g+R),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+=ot;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+=ot;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+=ot,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 G(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 _n(e,t){e.save(),e.beginPath(),e.rect(t.left,t.top,t.right-t.left,t.bottom-t.top),e.clip()}function vn(e){e.restore()}function yn(e,t,n,r,i){if(!t)return e.lineTo(n.x,n.y);if(i===`middle`){let r=(t.x+n.x)/2;e.lineTo(r,t.y),e.lineTo(r,n.y)}else i===`after`==!!r?e.lineTo(n.x,t.y):e.lineTo(t.x,n.y);e.lineTo(n.x,n.y)}function bn(e,t,n,r){if(!t)return e.lineTo(n.x,n.y);e.bezierCurveTo(r?t.cp1x:t.cp2x,r?t.cp1y:t.cp2y,r?n.cp2x:n.cp1x,r?n.cp2y:n.cp1y,n.x,n.y)}function xn(e,t){t.translation&&e.translate(t.translation[0],t.translation[1]),A(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 Sn(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 Cn(e,t){let n=e.fillStyle;e.fillStyle=t.color,e.fillRect(t.left,t.top,t.width,t.height),e.fillStyle=n}function wn(e,t,n,r,i,a={}){let o=j(t)?t:[t],s=a.strokeWidth>0&&a.strokeColor!==``,c,l;for(e.save(),e.font=i.string,xn(e,a),c=0;c<o.length;++c)l=o[c],a.backdrop&&Cn(e,a.backdrop),s&&(a.strokeColor&&(e.strokeStyle=a.strokeColor),A(a.strokeWidth)||(e.lineWidth=a.strokeWidth),e.strokeText(l,n,r,a.maxWidth)),e.fillText(l,n,r,a.maxWidth),Sn(e,n,r,l,a),r+=Number(i.lineHeight);e.restore()}function Tn(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*R,R,!0),e.lineTo(n,r+a-o.bottomLeft),e.arc(n+o.bottomLeft,r+a-o.bottomLeft,o.bottomLeft,R,B,!0),e.lineTo(n+i-o.bottomRight,r+a),e.arc(n+i-o.bottomRight,r+a-o.bottomRight,o.bottomRight,B,0,!0),e.lineTo(n+i,r+o.topRight),e.arc(n+i-o.topRight,r+o.topRight,o.topRight,0,-B,!0),e.lineTo(n+o.topLeft,r)}var En=/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/,Dn=/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;function On(e,t){let n=(``+e).match(En);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 kn=e=>+e||0;function An(e,t){let n={},r=M(t),i=r?Object.keys(t):t,a=M(e)?r?n=>F(e[n],e[t[n]]):t=>e[t]:()=>e;for(let e of i)n[e]=kn(a(e));return n}function jn(e){return An(e,{top:`y`,right:`x`,bottom:`y`,left:`x`})}function Mn(e){return An(e,[`topLeft`,`topRight`,`bottomLeft`,`bottomRight`])}function K(e){let t=jn(e);return t.width=t.left+t.right,t.height=t.top+t.bottom,t}function q(e,t){e||={},t||=W.font;let n=F(e.size,t.size);typeof n==`string`&&(n=parseInt(n,10));let r=F(e.style,t.style);r&&!(``+r).match(Dn)&&(console.warn(`Invalid font style specified: "`+r+`"`),r=void 0);let i={family:F(e.family,t.family),lineHeight:On(F(e.lineHeight,t.lineHeight),n),size:n,style:r,weight:F(e.weight,t.weight),string:``};return i.string=un(i),i}function Nn(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&&j(s)&&(s=s[n%s.length],i=!1),s!==void 0))return r&&!i&&(r.cacheable=!1),s}function Pn(e,t,n){let{min:r,max:i}=e,a=Be(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 Fn(e,t){return Object.assign(Object.create(e),t)}function In(e,t=[``],n,r,i=()=>e[0]){let a=n||e;return r===void 0&&(r=Qn(`_fallback`,e)),new Proxy({[Symbol.toStringTag]:`Object`,_cacheable:!0,_scopes:e,_rootScopes:a,_fallback:r,_getTarget:i,override:n=>In([n,...e],t,a,r)},{deleteProperty(t,n){return delete t[n],delete t._keys,delete e[0][n],!0},get(n,r){return Vn(n,r,()=>Zn(r,t,e,n))},getOwnPropertyDescriptor(e,t){return Reflect.getOwnPropertyDescriptor(e._scopes[0],t)},getPrototypeOf(){return Reflect.getPrototypeOf(e[0])},has(e,t){return $n(e).includes(t)},ownKeys(e){return $n(e)},set(e,t,n){let r=e._storage||=i();return e[t]=r[t]=n,delete e._keys,!0}})}function Ln(e,t,n,r){let i={_cacheable:!1,_proxy:e,_context:t,_subProxy:n,_stack:new Set,_descriptors:Rn(e,r),setContext:t=>Ln(e,t,n,r),override:i=>Ln(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 Vn(e,t,()=>Hn(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 Rn(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:et(n)?n:()=>n,isIndexable:et(r)?r:()=>r}}var zn=(e,t)=>e?e+Qe(t):t,Bn=(e,t)=>M(t)&&e!==`adapters`&&(Object.getPrototypeOf(t)===null||t.constructor===Object);function Vn(e,t,n){if(Object.prototype.hasOwnProperty.call(e,t)||t===`constructor`)return e[t];let r=n();return e[t]=r,r}function Hn(e,t,n){let{_proxy:r,_context:i,_subProxy:a,_descriptors:o}=e,s=r[t];return et(s)&&o.isScriptable(t)&&(s=Un(t,s,e,n)),j(s)&&s.length&&(s=Wn(t,s,e,o.isIndexable)),Bn(t,s)&&(s=Ln(s,i,a&&a[t],o)),s}function Un(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),Bn(e,c)&&(c=Jn(i._scopes,i,e,c)),c}function Wn(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(M(t[0])){let n=t,r=i._scopes.filter(e=>e!==n);t=[];for(let c of n){let n=Jn(r,i,e,c);t.push(Ln(n,a,o&&o[e],s))}}return t}function Gn(e,t,n){return et(e)?e(t,n):e}var Kn=(e,t)=>e===!0?t:typeof e==`string`?Ze(t,e):void 0;function qn(e,t,n,r,i){for(let a of t){let t=Kn(n,a);if(t){e.add(t);let a=Gn(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 Jn(e,t,n,r){let i=t._rootScopes,a=Gn(t._fallback,n,r),o=[...e,...i],s=new Set;s.add(r);let c=Yn(s,o,n,a||n,r);return c===null||a!==void 0&&a!==n&&(c=Yn(s,o,a,c,r),c===null)?!1:In(Array.from(s),[``],i,a,()=>Xn(t,n,r))}function Yn(e,t,n,r,i){for(;n;)n=qn(e,t,n,r,i);return n}function Xn(e,t,n){let r=e._getTarget();t in r||(r[t]={});let i=r[t];return j(i)&&M(n)?n:i||{}}function Zn(e,t,n,r){let i;for(let a of t)if(i=Qn(zn(a,e),n),i!==void 0)return Bn(e,i)?Jn(n,r,e,i):i}function Qn(e,t){for(let n of t){if(!n)continue;let t=n[e];if(t!==void 0)return t}}function $n(e){let t=e._keys;return t||=e._keys=er(e._scopes),t}function er(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)}var tr=2**-52||1e-14,nr=(e,t)=>t<e.length&&!e[t].skip&&e[t],rr=e=>e===`x`?`y`:`x`;function ir(e,t,n,r){let i=e.skip?t:e,a=t,o=n.skip?t:n,s=xt(a,i),c=xt(o,a),l=s/(s+c),u=c/(s+c);l=isNaN(l)?0:l,u=isNaN(u)?0:u;let d=r*l,f=r*u;return{previous:{x:a.x-d*(o.x-i.x),y:a.y-d*(o.y-i.y)},next:{x:a.x+f*(o.x-i.x),y:a.y+f*(o.y-i.y)}}}function ar(e,t,n){let r=e.length,i,a,o,s,c,l=nr(e,0);for(let u=0;u<r-1;++u)if(c=l,l=nr(e,u+1),!(!c||!l)){if(ut(t[u],0,tr)){n[u]=n[u+1]=0;continue}i=n[u]/t[u],a=n[u+1]/t[u],s=i**2+a**2,!(s<=9)&&(o=3/Math.sqrt(s),n[u]=i*o*t[u],n[u+1]=a*o*t[u])}}function or(e,t,n=`x`){let r=rr(n),i=e.length,a,o,s,c=nr(e,0);for(let l=0;l<i;++l){if(o=s,s=c,c=nr(e,l+1),!s)continue;let i=s[n],u=s[r];o&&(a=(i-o[n])/3,s[`cp1${n}`]=i-a,s[`cp1${r}`]=u-a*t[l]),c&&(a=(c[n]-i)/3,s[`cp2${n}`]=i+a,s[`cp2${r}`]=u+a*t[l])}}function sr(e,t=`x`){let n=rr(t),r=e.length,i=Array(r).fill(0),a=Array(r),o,s,c,l=nr(e,0);for(o=0;o<r;++o)if(s=c,c=l,l=nr(e,o+1),c){if(l){let e=l[t]-c[t];i[o]=e===0?0:(l[n]-c[n])/e}a[o]=s?l?lt(i[o-1])===lt(i[o])?(i[o-1]+i[o])/2:0:i[o-1]:i[o]}ar(e,i,a),or(e,a,t)}function cr(e,t,n){return Math.max(Math.min(e,n),t)}function lr(e,t){let n,r,i,a,o,s=G(e[0],t);for(n=0,r=e.length;n<r;++n)o=a,a=s,s=n<r-1&&G(e[n+1],t),a&&(i=e[n],o&&(i.cp1x=cr(i.cp1x,t.left,t.right),i.cp1y=cr(i.cp1y,t.top,t.bottom)),s&&(i.cp2x=cr(i.cp2x,t.left,t.right),i.cp2y=cr(i.cp2y,t.top,t.bottom)))}function ur(e,t,n,r,i){let a,o,s,c;if(t.spanGaps&&(e=e.filter(e=>!e.skip)),t.cubicInterpolationMode===`monotone`)sr(e,i);else{let n=r?e[e.length-1]:e[0];for(a=0,o=e.length;a<o;++a)s=e[a],c=ir(n,s,e[Math.min(a+1,o-+!r)%o],t.tension),s.cp1x=c.previous.x,s.cp1y=c.previous.y,s.cp2x=c.next.x,s.cp2y=c.next.y,n=s}t.capBezierPoints&&lr(e,n)}function dr(){return typeof window<`u`&&typeof document<`u`}function fr(e){let t=e.parentNode;return t&&t.toString()===`[object ShadowRoot]`&&(t=t.host),t}function pr(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 mr=e=>e.ownerDocument.defaultView.getComputedStyle(e,null);function hr(e,t){return mr(e).getPropertyValue(t)}var gr=[`top`,`right`,`bottom`,`left`];function _r(e,t,n){let r={};n=n?`-`+n:``;for(let i=0;i<4;i++){let a=gr[i];r[a]=parseFloat(e[t+`-`+a+n])||0}return r.width=r.left+r.right,r.height=r.top+r.bottom,r}var vr=(e,t,n)=>(e>0||t>0)&&(!n||!n.shadowRoot);function yr(e,t){let n=e.touches,r=n&&n.length?n[0]:e,{offsetX:i,offsetY:a}=r,o=!1,s,c;if(vr(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 br(e,t){if(`native`in e)return e;let{canvas:n,currentDevicePixelRatio:r}=t,i=mr(n),a=i.boxSizing===`border-box`,o=_r(i,`padding`),s=_r(i,`border`,`width`),{x:c,y:l,box:u}=yr(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 xr(e,t,n){let r,i;if(t===void 0||n===void 0){let a=e&&fr(e);if(!a)t=e.clientWidth,n=e.clientHeight;else{let e=a.getBoundingClientRect(),o=mr(a),s=_r(o,`border`,`width`),c=_r(o,`padding`);t=e.width-c.width-s.width,n=e.height-c.height-s.height,r=pr(o.maxWidth,a,`clientWidth`),i=pr(o.maxHeight,a,`clientHeight`)}}return{width:t,height:n,maxWidth:r||it,maxHeight:i||it}}var Sr=e=>Math.round(e*10)/10;function Cr(e,t,n,r){let i=mr(e),a=_r(i,`margin`),o=pr(i.maxWidth,e,`clientWidth`)||it,s=pr(i.maxHeight,e,`clientHeight`)||it,c=xr(e,t,n),{width:l,height:u}=c;if(i.boxSizing===`content-box`){let e=_r(i,`border`,`width`),t=_r(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=Sr(Math.min(l,o,c.maxWidth)),u=Sr(Math.min(u,s,c.maxHeight)),l&&!u&&(u=Sr(l/2)),(t!==void 0||n!==void 0)&&r&&c.height&&u>c.height&&(u=c.height,l=Sr(Math.floor(u*r))),{width:l,height:u}}function wr(e,t,n){let r=t||1,i=Sr(e.height*r),a=Sr(e.width*r);e.height=Sr(e.height),e.width=Sr(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 Tr=function(){let e=!1;try{let t={get passive(){return e=!0,!1}};dr()&&(window.addEventListener(`test`,null,t),window.removeEventListener(`test`,null,t))}catch{}return e}();function Er(e,t){let n=hr(e,t),r=n&&n.match(/^(\d+)(\.\d+)?px$/);return r?+r[1]:void 0}function Dr(e,t,n,r){return{x:e.x+n*(t.x-e.x),y:e.y+n*(t.y-e.y)}}function Or(e,t,n,r){return{x:e.x+n*(t.x-e.x),y:r===`middle`?n<.5?e.y:t.y:r===`after`?n<1?e.y:t.y:n>0?t.y:e.y}}function kr(e,t,n,r){let i={x:e.cp2x,y:e.cp2y},a={x:t.cp1x,y:t.cp1y},o=Dr(e,i,n),s=Dr(i,a,n),c=Dr(a,t,n);return Dr(Dr(o,s,n),Dr(s,c,n),n)}var Ar=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}}},jr=function(){return{x(e){return e},setWidth(e){},textAlign(e){return e},xPlus(e,t){return e+t},leftForLtr(e,t){return e}}};function Mr(e,t,n){return e?Ar(t,n):jr()}function Nr(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 Pr(e,t){t!==void 0&&(delete e.prevTextDirection,e.canvas.style.setProperty(`direction`,t[0],t[1]))}function Fr(e){return e===`angle`?{between:Ct,compare:St,normalize:V}:{between:Tt,compare:(e,t)=>e-t,normalize:e=>e}}function Ir({start:e,end:t,count:n,loop:r,style:i}){return{start:e%n,end:t%n,loop:r&&(t-e+1)%n===0,style:i}}function Lr(e,t,n){let{property:r,start:i,end:a}=n,{between:o,normalize:s}=Fr(r),c=t.length,{start:l,end:u,loop:d}=e,f,p;if(d){for(l+=c,u+=c,f=0,p=c;f<p&&o(s(t[l%c][r]),i,a);++f)l--,u--;l%=c,u%=c}return u<l&&(u+=c),{start:l,end:u,loop:d,style:e.style}}function Rr(e,t,n){if(!n)return[e];let{property:r,start:i,end:a}=n,o=t.length,{compare:s,between:c,normalize:l}=Fr(r),{start:u,end:d,loop:f,style:p}=Lr(e,t,n),m=[],h=!1,g=null,_,v,y,b=()=>c(i,y,_)&&s(i,y)!==0,x=()=>s(a,_)===0||c(a,y,_),S=()=>h||b(),C=()=>!h||x();for(let e=u,n=u;e<=d;++e)v=t[e%o],!v.skip&&(_=l(v[r]),_!==y&&(h=c(_,i,a),g===null&&S()&&(g=s(_,i)===0?e:n),g!==null&&C()&&(m.push(Ir({start:g,end:e,loop:f,count:o,style:p})),g=null),n=e,y=_));return g!==null&&m.push(Ir({start:g,end:d,loop:f,count:o,style:p})),m}function zr(e,t){let n=[],r=e.segments;for(let i=0;i<r.length;i++){let a=Rr(r[i],e.points,t);a.length&&n.push(...a)}return n}function Br(e,t,n,r){let i=0,a=t-1;if(n&&!r)for(;i<t&&!e[i].skip;)i++;for(;i<t&&e[i].skip;)i++;for(i%=t,n&&(a+=i);a>i&&e[a%t].skip;)a--;return a%=t,{start:i,end:a}}function Vr(e,t,n,r){let i=e.length,a=[],o=t,s=e[t],c;for(c=t+1;c<=n;++c){let n=e[c%i];n.skip||n.stop?s.skip||(r=!1,a.push({start:t%i,end:(c-1)%i,loop:r}),t=o=n.stop?c:null):(o=c,s.skip&&(t=c)),s=n}return o!==null&&a.push({start:t%i,end:o%i,loop:r}),a}function Hr(e,t){let n=e.points,r=e.options.spanGaps,i=n.length;if(!i)return[];let a=!!e._loop,{start:o,end:s}=Br(n,i,a,r);return r===!0?Ur(e,[{start:o,end:s,loop:a}],n,t):Ur(e,Vr(n,o,s<o?s+i:s,!!e._fullLoop&&o===0&&s===i-1),n,t)}function Ur(e,t,n,r){return!r||!r.setContext||!n?t:Wr(e,t,n,r)}function Wr(e,t,n,r){let i=e._chart.getContext(),a=Gr(e.options),{_datasetIndex:o,options:{spanGaps:s}}=e,c=n.length,l=[],u=a,d=t[0].start,f=d;function p(e,t,r,i){let a=s?-1:1;if(e!==t){for(e+=c;n[e%c].skip;)e-=a;for(;n[t%c].skip;)t+=a;e%c!==t%c&&(l.push({start:e%c,end:t%c,loop:r,style:i}),u=i,d=t%c)}}for(let e of t){d=s?d:e.start;let t=n[d%c],a;for(f=d+1;f<=e.end;f++){let s=n[f%c];a=Gr(r.setContext(Fn(i,{type:`segment`,p0:t,p1:s,p0DataIndex:(f-1)%c,p1DataIndex:f%c,datasetIndex:o}))),Kr(a,u)&&p(d,f-1,e.loop,u),t=s,u=a}d<f-1&&p(d,f-1,e.loop,u)}return l}function Gr(e){return{backgroundColor:e.backgroundColor,borderCapStyle:e.borderCapStyle,borderDash:e.borderDash,borderDashOffset:e.borderDashOffset,borderJoinStyle:e.borderJoinStyle,borderWidth:e.borderWidth,borderColor:e.borderColor}}function Kr(e,t){if(!t)return!1;let n=[],r=function(e,t){return Gt(t)?(n.includes(t)||n.push(t),n.indexOf(t)):t};return JSON.stringify(e,r)!==JSON.stringify(t,r)}function qr(e,t,n){return e.options.clip?e[n]:t[n]}function Jr(e,t){let{xScale:n,yScale:r}=e;return n&&r?{left:qr(n,t,`left`),right:qr(n,t,`right`),top:qr(r,t,`top`),bottom:qr(r,t,`bottom`)}:t}function Yr(e,t){let n=t._clip;if(n.disabled)return!1;let r=Jr(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 J=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,Pt.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)}},Xr=`transparent`,Zr={boolean(e,t,n){return n>.5?t:e},color(e,t,n){let r=Kt(e||Xr),i=r.valid&&Kt(t||Xr);return i&&i.valid?i.mix(r,n).hexString():t},number(e,t,n){return e+(t-e)*n}},Qr=class{constructor(e,t,n,r){let i=t[n];r=Nn([e.to,r,i,e.from]);let a=Nn([e.from,i,r]);this._active=!0,this._fn=e.fn||Zr[e.type||typeof a],this._easing=Wt[e.easing]||Wt.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=Nn([e.to,t,r,e.from]),this._from=Nn([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]()}},$r=class{constructor(e,t){this._chart=e,this._properties=new Map,this.configure(t)}configure(e){if(!M(e))return;let t=Object.keys(W.animation),n=this._properties;Object.getOwnPropertyNames(e).forEach(r=>{let i=e[r];if(!M(i))return;let a={};for(let e of t)a[e]=i[e];(j(i.properties)&&i.properties||[r]).forEach(e=>{(e===r||!n.has(e))&&n.set(e,a)})})}_animateOptions(e,t){let n=t.options,r=ti(e,n);if(!r)return[];let i=this._createAnimations(r,n);return n.$shared&&ei(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 Qr(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 J.add(this._chart,n),!0}};function ei(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 ti(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 ni(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 ri(e,t,n){if(n===!1)return!1;let r=ni(e,n),i=ni(t,n);return{top:i.end,right:r.end,bottom:i.start,left:r.start}}function ii(e){let t,n,r,i;return M(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 ai(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 oi(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],N(l)&&(a||t===0||lt(t)===lt(l))&&(t+=l)}return!u&&!r.all?0:t}function si(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 ci(e,t){let n=e&&e.options.stacked;return n||n===void 0&&t.stack!==void 0}function li(e,t,n){return`${e.id}.${t.id}.${n.stack||n.type}`}function ui(e){let{min:t,max:n,minDefined:r,maxDefined:i}=e.getUserBounds();return{min:r?t:-1/0,max:i?n:1/0}}function di(e,t,n){let r=e[t]||(e[t]={});return r[n]||(r[n]={})}function fi(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 pi(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=li(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]=di(i,u,a),f[s]=d,f._top=fi(f,o,!0,r.type),f._bottom=fi(f,o,!1,r.type);let m=f._visualValues||(f._visualValues={});m[s]=d}}function mi(e,t){let n=e.scales;return Object.keys(n).filter(e=>n[e].axis===t).shift()}function hi(e,t){return Fn(e,{active:!1,dataset:void 0,datasetIndex:t,index:t,mode:`default`,type:`dataset`})}function gi(e,t,n){return Fn(e,{active:!1,dataIndex:t,parsed:void 0,raw:void 0,element:n,index:t,mode:`default`,type:`data`})}function _i(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 vi=e=>e===`reset`||e===`none`,yi=(e,t)=>t?e:Object.assign({},e),bi=(e,t,n)=>e&&!t.hidden&&t._stacked&&{keys:ai(n,!0),values:null},xi=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=ci(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&&_i(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=F(n.xAxisID,mi(e,`x`)),a=t.yAxisID=F(n.yAxisID,mi(e,`y`)),o=t.rAxisID=F(n.rAxisID,mi(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&&Mt(this._data,this),e._stacked&&_i(e)}_dataCheck(){let e=this.getDataset(),t=e.data||=[],n=this._data;if(M(t)){let e=this._cachedMeta;this._data=si(t,e)}else if(n!==t){if(n){Mt(n,this);let e=this._cachedMeta;_i(e),e._parsed=[]}t&&Object.isExtensible(t)&&jt(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=ci(t.vScale,t),t.stack!==n.stack&&(r=!0,_i(t),t.stack=n.stack),this._resyncElements(e),(r||i!==t._stacked)&&(pi(this,t._parsed),t._stacked=ci(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=j(r[e])?this.parseArrayData(n,r,e,t):M(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&&pi(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(Ze(f,o),d),y:a.parse(Ze(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 oi({keys:ai(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=oi(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=bi(t,n,this.chart),c={min:1/0,max:-1/0},{min:l,max:u}=ui(o),d,f;function p(){f=r[d];let t=f[o.axis];return!N(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],N(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=ii(F(this.options.clip,ri(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||=gi(this.getContext(),e,t),i.parsed=this.getParsed(e),i.raw=r.data[e],i.index=i.dataIndex=e}else i=this.$context||=hi(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&&$e(n);if(o)return yi(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(W.elements[e]),p=c.resolveNamedOptions(d,f,()=>this.getContext(n,r,t),u);return p.$shared&&(p.$shared=s,i[a]=Object.freeze(yi(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 $r(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||vi(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){vi(r)?Object.assign(e,n):this._resolveAnimations(t,r).update(e,n)}updateSharedOptions(e,t,n){e&&!vi(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&&_i(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])}},Si=class extends xi{static id=`line`;static defaults={datasetElementType:`line`,dataElementType:`point`,showLine:!0,spanGaps:!1};static overrides={scales:{_index_:{type:`category`},_value_:{type:`linear`}}};initialize(){this.enableOptionSharing=!0,this.supportsDecimation=!0,super.initialize()}update(e){let t=this._cachedMeta,{dataset:n,data:r=[],_dataset:i}=t,a=this.chart._animationsDisabled,{start:o,count:s}=zt(t,r,a);this._drawStart=o,this._drawCount=s,Bt(t)&&(o=0,s=r.length),n._chart=this.chart,n._datasetIndex=this.index,n._decimated=!!i._decimated,n.points=r;let c=this.resolveDatasetElementOptions(e);this.options.showLine||(c.borderWidth=0),c.segment=this.options.segment,this.updateElement(n,void 0,{animated:!a,options:c},e),this.updateElements(r,o,s,e)}updateElements(e,t,n,r){let i=r===`reset`,{iScale:a,vScale:o,_stacked:s,_dataset:c}=this._cachedMeta,{sharedOptions:l,includeOptions:u}=this._getSharedOptions(t,r),d=a.axis,f=o.axis,{spanGaps:p,segment:m}=this.options,h=mt(p)?p:1/0,g=this.chart._animationsDisabled||i||r===`none`,_=t+n,v=e.length,y=t>0&&this.getParsed(t-1);for(let n=0;n<v;++n){let p=e[n],v=g?p:{};if(n<t||n>=_){v.skip=!0;continue}let b=this.getParsed(n),x=A(b[f]),S=v[d]=a.getPixelForValue(b[d],n),C=v[f]=i||x?o.getBasePixel():o.getPixelForValue(s?this.applyStack(o,b,s):b[f],n);v.skip=isNaN(S)||isNaN(C)||x,v.stop=n>0&&Math.abs(b[d]-y[d])>h,m&&(v.parsed=b,v.raw=c.data[n]),u&&(v.options=l||this.resolveDataElementOptions(n,p.active?`active`:r)),g||this.updateElement(p,n,v,r),y=b}}getMaxOverflow(){let e=this._cachedMeta,t=e.dataset,n=t.options&&t.options.borderWidth||0,r=e.data||[];if(!r.length)return n;let i=r[0].size(this.resolveDataElementOptions(0)),a=r[r.length-1].size(this.resolveDataElementOptions(r.length-1));return Math.max(n,i,a)/2}draw(){let e=this._cachedMeta;e.dataset.updateControlPoints(this.chart.chartArea,e.iScale.axis),super.draw()}};function Ci(){throw Error(`This method is not implemented: Check that a complete date adapter is provided.`)}var wi={_date:class e{static override(t){Object.assign(e.prototype,t)}options;constructor(e){this.options=e||{}}init(){}formats(){return Ci()}parse(){return Ci()}format(){return Ci()}add(){return Ci()}diff(){return Ci()}startOf(){return Ci()}endOf(){return Ci()}}};function Ti(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?Ot:Dt;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=>!A(e[t.axis]));r.lo-=Math.max(0,a);let o=n.slice(r.hi).findIndex(e=>!A(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 Ei(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}=Ti(a[e],t,o,i);for(let e=c;e<=l;++e){let t=s[e];t.skip||r(t,n,e)}}}function Di(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 Oi(e,t,n,r,i){let a=[];return!i&&!e.isPointInArea(t)||Ei(e,n,t,function(n,o,s){!i&&!G(n,e.chartArea,0)||n.inRange(t.x,t.y,r)&&a.push({element:n,datasetIndex:o,index:s})},!0),a}function ki(e,t,n,r){let i=[];function a(e,n,a){let{startAngle:o,endAngle:s}=e.getProps([`startAngle`,`endAngle`],r),{angle:c}=bt(e,{x:t.x,y:t.y});Ct(c,o,s)&&i.push({element:e,datasetIndex:n,index:a})}return Ei(e,n,t,a),i}function Ai(e,t,n,r,i,a){let o=[],s=Di(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 Ei(e,n,t,l),o}function ji(e,t,n,r,i,a){return!a&&!e.isPointInArea(t)?[]:n===`r`&&!r?ki(e,t,n,i):Ai(e,t,n,r,i,a)}function Mi(e,t,n,r,i){let a=[],o=n===`x`?`inXRange`:`inYRange`,s=!1;return Ei(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 Ni={evaluateInteractionItems:Ei,modes:{index(e,t,n,r){let i=br(t,e),a=n.axis||`x`,o=n.includeInvisible||!1,s=n.intersect?Oi(e,i,a,r,o):ji(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=br(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1,s=n.intersect?Oi(e,i,a,r,o):ji(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 Oi(e,br(t,e),n.axis||`xy`,r,n.includeInvisible||!1)},nearest(e,t,n,r){let i=br(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1;return ji(e,i,a,n.intersect,r,o)},x(e,t,n,r){return Mi(e,br(t,e),`x`,n.intersect,r)},y(e,t,n,r){return Mi(e,br(t,e),`y`,n.intersect,r)}}},Pi=[`left`,`top`,`right`,`bottom`];function Fi(e,t){return e.filter(e=>e.pos===t)}function Ii(e,t){return e.filter(e=>Pi.indexOf(e.pos)===-1&&e.box.axis===t)}function Li(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 Ri(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 zi(e){let t={};for(let n of e){let{stack:e,pos:r,stackWeight:i}=n;if(!e||!Pi.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 Bi(e,t){let n=zi(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 Vi(e){let t=Ri(e),n=Li(t.filter(e=>e.box.fullSize),!0),r=Li(Fi(t,`left`),!0),i=Li(Fi(t,`right`)),a=Li(Fi(t,`top`),!0),o=Li(Fi(t,`bottom`)),s=Ii(t,`x`),c=Ii(t,`y`);return{fullSize:n,leftAndTop:r.concat(a),rightAndBottom:i.concat(c).concat(o).concat(s),chartArea:Fi(t,`chartArea`),vertical:r.concat(i).concat(c),horizontal:a.concat(o).concat(s)}}function Hi(e,t,n,r){return Math.max(e[n],t[n])+Math.max(e[r],t[r])}function Ui(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 Wi(e,t,n,r){let{pos:i,box:a}=n,o=e.maxPadding;if(!M(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&&Ui(o,a.getPadding());let s=Math.max(0,t.outerWidth-Hi(o,e,`left`,`right`)),c=Math.max(0,t.outerHeight-Hi(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 Gi(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 Ki(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 qi(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,Ki(s.horizontal,t));let{same:o,other:d}=Wi(t,n,s,r);l|=o&&i.length,u||=d,c.fullSize||i.push(s)}return l&&qi(i,t,n,r)||u}function Ji(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 Yi(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;$e(c.start)&&(o=c.start),e.fullSize?Ji(e,i.left,o,n.outerWidth-i.right-i.left,a):Ji(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;$e(c.start)&&(a=c.start),e.fullSize?Ji(e,a,i.top,o,n.outerHeight-i.bottom-i.top):Ji(e,a,t.top+c.placed,o,r),c.start=a,c.placed+=r,a=e.right}}t.x=a,t.y=o}var Xi={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=K(e.options.layout.padding),a=Math.max(t-i.width,0),o=Math.max(n-i.height,0),s=Vi(e.boxes),c=s.vertical,l=s.horizontal;L(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);Ui(f,K(r));let p=Object.assign({maxPadding:f,w:a,h:o,x:i.left,y:i.top},i),m=Bi(c.concat(l),d);qi(s.fullSize,p,d,m),qi(c,p,d,m),qi(l,p,d,m)&&qi(c,p,d,m),Gi(p),Yi(s.leftAndTop,p,d,m),p.x+=p.w,p.y+=p.h,Yi(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},L(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})})}},Zi=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){}},Qi=class extends Zi{acquireContext(e){return e&&e.getContext&&e.getContext(`2d`)||null}updateConfig(e){e.options.animation=!1}},$i=`$chartjs`,ea={touchstart:`mousedown`,touchmove:`mousemove`,touchend:`mouseup`,pointerenter:`mouseenter`,pointerdown:`mousedown`,pointermove:`mousemove`,pointerup:`mouseup`,pointerleave:`mouseout`,pointerout:`mouseout`},ta=e=>e===null||e===``;function na(e,t){let n=e.style,r=e.getAttribute(`height`),i=e.getAttribute(`width`);if(e[$i]={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`,ta(i)){let t=Er(e,`width`);t!==void 0&&(e.width=t)}if(ta(r)){if(e.style.height===``)e.height=e.width/(t||2);else{let t=Er(e,`height`);t!==void 0&&(e.height=t)}}return e}var ra=Tr?{passive:!0}:!1;function ia(e,t,n){e&&e.addEventListener(t,n,ra)}function aa(e,t,n){e&&e.canvas&&e.canvas.removeEventListener(t,n,ra)}function oa(e,t){let n=ea[e.type]||e.type,{x:r,y:i}=br(e,t);return{type:n,chart:t,native:e,x:r===void 0?null:r,y:i===void 0?null:i}}function sa(e,t){for(let n of e)if(n===t||n.contains(t))return!0}function ca(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=sa(n.addedNodes,r),t&&=!sa(n.removedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}function la(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=sa(n.removedNodes,r),t&&=!sa(n.addedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}var ua=new Map,da=0;function fa(){let e=window.devicePixelRatio;e!==da&&(da=e,ua.forEach((t,n)=>{n.currentDevicePixelRatio!==e&&t()}))}function pa(e,t){ua.size||window.addEventListener(`resize`,fa),ua.set(e,t)}function ma(e){ua.delete(e),ua.size||window.removeEventListener(`resize`,fa)}function ha(e,t,n){let r=e.canvas,i=r&&fr(r);if(!i)return;let a=Ft((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),pa(e,a),o}function ga(e,t,n){n&&n.disconnect(),t===`resize`&&ma(e)}function _a(e,t,n){let r=e.canvas,i=Ft(t=>{e.ctx!==null&&n(oa(t,e))},e);return ia(r,t,i),i}var va=class extends Zi{acquireContext(e,t){let n=e&&e.getContext&&e.getContext(`2d`);return n&&n.canvas===e?(na(e,t),n):null}releaseContext(e){let t=e.canvas;if(!t[$i])return!1;let n=t[$i].initial;[`height`,`width`].forEach(e=>{let r=n[e];A(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[$i],!0}addEventListener(e,t,n){this.removeEventListener(e,t);let r=e.$proxies||={};r[t]=({attach:ca,detach:la,resize:ha}[t]||_a)(e,t,n)}removeEventListener(e,t){let n=e.$proxies||={},r=n[t];r&&(({attach:ga,detach:ga,resize:ga}[t]||aa)(e,t,r),n[t]=void 0)}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(e,t,n,r){return Cr(e,t,n,r)}isAttached(e){let t=e&&fr(e);return!!(t&&t.isConnected)}};function ya(e){return!dr()||typeof OffscreenCanvas<`u`&&e instanceof OffscreenCanvas?Qi:va}var ba=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 mt(this.x)&&mt(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 xa(e,t){let n=e.options.ticks,r=Sa(e),i=Math.min(n.maxTicksLimit||r,r),a=n.major.enabled?wa(t):[],o=a.length,s=a[0],c=a[o-1],l=[];if(o>i)return Ta(t,l,a,o/i),l;let u=Ca(a,t,i);if(o>0){let e,n,r=o>1?Math.round((c-s)/(o-1)):null;for(Ea(t,l,u,A(r)?0:s-r,s),e=0,n=o-1;e<n;e++)Ea(t,l,u,a[e],a[e+1]);return Ea(t,l,u,c,A(r)?t.length:c+r),l}return Ea(t,l,u),l}function Sa(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 Ca(e,t,n){let r=Da(e),i=t.length/n;if(!r)return Math.max(i,1);let a=ft(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 wa(e){let t=[],n,r;for(n=0,r=e.length;n<r;n++)e[n].major&&t.push(n);return t}function Ta(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 Ea(e,t,n,r,i){let a=F(r,0),o=Math.min(F(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 Da(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 Oa=e=>e===`left`?`right`:e===`right`?`left`:e,ka=(e,t,n)=>t===`top`||t===`left`?e[t]+n:e[t]-n,Aa=(e,t)=>Math.min(t||e,e);function ja(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 Ma(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 Na(e,t){L(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 Pa(e){return e.drawTicks?e.tickLength:0}function Fa(e,t){if(!e.display)return 0;let n=q(e.font,t),r=K(e.padding);return(j(e.text)?e.text.length:1)*n.lineHeight+r.height}function Ia(e,t){return Fn(e,{scale:t,type:`scale`})}function La(e,t,n){return Fn(e,{tick:n,index:t,type:`tick`})}function Ra(e,t,n){let r=Lt(e);return(n&&t!==`right`||!n&&t===`right`)&&(r=Oa(r)),r}function za(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=U(r,a,s),M(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:ka(e,n,t);f=s-a}else{if(M(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:ka(e,n,t);m=U(r,o,i),d=n===`left`?-B:B}return{titleX:p,titleY:m,maxWidth:f,rotation:d}}var Ba=class e extends ba{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=P(e,1/0),t=P(t,-1/0),n=P(n,1/0),r=P(r,-1/0),{min:P(e,n),max:P(t,r),minDefined:N(e),maxDefined:N(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:P(t,P(n,t)),max:P(n,P(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(){I(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=Pn(this,i,r),!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();let s=o<this.ticks.length;this._convertTicksToLabels(s?ja(this.ticks,o):this.ticks),this.configure(),this.beforeCalculateLabelRotation(),this.calculateLabelRotation(),this.afterCalculateLabelRotation(),a.display&&(a.autoSkip||a.source===`auto`)&&(this.ticks=xa(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(){I(this.options.afterUpdate,[this])}beforeSetDimensions(){I(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(){I(this.options.afterSetDimensions,[this])}_callHooks(e){this.chart.notifyPlugins(e,this.getContext()),I(this.options[e],[this])}beforeDataLimits(){this._callHooks(`beforeDataLimits`)}determineDataLimits(){}afterDataLimits(){this._callHooks(`afterDataLimits`)}beforeBuildTicks(){this._callHooks(`beforeBuildTicks`)}buildTicks(){return[]}afterBuildTicks(){this._callHooks(`afterBuildTicks`)}beforeTickToLabelConversion(){I(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=I(t.callback,[i.value,n,e],this)}afterTickToLabelConversion(){I(this.options.afterTickToLabelConversion,[this])}beforeCalculateLabelRotation(){I(this.options.beforeCalculateLabelRotation,[this])}calculateLabelRotation(){let e=this.options,t=e.ticks,n=Aa(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=H(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-Pa(e.grid)-t.padding-Fa(e.title,this.chart.options.font),c=Math.sqrt(u*u+d*d),a=vt(Math.min(Math.asin(H((l.highest.height+6)/o,-1,1)),Math.asin(H(s/c,-1,1))-Math.asin(H(d/c,-1,1)))),a=Math.max(r,Math.min(i,a))),this.labelRotation=a}afterCalculateLabelRotation(){I(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){I(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=Fa(r,t.options.font);if(o?(e.width=this.maxWidth,e.height=Pa(i)+a):(e.height=this.maxHeight,e.width=Pa(i)+a),n.display&&this.ticks.length){let{first:t,last:r,widest:i,highest:a}=this._getLabelSizes(),s=n.padding*2,c=_t(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(){I(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++)A(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=ja(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/Aa(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,!A(p)&&!j(p))v=dn(r,g.data,g.gc,v,p),y=_;else if(j(p))for(d=0,f=p.length;d<f;++d)b=p[d],!A(b)&&!j(b)&&(v=dn(r,g.data,g.gc,v,b),y+=_);a.push(v),o.push(y),c=Math.max(v,c),l=Math.max(y,l)}Na(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 wt(this._alignToPixels?pn(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||=La(this.getContext(),e,n)}return this.$context||=Ia(this.chart.getContext(),this)}_tickSize(){let e=this.options.ticks,t=_t(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=Pa(i),d=[],f=o.setContext(this.getContext()),p=f.display?f.width:0,m=p/2,h=function(e){return pn(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(M(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(M(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 ee=F(r.ticks.maxTicksLimit,l),O=Math.max(1,Math.ceil(l/ee));for(_=0;_<l;_+=O){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=Ma(this,_,s),v!==void 0&&(y=pn(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=Pa(n.grid),f=d+l,p=u?-l:f,m=-_t(this.labelRotation),h=[],g,_,v,y,b,x,S,C,w,T,E,D,ee=`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(M(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(M(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`?ee=`top`:s===`end`&&(ee=`bottom`));let O=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=j(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`?-O.highest.height/2-t*T+T:-O.highest.height+T/2:c===`near`||m!==0?T/2:c===`center`?O.highest.height/2-t*T:O.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=K(e.backdropPadding),n=O.heights[g],r=O.widths[g],i=D-t.top,a=0-t.left;switch(ee){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:ee,translation:[b,x],backdrop:f}})}return h}_getXAxisLabelAlignment(){let{position:e,ticks:t}=this.options;if(-_t(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=pn(e,this.left,a)-a/2,l=pn(e,this.right,o)+o/2,u=d=s):(u=pn(e,this.top,a)-a/2,d=pn(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&&_n(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;wn(t,i,0,a,r,n)}n&&vn(t)}drawTitle(){let{ctx:e,options:{position:t,title:n,reverse:r}}=this;if(!n.display)return;let i=q(n.font),a=K(n.padding),o=n.align,s=i.lineHeight/2;t===`bottom`||t===`center`||M(t)?(s+=a.bottom,j(n.text)&&(s+=i.lineHeight*(n.text.length-1))):s+=a.top;let{titleX:c,titleY:l,maxWidth:u,rotation:d}=za(this,s,t,o);wn(e,n.text,0,0,i,{color:n.color,maxWidth:u,rotation:d,textAlign:Ra(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=F(t.grid&&t.grid.z,-1),i=F(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 q(this.options.ticks.setContext(this.getContext(e)).font)}_maxDigits(){let e=this._resolveTickFontOptions(0).lineHeight;return(this.isHorizontal()?this.width:this.height)/e}},Va=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;Wa(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,Ha(e,a,n),this.override&&W.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 W[r]&&(delete W[r][n],this.override&&delete on[n])}};function Ha(e,t,n){let r=Ge(Object.create(null),[n?W.get(n):{},W.get(t),e.defaults]);W.set(t,r),e.defaultRoutes&&Ua(t,e.defaultRoutes),e.descriptors&&W.describe(t,e.descriptors)}function Ua(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(`.`);W.route(a,i,c,s)})}function Wa(e){return`id`in e&&`defaults`in e}var Y=new class{constructor(){this.controllers=new Va(xi,`datasets`,!0),this.elements=new Va(ba,`elements`),this.plugins=new Va(Object,`plugins`),this.scales=new Va(Ba,`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):L(t,t=>{let r=n||this._getRegistryForType(t);this._exec(e,r,t)})})}_exec(e,t,n){let r=Qe(e);I(n[`before`+r],[],n),t[e](n),I(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}},Ga=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(I(a,[t,r,i.options],e)===!1&&r.cancelable)return!1}return!0}invalidate(){A(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=F(n.options&&n.options.plugins,{}),i=Ka(n);return r===!1&&!t?[]:Ja(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 Ka(e){let t={},n=[],r=Object.keys(Y.plugins.items);for(let e=0;e<r.length;e++)n.push(Y.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 qa(e,t){return!t&&e===!1?null:e===!0?{}:e}function Ja(e,{plugins:t,localIds:n},r,i){let a=[],o=e.getContext();for(let s of t){let t=s.id,c=qa(r[t],i);c!==null&&a.push({plugin:s,options:Ya(e.config,{plugin:s,local:n[t]},c,o)})}return a}function Ya(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 Xa(e,t){let n=W.datasets[e]||{};return((t.datasets||{})[e]||{}).indexAxis||t.indexAxis||n.indexAxis||`x`}function Za(e,t){let n=e;return e===`_index_`?n=t:e===`_value_`&&(n=t===`x`?`y`:`x`),n}function Qa(e,t){return e===t?`_index_`:`_value_`}function $a(e){if(e===`x`||e===`y`||e===`r`)return e}function eo(e){if(e===`top`||e===`bottom`)return`x`;if(e===`left`||e===`right`)return`y`}function to(e,...t){if($a(e))return e;for(let n of t){let t=n.axis||eo(n.position)||e.length>1&&$a(e[0].toLowerCase());if(t)return t}throw Error(`Cannot determine type of '${e}' axis. Please provide 'axis' or 'position' option.`)}function no(e,t,n){if(n[t+`AxisID`]===e)return{axis:t}}function ro(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 no(e,`x`,n[0])||no(e,`y`,n[0])}return{}}function io(e,t){let n=on[e.type]||{scales:{}},r=t.scales||{},i=Xa(e.type,t),a=Object.create(null);return Object.keys(r).forEach(t=>{let o=r[t];if(!M(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=to(t,o,ro(t,e),W.scales[o.type]),c=Qa(s,i),l=n.scales||{};a[t]=Ke(Object.create(null),[{axis:s},o,l[s],l[c]])}),e.data.datasets.forEach(n=>{let i=n.type||e.type,o=n.indexAxis||Xa(i,t),s=(on[i]||{}).scales||{};Object.keys(s).forEach(e=>{let t=Za(e,o),i=n[t+`AxisID`]||t;a[i]=a[i]||Object.create(null),Ke(a[i],[{axis:t},r[i],s[e]])})}),Object.keys(a).forEach(e=>{let t=a[e];Ke(t,[W.scales[t.type],W.scale])}),a}function ao(e){let t=e.options||={};t.plugins=F(t.plugins,{}),t.scales=io(e,t)}function oo(e){return e||={},e.datasets=e.datasets||[],e.labels=e.labels||[],e}function so(e){return e||={},e.data=oo(e.data),ao(e),e}var co=new Map,lo=new Set;function uo(e,t){let n=co.get(e);return n||(n=t(),co.set(e,n),lo.add(n)),n}var fo=(e,t,n)=>{let r=Ze(t,n);r!==void 0&&e.add(r)},po=class{constructor(e){this._config=so(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=oo(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(),ao(e)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(e){return uo(e,()=>[[`datasets.${e}`,``]])}datasetAnimationScopeKeys(e,t){return uo(`${e}.transition.${t}`,()=>[[`datasets.${e}.transitions.${t}`,`transitions.${t}`],[`datasets.${e}`,``]])}datasetElementScopeKeys(e,t){return uo(`${e}-${t}`,()=>[[`datasets.${e}.elements.${t}`,`datasets.${e}`,`elements.${t}`,``]])}pluginScopeKeys(e){let t=e.id,n=this.type;return uo(`${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=>fo(s,e,t))),t.forEach(e=>fo(s,r,e)),t.forEach(e=>fo(s,on[i]||{},e)),t.forEach(e=>fo(s,W,e)),t.forEach(e=>fo(s,sn,e))});let c=Array.from(s);return c.length===0&&c.push(Object.create(null)),lo.has(t)&&a.set(t,c),c}chartOptionScopes(){let{options:e,type:t}=this;return[e,on[t]||{},W.datasets[t]||{},{type:t},W,sn]}resolveNamedOptions(e,t,n,r=[``]){let i={$shared:!0},{resolver:a,subPrefixes:o}=mo(this._resolverCache,e,r),s=a;if(go(a,t)){i.$shared=!1,n=et(n)?n():n;let t=this.createResolver(e,n,o);s=Ln(a,n,t)}for(let e of t)i[e]=s[e];return i}createResolver(e,t,n=[``],r){let{resolver:i}=mo(this._resolverCache,e,n);return M(t)?Ln(i,t,void 0,r):i}};function mo(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:In(t,n),subPrefixes:n.filter(e=>!e.toLowerCase().includes(`hover`))},r.set(i,a)),a}var ho=e=>M(e)&&Object.getOwnPropertyNames(e).some(t=>et(e[t]));function go(e,t){let{isScriptable:n,isIndexable:r}=Rn(e);for(let i of t){let t=n(i),a=r(i),o=(a||t)&&e[i];if(t&&(et(o)||ho(o))||a&&j(o))return!0}return!1}var _o=`4.5.1`,vo=[`top`,`bottom`,`left`,`right`,`chartArea`];function yo(e,t){return e===`top`||e===`bottom`||vo.indexOf(e)===-1&&t===`x`}function bo(e,t){return function(n,r){return n[e]===r[e]?n[t]-r[t]:n[e]-r[e]}}function xo(e){let t=e.chart,n=t.options.animation;t.notifyPlugins(`afterRender`),I(n&&n.onComplete,[e],t)}function So(e){let t=e.chart,n=t.options.animation;I(n&&n.onProgress,[e],t)}function Co(e){return dr()&&typeof e==`string`?e=document.getElementById(e):e&&e.length&&(e=e[0]),e&&e.canvas&&(e=e.canvas),e}var wo={},To=e=>{let t=Co(e);return Object.values(wo).filter(e=>e.canvas===t).pop()};function Eo(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 Do(e,t,n,r){return!n||e.type===`mouseout`?null:r?t:e}var Oo=class{static defaults=W;static instances=wo;static overrides=on;static registry=Y;static version=_o;static getChart=To;static register(...e){Y.add(...e),ko()}static unregister(...e){Y.remove(...e),ko()}constructor(e,t){let n=this.config=new po(t),r=Co(e),i=To(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||(ya(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=ze(),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 Ga,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=It(e=>this.update(e),a.resizeDelay||0),this._dataChanges=[],wo[this.id]=this,!o||!s){console.error(`Failed to create chart: can't acquire context from the given item`);return}J.listen(this,`complete`,xo),J.listen(this,`progress`,So),this._initialize(),this.attached&&this.update()}get aspectRatio(){let{options:{aspectRatio:e,maintainAspectRatio:t},width:n,height:r,_aspectRatio:i}=this;return A(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 Y}_initialize(){return this.notifyPlugins(`beforeInit`),this.options.responsive?this.resize():wr(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins(`afterInit`),this}clear(){return mn(this.canvas,this.ctx),this}stop(){return J.stop(this),this}resize(e,t){J.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,wr(this,o,!0)&&(this.notifyPlugins(`resize`,{size:a}),I(n.onResize,[this,a],this),this.attached&&this._doResize(s)&&this.render())}ensureScalesHaveIDs(){L(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=to(e,n),i=r===`r`,a=r===`x`;return{options:n,dposition:i?`chartArea`:a?`bottom`:`left`,dtype:i?`radialLinear`:a?`category`:`linear`}}))),L(i,t=>{let i=t.options,a=i.id,o=to(a,i),s=F(i.type,t.dtype);(i.position===void 0||yo(i.position,o)!==yo(t.dposition))&&(i.position=t.dposition),r[a]=!0;let c=null;a in n&&n[a].type===s?c=n[a]:(c=new(Y.getScale(s))({id:a,type:s,ctx:this.ctx,chart:this}),n[c.id]=c),c.init(i,e)}),L(r,(e,t)=>{e||delete n[t]}),L(n,e=>{Xi.configure(this,e,e.options),Xi.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(bo(`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||Xa(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=Y.getController(a),{datasetElementType:r,dataElementType:o}=W.datasets[a];Object.assign(t,{dataElementType:Y.getElement(o),datasetElementType:r&&Y.getElement(r)}),i.controller=new t(this,n),e.push(i.controller)}}return this._updateMetasets(),e}_resetElements(){L(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||L(i,e=>{e.reset()}),this._updateDatasets(e),this.notifyPlugins(`afterUpdate`,{mode:e}),this._layers.sort(bo(`z`,`_idx`));let{_active:o,_lastEvent:s}=this;s?this._eventHandler(s,!0):o.length&&this._updateHoverStyles(o,o,!0),this.render()}_updateScales(){L(this.scales,e=>{Xi.removeBox(this,e)}),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){let e=this.options;(!tt(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)Eo(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(!tt(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;Xi.update(this,this.width,this.height,e);let t=this.chartArea,n=t.width<=0||t.height<=0;this._layers=[],L(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,et(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&&(J.has(this)?this.attached&&!J.running(this)&&J.start(this):(this.draw(),xo({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=Yr(this,e);this.notifyPlugins(`beforeDatasetDraw`,n)!==!1&&(r&&_n(t,r),e.controller.draw(),r&&vn(t),n.cancelable=!1,this.notifyPlugins(`afterDatasetDraw`,n))}isPointInArea(e){return G(e,this.chartArea,this._minPadding)}getElementsAtEventForMode(e,t,n,r){let i=Ni.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||=Fn(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);$e(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(),J.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(),mn(e,t),this.platform.releaseContext(t),this.canvas=null,this.ctx=null),delete wo[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)};L(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(){L(this._listeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._listeners={},L(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}});Ve(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=nt(e),c=Do(e,this._lastEvent,n,s);n&&(this._lastEvent=null,I(i.onHover,[e,o,this],this),s&&I(i.onClick,[e,o,this],this));let l=!Ve(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 ko(){return L(Oo.instances,e=>e._plugins.invalidate())}function Ao(e,t,n=t){e.lineCap=F(n.borderCapStyle,t.borderCapStyle),e.setLineDash(F(n.borderDash,t.borderDash)),e.lineDashOffset=F(n.borderDashOffset,t.borderDashOffset),e.lineJoin=F(n.borderJoinStyle,t.borderJoinStyle),e.lineWidth=F(n.borderWidth,t.borderWidth),e.strokeStyle=F(n.borderColor,t.borderColor)}function jo(e,t,n){e.lineTo(n.x,n.y)}function Mo(e){return e.stepped?yn:e.tension||e.cubicInterpolationMode===`monotone`?bn:jo}function No(e,t,n={}){let r=e.length,{start:i=0,end:a=r-1}=n,{start:o,end:s}=t,c=Math.max(i,o),l=Math.min(a,s),u=i<o&&a<o||i>s&&a>s;return{count:r,start:c,loop:t.loop,ilen:l<c&&!u?r+l-c:l-c}}function Po(e,t,n,r){let{points:i,options:a}=t,{count:o,start:s,loop:c,ilen:l}=No(i,n,r),u=Mo(a),{move:d=!0,reverse:f}=r||{},p,m,h;for(p=0;p<=l;++p)m=i[(s+(f?l-p:p))%o],!m.skip&&(d?(e.moveTo(m.x,m.y),d=!1):u(e,h,m,f,a.stepped),h=m);return c&&(m=i[(s+(f?l:0))%o],u(e,h,m,f,a.stepped)),!!c}function Fo(e,t,n,r){let i=t.points,{count:a,start:o,ilen:s}=No(i,n,r),{move:c=!0,reverse:l}=r||{},u=0,d=0,f,p,m,h,g,_,v=e=>(o+(l?s-e:e))%a,y=()=>{h!==g&&(e.lineTo(u,g),e.lineTo(u,h),e.lineTo(u,_))};for(c&&(p=i[v(0)],e.moveTo(p.x,p.y)),f=0;f<=s;++f){if(p=i[v(f)],p.skip)continue;let t=p.x,n=p.y,r=t|0;r===m?(n<h?h=n:n>g&&(g=n),u=(d*u+t)/++d):(y(),e.lineTo(t,n),m=r,d=0,h=g=n),_=n}y()}function Io(e){let t=e.options,n=t.borderDash&&t.borderDash.length;return!e._decimated&&!e._loop&&!t.tension&&t.cubicInterpolationMode!==`monotone`&&!t.stepped&&!n?Fo:Po}function Lo(e){return e.stepped?Or:e.tension||e.cubicInterpolationMode===`monotone`?kr:Dr}function Ro(e,t,n,r){let i=t._path;i||(i=t._path=new Path2D,t.path(i,n,r)&&i.closePath()),Ao(e,t.options),e.stroke(i)}function zo(e,t,n,r){let{segments:i,options:a}=t,o=Io(t);for(let s of i)Ao(e,a,s.style),e.beginPath(),o(e,t,s,{start:n,end:n+r-1})&&e.closePath(),e.stroke()}var Bo=typeof Path2D==`function`;function Vo(e,t,n,r){Bo&&!t.options.segment?Ro(e,t,n,r):zo(e,t,n,r)}var Ho=class extends ba{static id=`line`;static defaults={borderCapStyle:`butt`,borderDash:[],borderDashOffset:0,borderJoinStyle:`miter`,borderWidth:3,capBezierPoints:!0,cubicInterpolationMode:`default`,fill:!1,spanGaps:!1,stepped:!1,tension:0};static defaultRoutes={backgroundColor:`backgroundColor`,borderColor:`borderColor`};static descriptors={_scriptable:!0,_indexable:e=>e!==`borderDash`&&e!==`fill`};constructor(e){super(),this.animated=!0,this.options=void 0,this._chart=void 0,this._loop=void 0,this._fullLoop=void 0,this._path=void 0,this._points=void 0,this._segments=void 0,this._decimated=!1,this._pointsUpdated=!1,this._datasetIndex=void 0,e&&Object.assign(this,e)}updateControlPoints(e,t){let n=this.options;if((n.tension||n.cubicInterpolationMode===`monotone`)&&!n.stepped&&!this._pointsUpdated){let r=n.spanGaps?this._loop:this._fullLoop;ur(this._points,n,e,r,t),this._pointsUpdated=!0}}set points(e){this._points=e,delete this._segments,delete this._path,this._pointsUpdated=!1}get points(){return this._points}get segments(){return this._segments||=Hr(this,this.options.segment)}first(){let e=this.segments,t=this.points;return e.length&&t[e[0].start]}last(){let e=this.segments,t=this.points,n=e.length;return n&&t[e[n-1].end]}interpolate(e,t){let n=this.options,r=e[t],i=this.points,a=zr(this,{property:t,start:r,end:r});if(!a.length)return;let o=[],s=Lo(n),c,l;for(c=0,l=a.length;c<l;++c){let{start:l,end:u}=a[c],d=i[l],f=i[u];if(d===f){o.push(d);continue}let p=s(d,f,Math.abs((r-d[t])/(f[t]-d[t])),n.stepped);p[t]=e[t],o.push(p)}return o.length===1?o[0]:o}pathSegment(e,t,n){return Io(this)(e,this,t,n)}path(e,t,n){let r=this.segments,i=Io(this),a=this._loop;t||=0,n||=this.points.length-t;for(let o of r)a&=i(e,this,o,{start:t,end:t+n-1});return!!a}draw(e,t,n,r){let i=this.options||{};(this.points||[]).length&&i.borderWidth&&(e.save(),Vo(e,this,n,r),e.restore()),this.animated&&(this._pointsUpdated=!1,this._path=void 0)}};function Uo(e,t,n,r){let i=e.options,{[n]:a}=e.getProps([n],r);return Math.abs(t-a)<i.radius+i.hitRadius}var Wo=class extends ba{static id=`point`;parsed;skip;stop;static defaults={borderWidth:1,hitRadius:1,hoverBorderWidth:1,hoverRadius:4,pointStyle:`circle`,radius:3,rotation:0};static defaultRoutes={backgroundColor:`backgroundColor`,borderColor:`borderColor`};constructor(e){super(),this.options=void 0,this.parsed=void 0,this.skip=void 0,this.stop=void 0,e&&Object.assign(this,e)}inRange(e,t,n){let r=this.options,{x:i,y:a}=this.getProps([`x`,`y`],n);return(e-i)**2+(t-a)**2<(r.hitRadius+r.radius)**2}inXRange(e,t){return Uo(this,e,`x`,t)}inYRange(e,t){return Uo(this,e,`y`,t)}getCenterPoint(e){let{x:t,y:n}=this.getProps([`x`,`y`],e);return{x:t,y:n}}size(e){e=e||this.options||{};let t=e.radius||0;t=Math.max(t,t&&e.hoverRadius||0);let n=t&&e.borderWidth||0;return(t+n)*2}draw(e,t){let n=this.options;this.skip||n.radius<.1||!G(this,t,this.size(n)/2)||(e.strokeStyle=n.borderColor,e.lineWidth=n.borderWidth,e.fillStyle=n.backgroundColor,hn(e,n,this.x,this.y))}getRange(){let e=this.options||{};return e.radius+e.hitRadius}};function Go(e,t,n){let r=e.segments,i=e.points,a=t.points,o=[];for(let e of r){let{start:r,end:s}=e;s=Jo(r,s,i);let c=Ko(n,i[r],i[s],e.loop);if(!t.segments){o.push({source:e,target:c,start:i[r],end:i[s]});continue}let l=zr(t,c);for(let t of l){let r=Ko(n,a[t.start],a[t.end],t.loop),s=Rr(e,i,r);for(let e of s)o.push({source:e,target:t,start:{[n]:Yo(c,r,`start`,Math.max)},end:{[n]:Yo(c,r,`end`,Math.min)}})}}return o}function Ko(e,t,n,r){if(r)return;let i=t[e],a=n[e];return e===`angle`&&(i=V(i),a=V(a)),{property:e,start:i,end:a}}function qo(e,t){let{x:n=null,y:r=null}=e||{},i=t.points,a=[];return t.segments.forEach(({start:e,end:t})=>{t=Jo(e,t,i);let o=i[e],s=i[t];r===null?n!==null&&(a.push({x:n,y:o.y}),a.push({x:n,y:s.y})):(a.push({x:o.x,y:r}),a.push({x:s.x,y:r}))}),a}function Jo(e,t,n){for(;t>e;t--){let e=n[t];if(!isNaN(e.x)&&!isNaN(e.y))break}return t}function Yo(e,t,n,r){return e&&t?r(e[n],t[n]):e?e[n]:t?t[n]:0}function Xo(e,t){let n=[],r=!1;return j(e)?(r=!0,n=e):n=qo(e,t),n.length?new Ho({points:n,options:{tension:0},_loop:r,_fullLoop:r}):null}function Zo(e){return e&&e.fill!==!1}function Qo(e,t,n){let r=e[t].fill,i=[t],a;if(!n)return r;for(;r!==!1&&i.indexOf(r)===-1;){if(!N(r))return r;if(a=e[r],!a)return!1;if(a.visible)return r;i.push(r),r=a.fill}return!1}function $o(e,t,n){let r=rs(e);if(M(r))return!isNaN(r.value)&&r;let i=parseFloat(r);return N(i)&&Math.floor(i)===i?es(r[0],t,i,n):[`origin`,`start`,`end`,`stack`,`shape`].indexOf(r)>=0&&r}function es(e,t,n,r){return(e===`-`||e===`+`)&&(n=t+n),n===t||n<0||n>=r?!1:n}function ts(e,t){let n=null;return e===`start`?n=t.bottom:e===`end`?n=t.top:M(e)?n=t.getPixelForValue(e.value):t.getBasePixel&&(n=t.getBasePixel()),n}function ns(e,t,n){let r;return r=e===`start`?n:e===`end`?t.options.reverse?t.min:t.max:M(e)?e.value:t.getBaseValue(),r}function rs(e){let t=e.options,n=t.fill,r=F(n&&n.target,n);return r===void 0&&(r=!!t.backgroundColor),r===!1||r===null?!1:r===!0?`origin`:r}function is(e){let{scale:t,index:n,line:r}=e,i=[],a=r.segments,o=r.points,s=as(t,n);s.push(Xo({x:null,y:t.bottom},r));for(let e=0;e<a.length;e++){let t=a[e];for(let e=t.start;e<=t.end;e++)os(i,o[e],s)}return new Ho({points:i,options:{}})}function as(e,t){let n=[],r=e.getMatchingVisibleMetas(`line`);for(let e=0;e<r.length;e++){let i=r[e];if(i.index===t)break;i.hidden||n.unshift(i.dataset)}return n}function os(e,t,n){let r=[];for(let i=0;i<n.length;i++){let a=n[i],{first:o,last:s,point:c}=ss(a,t,`x`);if(!(!c||o&&s)){if(o)r.unshift(c);else if(e.push(c),!s)break}}e.push(...r)}function ss(e,t,n){let r=e.interpolate(t,n);if(!r)return{};let i=r[n],a=e.segments,o=e.points,s=!1,c=!1;for(let e=0;e<a.length;e++){let t=a[e],r=o[t.start][n],l=o[t.end][n];if(Tt(i,r,l)){s=i===r,c=i===l;break}}return{first:s,last:c,point:r}}var cs=class{constructor(e){this.x=e.x,this.y=e.y,this.radius=e.radius}pathSegment(e,t,n){let{x:r,y:i,radius:a}=this;return t||={start:0,end:z},e.arc(r,i,a,t.end,t.start,!0),!n.bounds}interpolate(e){let{x:t,y:n,radius:r}=this,i=e.angle;return{x:t+Math.cos(i)*r,y:n+Math.sin(i)*r,angle:i}}};function ls(e){let{chart:t,fill:n,line:r}=e;if(N(n))return us(t,n);if(n===`stack`)return is(e);if(n===`shape`)return!0;let i=ds(e);return i instanceof cs?i:Xo(i,r)}function us(e,t){let n=e.getDatasetMeta(t);return n&&e.isDatasetVisible(t)?n.dataset:null}function ds(e){return(e.scale||{}).getPointPositionForValue?ps(e):fs(e)}function fs(e){let{scale:t={},fill:n}=e,r=ts(n,t);if(N(r)){let e=t.isHorizontal();return{x:e?r:null,y:e?null:r}}return null}function ps(e){let{scale:t,fill:n}=e,r=t.options,i=t.getLabels().length,a=r.reverse?t.max:t.min,o=ns(n,t,a),s=[];if(r.grid.circular){let e=t.getPointPositionForValue(0,a);return new cs({x:e.x,y:e.y,radius:t.getDistanceFromCenterForValue(o)})}for(let e=0;e<i;++e)s.push(t.getPointPositionForValue(e,o));return s}function ms(e,t,n){let r=ls(t),{chart:i,index:a,line:o,scale:s,axis:c}=t,l=o.options,u=l.fill,d=l.backgroundColor,{above:f=d,below:p=d}=u||{},m=Yr(i,i.getDatasetMeta(a));r&&o.points.length&&(_n(e,n),hs(e,{line:o,target:r,above:f,below:p,area:n,scale:s,axis:c,clip:m}),vn(e))}function hs(e,t){let{line:n,target:r,above:i,below:a,area:o,scale:s,clip:c}=t,l=n._loop?`angle`:t.axis;e.save();let u=a;a!==i&&(l===`x`?(gs(e,r,o.top),vs(e,{line:n,target:r,color:i,scale:s,property:l,clip:c}),e.restore(),e.save(),gs(e,r,o.bottom)):l===`y`&&(_s(e,r,o.left),vs(e,{line:n,target:r,color:a,scale:s,property:l,clip:c}),e.restore(),e.save(),_s(e,r,o.right),u=i)),vs(e,{line:n,target:r,color:u,scale:s,property:l,clip:c}),e.restore()}function gs(e,t,n){let{segments:r,points:i}=t,a=!0,o=!1;e.beginPath();for(let s of r){let{start:r,end:c}=s,l=i[r],u=i[Jo(r,c,i)];a?(e.moveTo(l.x,l.y),a=!1):(e.lineTo(l.x,n),e.lineTo(l.x,l.y)),o=!!t.pathSegment(e,s,{move:o}),o?e.closePath():e.lineTo(u.x,n)}e.lineTo(t.first().x,n),e.closePath(),e.clip()}function _s(e,t,n){let{segments:r,points:i}=t,a=!0,o=!1;e.beginPath();for(let s of r){let{start:r,end:c}=s,l=i[r],u=i[Jo(r,c,i)];a?(e.moveTo(l.x,l.y),a=!1):(e.lineTo(n,l.y),e.lineTo(l.x,l.y)),o=!!t.pathSegment(e,s,{move:o}),o?e.closePath():e.lineTo(n,u.y)}e.lineTo(n,t.first().y),e.closePath(),e.clip()}function vs(e,t){let{line:n,target:r,property:i,color:a,scale:o,clip:s}=t,c=Go(n,r,i);for(let{source:t,target:l,start:u,end:d}of c){let{style:{backgroundColor:c=a}={}}=t,f=r!==!0;e.save(),e.fillStyle=c,ys(e,o,s,f&&Ko(i,u,d)),e.beginPath();let p=!!n.pathSegment(e,t),m;if(f){p?e.closePath():bs(e,r,d,i);let t=!!r.pathSegment(e,l,{move:p,reverse:!0});m=p&&t,m||bs(e,r,u,i)}e.closePath(),e.fill(m?`evenodd`:`nonzero`),e.restore()}}function ys(e,t,n,r){let i=t.chart.chartArea,{property:a,start:o,end:s}=r||{};if(a===`x`||a===`y`){let t,r,c,l;a===`x`?(t=o,r=i.top,c=s,l=i.bottom):(t=i.left,r=o,c=i.right,l=s),e.beginPath(),n&&(t=Math.max(t,n.left),c=Math.min(c,n.right),r=Math.max(r,n.top),l=Math.min(l,n.bottom)),e.rect(t,r,c-t,l-r),e.clip()}}function bs(e,t,n,r){let i=t.interpolate(n,r);i&&e.lineTo(i.x,i.y)}var xs={id:`filler`,afterDatasetsUpdate(e,t,n){let r=(e.data.datasets||[]).length,i=[],a,o,s,c;for(o=0;o<r;++o)a=e.getDatasetMeta(o),s=a.dataset,c=null,s&&s.options&&s instanceof Ho&&(c={visible:e.isDatasetVisible(o),index:o,fill:$o(s,o,r),chart:e,axis:a.controller.options.indexAxis,scale:a.vScale,line:s}),a.$filler=c,i.push(c);for(o=0;o<r;++o)c=i[o],!(!c||c.fill===!1)&&(c.fill=Qo(i,o,n.propagate))},beforeDraw(e,t,n){let r=n.drawTime===`beforeDraw`,i=e.getSortedVisibleDatasetMetas(),a=e.chartArea;for(let t=i.length-1;t>=0;--t){let n=i[t].$filler;n&&(n.line.updateControlPoints(a,n.axis),r&&n.fill&&ms(e.ctx,n,a))}},beforeDatasetsDraw(e,t,n){if(n.drawTime!==`beforeDatasetsDraw`)return;let r=e.getSortedVisibleDatasetMetas();for(let t=r.length-1;t>=0;--t){let n=r[t].$filler;Zo(n)&&ms(e.ctx,n,e.chartArea)}},beforeDatasetDraw(e,t,n){let r=t.meta.$filler;!Zo(r)||n.drawTime!==`beforeDatasetDraw`||ms(e.ctx,r,e.chartArea)},defaults:{propagate:!0,drawTime:`beforeDatasetDraw`}},Ss=(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)}},Cs=(e,t)=>e!==null&&t!==null&&e.datasetIndex===t.datasetIndex&&e.index===t.index,ws=class extends ba{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=I(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=q(n.font),i=r.size,a=this._computeTitleHeight(),{boxWidth:o,itemHeight:s}=Ss(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}=Ts(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=Mr(i,this.left,this.width);if(this.isHorizontal()){let i=0,o=U(n,this.left+r,this.right-this.lineWidths[i]);for(let s of t)i!==s.row&&(i=s.row,o=U(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=U(n,this.top+e+r,this.bottom-this.columnSizes[i].height);for(let s of t)s.col!==i&&(i=s.col,o=U(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;_n(e,this),this._draw(),vn(e)}}_draw(){let{options:e,columnSizes:t,lineWidths:n,ctx:r}=this,{align:i,labels:a}=e,o=W.color,s=Mr(e.rtl,this.left,this.width),c=q(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}=Ss(a,u),g=function(e,t,n){if(isNaN(p)||p<=0||isNaN(m)||m<0)return;r.save();let i=F(n.lineWidth,1);if(r.fillStyle=F(n.fillStyle,o),r.lineCap=F(n.lineCap,`butt`),r.lineDashOffset=F(n.lineDashOffset,0),r.lineJoin=F(n.lineJoin,`miter`),r.lineWidth=i,r.strokeStyle=F(n.strokeStyle,o),r.setLineDash(F(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;gn(r,o,c,l,a.pointStyleWidth&&p)}else{let a=t+Math.max((u-m)/2,0),o=s.leftForLtr(e,p),c=Mn(n.borderRadius);r.beginPath(),Object.values(c).some(e=>e!==0)?Tn(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){wn(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:U(i,this.left+l,this.right-n[0]),y:this.top+l+y,line:0}:{x:this.left+l,y:U(i,this.top+y+l,this.bottom-t[0].height),line:0},Nr(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=U(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=U(i,this.top+y+l,this.bottom-t[f.line].height));let w=s.x(S);if(g(w,C,o),S=Rt(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+=Os(o,e)+l}else f.y+=b}),Pr(this.ctx,e.textDirection)}drawTitle(){let e=this.options,t=e.title,n=q(t.font),r=K(t.padding);if(!t.display)return;let i=Mr(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=U(e.align,u,this.right-d);else{let t=this.columnSizes.reduce((e,t)=>Math.max(e,t.height),0);l=c+U(e.align,this.top,this.bottom-t-e.labels.padding-this._computeTitleHeight())}let f=U(o,u,u+d);a.textAlign=i.textAlign(Lt(o)),a.textBaseline=`middle`,a.strokeStyle=t.color,a.fillStyle=t.color,a.font=n.string,wn(a,t.text,f,l,n)}_computeTitleHeight(){let e=this.options.title,t=q(e.font),n=K(e.padding);return e.display?t.lineHeight+n.height:0}_getLegendItemAt(e,t){let n,r,i;if(Tt(e,this.left,this.right)&&Tt(t,this.top,this.bottom)){for(i=this.legendHitBoxes,n=0;n<i.length;++n)if(r=i[n],Tt(e,r.left,r.left+r.width)&&Tt(t,r.top,r.top+r.height))return this.legendItems[n]}return null}handleEvent(e){let t=this.options;if(!ks(e.type,t))return;let n=this._getLegendItemAt(e.x,e.y);if(e.type===`mousemove`||e.type===`mouseout`){let r=this._hoveredItem,i=Cs(r,n);r&&!i&&I(t.onLeave,[e,r,this],this),this._hoveredItem=n,n&&!i&&I(t.onHover,[e,n,this],this)}else n&&I(t.onClick,[e,n,this],this)}};function Ts(e,t,n,r,i){return{itemWidth:Es(r,e,t,n),itemHeight:Ds(i,r,t.lineHeight)}}function Es(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 Ds(e,t,n){let r=e;return typeof t.text!=`string`&&(r=Os(t,n)),r}function Os(e,t){return t*(e.text?e.text.length:0)}function ks(e,t){return!!((e===`mousemove`||e===`mouseout`)&&(t.onHover||t.onLeave)||t.onClick&&(e===`click`||e===`mouseup`))}var As={id:`legend`,_element:ws,start(e,t,n){let r=e.legend=new ws({ctx:e.ctx,options:n,chart:e});Xi.configure(e,r,n),Xi.addBox(e,r)},stop(e){Xi.removeBox(e,e.legend),delete e.legend},beforeUpdate(e,t,n){let r=e.legend;Xi.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=K(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)}}},js={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=xt(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 X(e,t){return t&&(j(t)?Array.prototype.push.apply(e,t):e.push(t)),e}function Z(e){return(typeof e==`string`||e instanceof String)&&e.indexOf(`
`)>-1?e.split(`
`):e}function Ms(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 Ns(e,t){let n=e.chart.ctx,{body:r,footer:i,title:a}=e,{boxWidth:o,boxHeight:s}=t,c=q(t.bodyFont),l=q(t.titleFont),u=q(t.footerFont),d=a.length,f=i.length,p=r.length,m=K(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,L(e.title,y),n.font=c.string,L(e.beforeBody.concat(e.afterBody),y),v=t.displayColors?o+2+t.boxPadding:0,L(r,e=>{L(e.before,y),L(e.lines,y),L(e.after,y)}),v=0,n.font=u.string,L(e.footer,y),n.restore(),g+=m.width,{width:g,height:h}}function Ps(e,t){let{y:n,height:r}=t;return n<r/2?`top`:n>e.height-r/2?`bottom`:`center`}function Fs(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 Is(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`),Fs(l,e,t,n)&&(l=`center`),l}function Ls(e,t,n){let r=n.yAlign||t.yAlign||Ps(e,n);return{xAlign:n.xAlign||t.xAlign||Is(e,t,n,r),yAlign:r}}function Rs(e,t){let{x:n,width:r}=e;return t===`right`?n-=r:t===`center`&&(n-=r/2),n}function zs(e,t,n){let{y:r,height:i}=e;return t===`top`?r+=n:r-=t===`bottom`?i+n:i/2,r}function Bs(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}=Mn(o),m=Rs(t,s),h=zs(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:H(m,0,r.width-t.width),y:H(h,0,r.height-t.height)}}function Vs(e,t,n){let r=K(n.padding);return t===`center`?e.x+e.width/2:t===`right`?e.x+e.width-r.right:e.x+r.left}function Hs(e){return X([],Z(e))}function Us(e,t,n){return Fn(e,{tooltip:t,tooltipItems:n,type:`tooltip`})}function Ws(e,t){let n=t&&t.dataset&&t.dataset.tooltip&&t.dataset.tooltip.callbacks;return n?e.override(n):e}var Gs={beforeTitle:k,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:k,beforeBody:k,beforeLabel:k,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 A(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:k,afterBody:k,beforeFooter:k,footer:k,afterFooter:k};function Q(e,t,n,r){let i=e[t].call(n,r);return i===void 0?Gs[t].call(n,r):i}var Ks=class extends ba{static positioners=js;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 $r(this.chart,r);return r._cacheable&&(this._cachedAnimations=Object.freeze(i)),i}getContext(){return this.$context||=Us(this.chart.getContext(),this,this._tooltipItems)}getTitle(e,t){let{callbacks:n}=t,r=Q(n,`beforeTitle`,this,e),i=Q(n,`title`,this,e),a=Q(n,`afterTitle`,this,e),o=[];return o=X(o,Z(r)),o=X(o,Z(i)),o=X(o,Z(a)),o}getBeforeBody(e,t){return Hs(Q(t.callbacks,`beforeBody`,this,e))}getBody(e,t){let{callbacks:n}=t,r=[];return L(e,e=>{let t={before:[],lines:[],after:[]},i=Ws(n,e);X(t.before,Z(Q(i,`beforeLabel`,this,e))),X(t.lines,Q(i,`label`,this,e)),X(t.after,Z(Q(i,`afterLabel`,this,e))),r.push(t)}),r}getAfterBody(e,t){return Hs(Q(t.callbacks,`afterBody`,this,e))}getFooter(e,t){let{callbacks:n}=t,r=Q(n,`beforeFooter`,this,e),i=Q(n,`footer`,this,e),a=Q(n,`afterFooter`,this,e),o=[];return o=X(o,Z(r)),o=X(o,Z(i)),o=X(o,Z(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(Ms(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))),L(o,t=>{let n=Ws(e.callbacks,t);r.push(Q(n,`labelColor`,this,t)),i.push(Q(n,`labelPointStyle`,this,t)),a.push(Q(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=js[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=Ns(this,n),o=Object.assign({},e,t),s=Ls(this.chart,n,o),c=Bs(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}=Mn(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=Mr(n.rtl,this.x,this.width);for(e.x=Vs(this,n.titleAlign,n),t.textAlign=c.textAlign(n.titleAlign),t.textBaseline=`middle`,a=q(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=q(i.bodyFont),u=Vs(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,hn(e,t,n,l),e.strokeStyle=a.borderColor,e.fillStyle=a.backgroundColor,hn(e,t,n,l)}else{e.lineWidth=M(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=Mn(a.borderRadius);Object.values(o).some(e=>e!==0)?(e.beginPath(),e.fillStyle=i.multiKeyBackground,Tn(e,{x:t,y:p,w:c,h:s,radius:o}),e.fill(),e.stroke(),e.fillStyle=a.backgroundColor,e.beginPath(),Tn(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=q(n.bodyFont),d=u.lineHeight,f=0,p=Mr(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=Vs(this,h,n),t.fillStyle=n.bodyColor,L(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=_,L(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;L(g.after,m)}f=0,d=u.lineHeight,L(this.afterBody,m),e.y-=i}drawFooter(e,t,n){let r=this.footer,i=r.length,a,o;if(i){let s=Mr(n.rtl,this.x,this.width);for(e.x=Vs(this,n.footerAlign,n),e.y+=n.footerMarginTop,t.textAlign=s.textAlign(n.footerAlign),t.textBaseline=`middle`,a=q(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}=Mn(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=js[e.position].call(this,this._active,this._eventPosition);if(!n)return;let a=this._size=Ns(this,e),o=Object.assign({},n,this._size),s=Ls(t,e,o),c=Bs(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=K(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),Nr(e,t.textDirection),i.y+=a.top,this.drawTitle(i,e,t),this.drawBody(i,e,t),this.drawFooter(i,e,t),Pr(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=!Ve(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||!Ve(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=js[i.position].call(this,e,t);return a!==!1&&(n!==a.x||r!==a.y)}},qs={id:`tooltip`,_element:Ks,positioners:js,afterInit(e,t,n){n&&(e.tooltip=new Ks({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:Gs},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`]},Js=(e,t,n,r)=>(typeof t==`string`?(n=e.push(t)-1,r.unshift({index:n,label:t})):isNaN(t)&&(n=null),n);function Ys(e,t,n,r){let i=e.indexOf(t);return i===-1?Js(e,t,n,r):i===e.lastIndexOf(t)?i:n}var Xs=(e,t)=>e===null?null:H(Math.round(e),0,t);function Zs(e){let t=this.getLabels();return e>=0&&e<t.length?t[e]:e}var Qs=class extends Ba{static id=`category`;static defaults={ticks:{callback:Zs}};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(A(e))return null;let n=this.getLabels();return t=isFinite(t)&&n[t]===e?t:Ys(n,e,F(t,e),this._addedLabels),Xs(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 Zs.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 $s(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=!A(a),_=!A(o),v=!A(c),y=(h-m)/(u+1),b=dt((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=dt(w*b/p/f)*f),A(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&&ht((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=ut(w,Math.round(w),b/1e3)?Math.round(w):Math.ceil(w));let T=Math.max(yt(b),yt(S));x=10**(A(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++,ut(Math.round((S+E*b)*x)/x,a,ec(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&&ut(n[n.length-1].value,o,ec(o,y,e))?n[n.length-1].value=o:n.push({value:o}):(!_||C===o)&&n.push({value:C}),n}function ec(e,t,{horizontal:n,minRotation:r}){let i=_t(r),a=(n?Math.sin(i):Math.cos(i))||.001,o=.75*t*(``+e).length;return Math.min(t/a,o)}var tc=class extends Ba{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 A(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=lt(r),t=lt(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=$s({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`&&gt(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 en(e,this.chart.options.locale,this.options.ticks.format)}},nc=class extends tc{static id=`linear`;static defaults={ticks:{callback:rn.formatters.numeric}};determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=N(e)?e:0,this.max=N(t)?t:1,this.handleTickRangeOptions()}computeTickLimit(){let e=this.isHorizontal(),t=e?this.width:this.height,n=_t(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}},rc=e=>Math.floor(ct(e)),ic=(e,t)=>10**(rc(e)+t);function ac(e){return e/10**rc(e)==1}function oc(e,t,n){let r=10**n,i=Math.floor(e/r);return Math.ceil(t/r)-i}function sc(e,t){let n=rc(t-e);for(;oc(e,t,n)>10;)n++;for(;oc(e,t,n)<10;)n--;return Math.min(n,rc(e))}function cc(e,{min:t,max:n}){t=P(e.min,t);let r=[],i=rc(t),a=sc(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=P(e.min,Math.round((c+u+d*10**a)*o)/o);for(;f<n;)r.push({value:f,major:ac(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=P(e.max,f);return r.push({value:p,major:ac(p),significand:d}),r}(class extends Ba{static id=`logarithmic`;static defaults={ticks:{callback:rn.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=tc.prototype.parse.apply(this,[e,t]);if(n===0){this._zero=!0;return}return N(n)&&n>0?n:null}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=N(e)?Math.max(0,e):null,this.max=N(t)?Math.max(0,t):null,this.options.beginAtZero&&(this._zero=!0),this._zero&&this.min!==this._suggestedMin&&!N(this._userMin)&&(this.min=e===ic(this.min,0)?ic(this.min,-1):ic(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(ic(n,-1)),a(ic(r,1)))),n<=0&&i(ic(r,-1)),r<=0&&a(ic(n,1)),this.min=n,this.max=r}buildTicks(){let e=this.options,t=cc({min:this._userMin,max:this._userMax},this);return e.bounds===`ticks`&&gt(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`:en(e,this.chart.options.locale,this.options.ticks.format)}configure(){let e=this.min;super.configure(),this._startValue=ct(e),this._valueRange=ct(this.max)-ct(e)}getPixelForValue(e){return(e===void 0||e===0)&&(e=this.min),e===null||isNaN(e)?NaN:this.getPixelForDecimal(e===this.min?0:(ct(e)-this._startValue)/this._valueRange)}getValueForPixel(e){let t=this.getDecimalForPixel(e);return 10**(this._startValue+t*this._valueRange)}});function lc(e){let t=e.ticks;if(t.display&&e.display){let e=K(t.backdropPadding);return F(t.font&&t.font.size,W.font.size)+e.height}return 0}function uc(e,t,n){return n=j(n)?n:[n],{w:fn(e,t.string,n),h:n.length*t.lineHeight}}function dc(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 fc(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?R/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=q(a.font),d=uc(e.ctx,u,e._pointLabels[c]);r[c]=d;let f=V(e.getIndexAngle(c)+s),p=Math.round(vt(f));pc(n,t,f,dc(p,l.x,d.w,0,180),dc(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=gc(e,r,i)}function pc(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 mc(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(vt(V(c.angle+B))),u=yc(c.y,s.h,l),d=_c(l),f=vc(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 hc(e,t){if(!t)return!0;let{left:n,top:r,right:i,bottom:a}=e;return!(G({x:n,y:r},t)||G({x:n,y:a},t)||G({x:i,y:r},t)||G({x:i,y:a},t))}function gc(e,t,n){let r=[],i=e._pointLabels.length,a=e.options,{centerPointLabels:o,display:s}=a.pointLabels,c={extra:lc(a)/2,additionalAngle:o?R/i:0},l;for(let a=0;a<i;a++){c.padding=n[a],c.size=t[a];let i=mc(e,a,c);r.push(i),s===`auto`&&(i.visible=hc(i,l),i.visible&&(l=i))}return r}function _c(e){return e===0||e===180?`center`:e<180?`left`:`right`}function vc(e,t,n){return n===`right`?e-=t:n===`center`&&(e-=t/2),e}function yc(e,t,n){return n===90||n===270?e-=t/2:(n>270||n<90)&&(e-=t),e}function bc(e,t,n){let{left:r,top:i,right:a,bottom:o}=n,{backdropColor:s}=t;if(!A(s)){let n=Mn(t.borderRadius),c=K(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(),Tn(e,{x:l,y:u,w:d,h:f,radius:n}),e.fill()):e.fillRect(l,u,d,f)}}function xc(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));bc(n,a,t);let o=q(a.font),{x:s,y:c,textAlign:l}=t;wn(n,e._pointLabels[i],s,c+o.lineHeight/2,o,{color:a.color,textAlign:l,textBaseline:`middle`})}}function Sc(e,t,n,r){let{ctx:i}=e;if(n)i.arc(e.xCenter,e.yCenter,t,0,z);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 Cc(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(),Sc(e,n,o,r),a.closePath(),a.stroke(),a.restore())}function wc(e,t,n){return Fn(e,{label:n,index:t,type:`pointLabel`})}(class extends tc{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:rn.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=K(lc(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=N(e)&&!isNaN(e)?e:0,this.max=N(t)&&!isNaN(t)?t:0,this.handleTickRangeOptions()}computeTickLimit(){return Math.ceil(this.drawingArea/lc(this.options))}generateTickLabels(e){tc.prototype.generateTickLabels.call(this,e),this._pointLabels=this.getLabels().map((e,t)=>{let n=I(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?fc(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=z/(this._pointLabels.length||1),n=this.options.startAngle||0;return V(e*t+_t(n))}getDistanceFromCenterForValue(e){if(A(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(A(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 wc(this.getContext(),e,n)}}getPointPosition(e,t,n=0){let r=this.getIndexAngle(e)-B+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(),Sc(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&&xc(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);Cc(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=q(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=K(s.backdropPadding);e.fillRect(-a/2-t.left,-i-c.size/2-t.top,a+t.width,c.size+t.height)}wn(e,r.label,0,-i,c,{color:s.color,strokeColor:s.textStrokeColor,strokeWidth:s.textStrokeWidth})}),e.restore()}drawTitle(){}});var Tc={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}},$=Object.keys(Tc);function Ec(e,t){return e-t}function Dc(e,t){if(A(t))return null;let n=e._adapter,{parser:r,round:i,isoWeekday:a}=e._parseOpts,o=t;return typeof r==`function`&&(o=r(o)),N(o)||(o=typeof r==`string`?n.parse(o,r):n.parse(o)),o===null?null:(i&&(o=i===`week`&&(mt(a)||a===!0)?n.startOf(o,`isoWeek`,a):n.startOf(o,i)),+o)}function Oc(e,t,n,r){let i=$.length;for(let a=$.indexOf(e);a<i-1;++a){let e=Tc[$[a]],i=e.steps?e.steps:2**53-1;if(e.common&&Math.ceil((n-t)/(i*e.size))<=r)return $[a]}return $[i-1]}function kc(e,t,n,r,i){for(let a=$.length-1;a>=$.indexOf(n);a--){let n=$[a];if(Tc[n].common&&e._adapter.diff(i,r,n)>=t-1)return n}return $[n?$.indexOf(n):0]}function Ac(e){for(let t=$.indexOf(e)+1,n=$.length;t<n;++t)if(Tc[$[t]].common)return $[t]}function jc(e,t,n){if(!n)e[t]=!0;else if(n.length){let{lo:r,hi:i}=Et(n,t),a=n[r]>=t?n[r]:n[i];e[a]=!0}}function Mc(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 Nc(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:Mc(e,r,i,n)}var Pc=class extends Ba{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 wi._date(e.adapters.date);r.init(t),Ke(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:Dc(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=N(r)&&!isNaN(r)?r:+t.startOf(Date.now(),n),i=N(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=kt(r,i,a);return this._unit=t.unit||(n.autoSkip?Oc(t.minUnit,this.min,this.max,this._getLabelCapacity(i)):kc(this,o.length,t.minUnit,this.min,this.max)),this._majorUnit=!n.major.enabled||this._unit===`year`?void 0:Ac(this._unit),this.initOffsets(r),e.reverse&&o.reverse(),Nc(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=H(t,0,a),n=H(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||Oc(i.minUnit,t,n,this._getLabelCapacity(t)),o=F(r.ticks.stepSize,1),s=a===`week`&&i.isoWeekday,c=mt(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++)jc(l,d,p);return(d===n||r.bounds===`ticks`||f===1)&&jc(l,d,p),Object.keys(l).sort(Ec).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 I(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=_t(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,Nc(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(Dc(this,r[t]));return this._cache.labels=this._normalized?e:this.normalize(e)}normalize(e){return Nt(e.sort(Ec))}};function Fc(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}=Dt(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}=Dt(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 Pc{static id=`timeseries`;static defaults=Pc.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=Fc(t,this.min),this._tableRange=Fc(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(Fc(this._table,e)-this._minPos)/this._tableRange}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return Fc(this._table,n*this._tableRange+this._minPos,!0)}});var Ic={data:{type:Object,required:!0},options:{type:Object,default:()=>({})},plugins:{type:Array,default:()=>[]},datasetIdKey:{type:String,default:`label`},updateMode:{type:String,default:void 0}},Lc={ariaLabel:{type:String},ariaDescribedby:{type:String}},Rc={type:{type:String,required:!0},destroyDelay:{type:Number,default:0},...Ic,...Lc},zc=(e,t)=>Object.assign(e,t);function Bc(e){return s(e)?d(e):e}function Vc(e){let t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:e;return s(t)?new Proxy(e,{}):e}function Hc(e,t){let n=e.options;n&&t&&Object.assign(n,t)}function Uc(e,t){e.labels=t}function Wc(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 Gc(e,t){let n={labels:[],datasets:[]};return Uc(n,e.labels),Wc(n,e.datasets,t),n}var Kc=c({props:Rc,setup(t,r){let{expose:i,slots:s}=r,c=v(null),l=g(null);i({chart:l});let u=()=>{if(!c.value)return;let{type:e,data:n,options:r,plugins:i,datasetIdKey:a}=t,o=Vc(Gc(n,a),n);l.value=new Oo(c.value,{type:e,data:o,options:{...r},plugins:i})},p=()=>{let e=d(l.value);e&&(t.destroyDelay>0?setTimeout(()=>{e.destroy(),l.value=null},t.destroyDelay):(e.destroy(),l.value=null))},m=e=>{e.update(t.updateMode)};return o(u),f(p),e([()=>t.options,()=>t.data],(e,n)=>{let[r,i]=e,[o,s]=n,c=d(l.value);if(!c)return;let u=!1;if(r){let e=Bc(r),t=Bc(o);e&&e!==t&&(Hc(c,e),u=!0)}if(i){let e=Bc(i.labels),n=Bc(s.labels),r=Bc(i.datasets),a=Bc(s.datasets);e!==n&&(Uc(c.config.data,e),u=!0),r&&r!==a&&(Wc(c.config.data,r,t.datasetIdKey),u=!0)}u&&a(()=>{m(c)})},{deep:!0}),()=>n(`canvas`,{role:`img`,"aria-label":t.ariaLabel,"aria-describedby":t.ariaDescribedby,ref:c},[n(`p`,{},[s.default?s.default():``])])}});function qc(t,r){return Oo.register(r),c({props:Ic,setup(r,i){let{expose:a}=i,o=g(null),s=g(null);e(()=>s.value?.chart??null,e=>{o.value=e},{flush:`sync`}),a({chart:o});let c=e=>{s.value=e};return()=>n(Kc,zc({ref:c},{type:t,...r}))}})}var Jc=qc(`line`,Si);Oo.register(Qs,nc,As,qs,Si,Ho,Wo,xs);function Yc(){let e=v(``),n=v(``),r=v(``);function i(){let t=getComputedStyle(document.documentElement);e.value=t.getPropertyValue(`--foreground`).trim(),n.value=t.getPropertyValue(`--muted-foreground`).trim(),r.value=t.getPropertyValue(`--border`).trim()}let a;return o(()=>{i(),a=window.matchMedia(`(prefers-color-scheme: dark)`),a.addEventListener(`change`,i)}),t(()=>{a?.removeEventListener(`change`,i)}),{foreground:e,mutedForeground:n,border:r}}var Xc=[`aria-label`],Zc=c({__name:`TimeSeriesChart`,props:{labels:{},datasets:{},comparisonDatasets:{default:()=>[]},stacked:{type:Boolean,default:!1},valueFormatter:{type:Function,default:b},ariaLabel:{}},setup(e){let t=e,n=`timeseries-chart-desc-${i()}`,a=h(()=>t.datasets.length===0||t.labels.length===0?`No data for this range.`:t.datasets.map(e=>{let n=e.data.length>0?e.data[e.data.length-1]:0,r=e.data.reduce((e,t)=>e+t,0);return`${e.label}: latest ${t.valueFormatter(n)}, total ${t.valueFormatter(r)} over ${t.labels.length} buckets.`}).join(` `)),{foreground:o,mutedForeground:s,border:c}=Yc();function d(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let f=h(()=>{o.value;let e=t.datasets.map(e=>{let n=d(e.color);return{label:e.label,data:e.data,borderColor:n,backgroundColor:n,fill:t.stacked,stack:t.stacked?`main`:void 0,tension:.2,pointRadius:2,borderWidth:2}}),n=t.comparisonDatasets.map(e=>{let t=d(e.color);return{label:`${e.label}${e.labelSuffix??``}`,data:e.data,borderColor:t,backgroundColor:`transparent`,borderDash:[6,4],fill:!1,tension:.2,pointRadius:0,borderWidth:1.5}});return{labels:t.labels,datasets:[...e,...n]}}),g=h(()=>({responsive:!0,maintainAspectRatio:!1,animation:!1,interaction:{mode:`index`,intersect:!1},scales:{x:{stacked:t.stacked,grid:{color:c.value,display:!1},ticks:{color:s.value}},y:{stacked:t.stacked,beginAtZero:!0,grid:{color:c.value},ticks:{color:s.value,callback:e=>t.valueFormatter(Number(e))}}},plugins:{legend:{display:t.datasets.length>1||t.comparisonDatasets.length>0,labels:{color:o.value}},tooltip:{callbacks:{label:e=>`${e.dataset.label}: ${t.valueFormatter(e.parsed.y??0)}`}}}}));return(t,i)=>(_(),u(`div`,{class:`h-72 w-full`,role:`img`,"aria-label":e.ariaLabel,"aria-describedby":n},[m(p(Jc),{data:f.value,options:g.value},null,8,[`data`,`options`]),l(`p`,{id:n,class:`sr-only`},r(a.value),1)],8,Xc))}});export{S as n,Zc as t};",
		),
	},
	"TryLongerRangeButton-CjkUnaOz.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"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",
		),
	},
	"badge-DUiBTDyA.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"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",
		),
	},
	"burndown-Bz44x7-d.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"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",
		),
	},
	"catalog-lU41irIq.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"aW1wb3J0e190IGFzIGUsYiBhcyB0LHggYXMgbix5IGFzIHJ9ZnJvbSIuL1NrZWxldG9uLUIwemlCNk9kLmpzIjt2YXIgaT0zZTUsYT1lKGBjYXRhbG9nYCx7c3RhdGU6KCk9Pih7ZGF0YTpudWxsLGZldGNoZWRBdDpudWxsLGxvYWRpbmc6ITEsZXJyb3I6YGAscmVxSWQ6MH0pLGdldHRlcnM6e3N0YWxlKGUpe3JldHVybiFlLmZldGNoZWRBdHx8RGF0ZS5ub3coKS1lLmZldGNoZWRBdC5nZXRUaW1lKCk+aX0sbW9kZWxzQnlJZChlKXtsZXQgdD1uZXcgTWFwO2ZvcihsZXQgbiBvZiBlLmRhdGE/LnByb3ZpZGVycz8/W10pZm9yKGxldCBlIG9mIG4ubW9kZWxzKXQuc2V0KGUuaWQsZSk7cmV0dXJuIHR9fSxhY3Rpb25zOnthc3luYyBlbnN1cmVMb2FkZWQoZT0hMSl7IWUmJnRoaXMuZGF0YSYmIXRoaXMuc3RhbGV8fGF3YWl0IHRoaXMuZmV0Y2goKX0sYXN5bmMgZmV0Y2goKXtpZighbigpLmlzQXV0aGVudGljYXRlZClyZXR1cm47bGV0IGU9Kyt0aGlzLnJlcUlkO3RoaXMubG9hZGluZz0hMDt0cnl7bGV0IG49YXdhaXQgdChgL2FkbWluL2FwaS9jYXRhbG9nYCk7aWYoZSE9PXRoaXMucmVxSWQpcmV0dXJuO3RoaXMuZGF0YT1uLHRoaXMuZmV0Y2hlZEF0PW5ldyBEYXRlLHRoaXMuZXJyb3I9YGB9Y2F0Y2godCl7aWYoZSE9PXRoaXMucmVxSWR8fHQgaW5zdGFuY2VvZiByJiYodC5zdGF0dXM9PT00MDF8fHQuc3RhdHVzPT09NDAzKSlyZXR1cm47dGhpcy5lcnJvcj10IGluc3RhbmNlb2YgRXJyb3I/dC5tZXNzYWdlOlN0cmluZyh0KX1maW5hbGx5e2U9PT10aGlzLnJlcUlkJiYodGhpcy5sb2FkaW5nPSExKX19fX0pO2V4cG9ydHthIGFzIHR9Ow==",
		),
	},
	"clipboard-B73fZ0c1.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"YXN5bmMgZnVuY3Rpb24gZShlLHQpe2lmKG5hdmlnYXRvci5jbGlwYm9hcmQ/LndyaXRlVGV4dCl0cnl7cmV0dXJuIGF3YWl0IG5hdmlnYXRvci5jbGlwYm9hcmQud3JpdGVUZXh0KGUpLGBjb3BpZWRgfWNhdGNoe31pZighdClyZXR1cm5gZmFpbGVkYDtsZXQgbj1kb2N1bWVudC5jcmVhdGVSYW5nZSgpO24uc2VsZWN0Tm9kZUNvbnRlbnRzKHQpO2xldCByPXdpbmRvdy5nZXRTZWxlY3Rpb24oKTtyZXR1cm4gcj8oci5yZW1vdmVBbGxSYW5nZXMoKSxyLmFkZFJhbmdlKG4pLGBzZWxlY3RlZGApOmBmYWlsZWRgfWV4cG9ydHtlIGFzIHR9Ow==",
		),
	},
	"consumers-CQtEJ9K7.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"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",
		),
	},
	"events-PUxhEega.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"aW1wb3J0e18gYXMgZSxfdCBhcyB0LGIgYXMgbix2IGFzIHIseCBhcyBpLHkgYXMgYX1mcm9tIi4vU2tlbGV0b24tQjB6aUI2T2QuanMiO3ZhciBvPTVlMyxzPTIwMCxjPXQoYGV2ZW50c2Ase3N0YXRlOigpPT4oe2V2ZW50czpbXSxzb3VyY2U6YHJlcGxpY2FgLHJlcGxpY2E6YGAsY2FwYWNpdHk6MCxkZWdyYWRlZDohMSxsYXN0VXBkYXRlZDpudWxsLGVycm9yOmBgLGtpbmRGaWx0ZXI6YGAsdXNlckZpbHRlcjpgYCxwb2xsZXI6dm9pZCAwLHJlZnJlc2hpbmc6ITEsdG9hc3RlZEZvckZhaWx1cmU6ITF9KSxhY3Rpb25zOnthc3luYyByZWZyZXNoKCl7aWYoIWkoKS5pc0F1dGhlbnRpY2F0ZWR8fHRoaXMucmVmcmVzaGluZylyZXR1cm47dGhpcy5yZWZyZXNoaW5nPSEwO2xldCB0PXRoaXMubGFzdFVwZGF0ZWQhPT1udWxsO3RyeXtsZXQgZT1hd2FpdCBuKGAvYWRtaW4vYXBpL2V2ZW50cz9saW1pdD0ke3N9YCk7dGhpcy5ldmVudHM9ZS5ldmVudHMsdGhpcy5zb3VyY2U9ZS5zb3VyY2UsdGhpcy5yZXBsaWNhPWUucmVwbGljYSx0aGlzLmNhcGFjaXR5PWUuY2FwYWNpdHksdGhpcy5kZWdyYWRlZD1lLmRlZ3JhZGVkPz8hMSx0aGlzLmxhc3RVcGRhdGVkPW5ldyBEYXRlLHRoaXMuZXJyb3I9YGAsdGhpcy50b2FzdGVkRm9yRmFpbHVyZT0hMX1jYXRjaChuKXtpZihuIGluc3RhbmNlb2YgYSYmKG4uc3RhdHVzPT09NDAxfHxuLnN0YXR1cz09PTQwMykpcmV0dXJuO3RoaXMuZXJyb3I9biBpbnN0YW5jZW9mIEVycm9yP24ubWVzc2FnZTpTdHJpbmcobiksdCYmIXRoaXMudG9hc3RlZEZvckZhaWx1cmUmJmUoKS5wdXNoKHtraW5kOmBlcnJvcmAsbWVzc2FnZTpgRXZlbnRzIHJlZnJlc2ggZmFpbGVkOiAke3RoaXMuZXJyb3J9YH0pLHRoaXMudG9hc3RlZEZvckZhaWx1cmU9ITB9ZmluYWxseXt0aGlzLnJlZnJlc2hpbmc9ITF9fSxzZXRLaW5kRmlsdGVyKGUpe3RoaXMua2luZEZpbHRlcj1lfSxzZXRVc2VyRmlsdGVyKGUpe3RoaXMudXNlckZpbHRlcj1lfSxzdGFydFBvbGxpbmcoKXt0aGlzLnBvbGxlcnx8KHRoaXMucG9sbGVyPXIoe2ludGVydmFsTXM6byx0aWNrOigpPT52b2lkIHRoaXMucmVmcmVzaCgpfSksdGhpcy5wb2xsZXIuc3RhcnQoKSl9LHN0b3BQb2xsaW5nKCl7dGhpcy5wb2xsZXI/LnN0b3AoKSx0aGlzLnBvbGxlcj12b2lkIDB9fX0pO2V4cG9ydHtjIGFzIHR9Ow==",
		),
	},
	"events-filter-XFnjIaR7.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"dmFyIGU9e3JhdGVfbGltaXQ6YFJhdGUgbGltaXRgLGJ1ZGdldDpgQnVkZ2V0YCxzdG9yZV9kb3duOmBTdG9yZSBkb3duYCx1cHN0cmVhbTpgVXBzdHJlYW0gZXJyb3JgLHRpbWVvdXQ6YFRpbWVvdXRgLHVucHJpY2VkOmBVbnByaWNlZCBtb2RlbGAsY2FwYWNpdHk6YENhcGFjaXR5YH0sdD1PYmplY3Qua2V5cyhlKTtmdW5jdGlvbiBuKGUpe3N3aXRjaChlKXtjYXNlYHJhdGVfbGltaXRgOmNhc2VgYnVkZ2V0YDpjYXNlYGNhcGFjaXR5YDpyZXR1cm5gZGVzdHJ1Y3RpdmVgO2Nhc2Vgc3RvcmVfZG93bmA6Y2FzZWB1cHN0cmVhbWA6Y2FzZWB0aW1lb3V0YDpyZXR1cm5gc2Vjb25kYXJ5YDtkZWZhdWx0OnJldHVybmBvdXRsaW5lYH19ZnVuY3Rpb24gcihlLHQpe2xldCBuPXQua2luZCxyPXQudXNlci50cmltKCkudG9Mb3dlckNhc2UoKTtyZXR1cm4gZS5maWx0ZXIoZT0+e2lmKG4mJmUua2luZCE9PW4pcmV0dXJuITE7aWYoIXIpcmV0dXJuITA7bGV0IHQ9ZS51c2VyPy50b0xvd2VyQ2FzZSgpLmluY2x1ZGVzKHIpPz8hMSxpPWUuZ3JvdXA/LnRvTG93ZXJDYXNlKCkuaW5jbHVkZXMocik/PyExO3JldHVybiB0fHxpfSl9ZXhwb3J0e3IgYXMgaSxlIGFzIG4sbiBhcyByLHR9Ow==",
		),
	},
	"index-BD5bBisO.css": {
		contentType: "text/css; charset=utf-8",
		body: decodeAdminAsset(
			"@keyframes authgate-shake-b6d6fb1e{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-b6d6fb1e]{animation:.4s ease-in-out authgate-shake-b6d6fb1e}}@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-space-y-reverse:0;--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-ease: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);--text-2xl:1.5rem;--text-2xl--line-height:calc(2 / 1.5);--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;--ease-in:cubic-bezier(.4, 0, 1, 1);--ease-out:cubic-bezier(0, 0, .2, 1);--animate-spin:spin 1s linear infinite;--animate-pulse:pulse 2s cubic-bezier(.4, 0, .6, 1) infinite;--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-auto{pointer-events:auto}.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}.inset-x-0{inset-inline:0}.inset-y-0{inset-block:0}.top-1\/2{top:50%}.top-5{top:calc(var(--spacing) * 5)}.top-100{top:calc(var(--spacing) * 100)}.right-1{right:var(--spacing)}.right-1\.5{right:calc(var(--spacing) * 1.5)}.right-2{right:calc(var(--spacing) * 2)}.bottom-0{bottom:0}.left-0{left:0}.left-2\.5{left:calc(var(--spacing) * 2.5)}.z-10{z-index:10}.z-50{z-index:50}.col-span-full{grid-column:1/-1}.container{width:100%}@media (width>=40rem){.container{max-width:40rem}}@media (width>=48rem){.container{max-width:48rem}}@media (width>=64rem){.container{max-width:64rem}}@media (width>=80rem){.container{max-width:80rem}}@media (width>=96rem){.container{max-width:96rem}}.-mx-1\.5{margin-inline:calc(var(--spacing) * -1.5)}.mx-auto{margin-inline:auto}.-mt-1{margin-top:calc(var(--spacing) * -1)}.mt-0\.5{margin-top:calc(var(--spacing) * .5)}.mt-1{margin-top:var(--spacing)}.mt-2{margin-top:calc(var(--spacing) * 2)}.-mr-1{margin-right:calc(var(--spacing) * -1)}.mb-1\.5{margin-bottom:calc(var(--spacing) * 1.5)}.mb-2{margin-bottom:calc(var(--spacing) * 2)}.mb-3{margin-bottom:calc(var(--spacing) * 3)}.ml-1{margin-left:var(--spacing)}.ml-auto{margin-left:auto}.block{display:block}.contents{display:contents}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline{display:inline}.inline-block{display:inline-block}.inline-flex{display:inline-flex}.table{display:table}.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-1\.5{height:calc(var(--spacing) * 1.5)}.h-3{height:calc(var(--spacing) * 3)}.h-4{height:calc(var(--spacing) * 4)}.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-64{height:calc(var(--spacing) * 64)}.h-72{height:calc(var(--spacing) * 72)}.h-\[calc\(100\%-1px\)\]{height:calc(100% - 1px)}.h-full{height:100%}.max-h-\(--reka-select-content-available-height\){max-height:var(--reka-select-content-available-height)}.min-h-\[70vh\]{min-height:70vh}.w-4{width:calc(var(--spacing) * 4)}.w-12{width:calc(var(--spacing) * 12)}.w-14{width:calc(var(--spacing) * 14)}.w-16{width:calc(var(--spacing) * 16)}.w-20{width:calc(var(--spacing) * 20)}.w-24{width:calc(var(--spacing) * 24)}.w-28{width:calc(var(--spacing) * 28)}.w-36{width:calc(var(--spacing) * 36)}.w-40{width:calc(var(--spacing) * 40)}.w-44{width:calc(var(--spacing) * 44)}.w-48{width:calc(var(--spacing) * 48)}.w-56{width:calc(var(--spacing) * 56)}.w-fit{width:fit-content}.w-full{width:100%}.max-w-32{max-width:calc(var(--spacing) * 32)}.max-w-40{max-width:calc(var(--spacing) * 40)}.max-w-full{max-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}.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)}.translate-y-2{--tw-translate-y:calc(var(--spacing) * 2);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,)}.animate-pulse{animation:var(--animate-pulse)}.animate-spin{animation:var(--animate-spin)}.cursor-default{cursor:default}.cursor-pointer{cursor:pointer}.list-disc{list-style-type:disc}.auto-rows-min{grid-auto-rows:min-content}.grid-cols-1{grid-template-columns:repeat(1,minmax(0,1fr))}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-col-reverse{flex-direction:column-reverse}.flex-wrap{flex-wrap:wrap}.items-center{align-items:center}.items-end{align-items:flex-end}.items-start{align-items:flex-start}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.justify-end{justify-content:flex-end}.justify-start{justify-content:flex-start}.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)}:where(.space-y-0\.5>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * .5) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * .5) * calc(1 - var(--tw-space-y-reverse)))}.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)}.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}.overflow-y-hidden{overflow-y:hidden}.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-sm{border-radius:calc(var(--radius) - 4px)}.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)}.border{border-style:var(--tw-border-style);border-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-accent{background-color:var(--accent)}.bg-background{background-color:var(--background)}.bg-bar-amber{background-color:var(--bar-amber)}.bg-card{background-color:var(--card)}.bg-destructive,.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{background-color:var(--muted)}.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-2{padding:calc(var(--spacing) * 2)}.p-3{padding:calc(var(--spacing) * 3)}.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-3{padding-block:calc(var(--spacing) * 3)}.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-1\.5{padding-bottom:calc(var(--spacing) * 1.5)}.pb-2{padding-bottom:calc(var(--spacing) * 2)}.pb-2\.5{padding-bottom:calc(var(--spacing) * 2.5)}.pb-\[calc\(env\(safe-area-inset-bottom\)\+1rem\)\]{padding-bottom:calc(env(safe-area-inset-bottom) + 1rem)}.pl-1\.5{padding-left:calc(var(--spacing) * 1.5)}.pl-2\.5{padding-left:calc(var(--spacing) * 2.5)}.pl-4{padding-left:calc(var(--spacing) * 4)}.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-heading{font-family:var(--font-sans)}.font-mono{font-family:ui-monospace,SF Mono,Cascadia Code,Roboto Mono,Consolas,monospace}.text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.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-words{overflow-wrap:break-word}.break-all{word-break:break-all}.whitespace-nowrap{white-space:nowrap}.whitespace-pre{white-space:pre}.text-accent-foreground{color:var(--accent-foreground)}.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-inherit{color:inherit}.text-muted-foreground,.text-muted-foreground\/40{color:var(--muted-foreground)}@supports (color:color-mix(in lab, red, red)){.text-muted-foreground\/40{color:color-mix(in oklab, var(--muted-foreground) 40%, transparent)}}.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)}.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}.opacity-0{opacity:0}.shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a), 0 4px 6px -4px 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)}.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}.duration-150{--tw-duration:.15s;transition-duration:.15s}.ease-in{--tw-ease:var(--ease-in);transition-timing-function:var(--ease-in)}.ease-out{--tw-ease:var(--ease-out);transition-timing-function:var(--ease-out)}.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\: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-horizontal\/tabs\:max-w-full:is(:where(.group\/tabs):where([data-orientation=horizontal]) *){max-width:100%}.group-data-horizontal\/tabs\:flex-none:is(:where(.group\/tabs):where([data-orientation=horizontal]) *){flex:none}.group-data-horizontal\/tabs\:justify-start:is(:where(.group\/tabs):where([data-orientation=horizontal]) *){justify-content:flex-start}.group-data-horizontal\/tabs\:overflow-x-auto:is(:where(.group\/tabs):where([data-orientation=horizontal]) *){overflow-x:auto}.group-data-horizontal\/tabs\:overflow-y-hidden:is(:where(.group\/tabs):where([data-orientation=horizontal]) *){overflow-y:hidden}.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\:bottom-\[-5px\]:after{content:var(--tw-content);bottom:-5px}.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)}.last\:border-0:last-child{border-style:var(--tw-border-style);border-width:0}.last\:pb-0:last-child{padding-bottom:0}@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\:text-primary:hover{color:var(--primary)}.hover\:underline:hover{text-decoration-line:underline}.hover\:opacity-90:hover{opacity:.9}}.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-2:focus-visible{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + 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-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\:outline-none:focus-visible{--tw-outline-style:none;outline-style:none}.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\=alert-description\]\:text-status-warn\/90>*)[data-slot=alert-description]{color:var(--status-warn)}@supports (color:color-mix(in lab, red, red)){:is(.\*\:data-\[slot\=alert-description\]\:text-status-warn\/90>*)[data-slot=alert-description]{color:color-mix(in oklab, var(--status-warn) 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 (prefers-reduced-motion:reduce){.motion-reduce\:animate-none{animation:none}.motion-reduce\:transition-none{transition-property:none}}@media (width>=40rem){.sm\:inset-x-auto{inset-inline:auto}.sm\:right-4{right:calc(var(--spacing) * 4)}.sm\:bottom-4{bottom:calc(var(--spacing) * 4)}.sm\:w-96{width:calc(var(--spacing) * 96)}.sm\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.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\:grid-cols-5{grid-template-columns:repeat(5,minmax(0,1fr))}.sm\:flex-row{flex-direction:row}.sm\:items-center{align-items:center}.sm\:items-end{align-items:flex-end}.sm\:items-start{align-items:flex-start}.sm\:justify-between{justify-content:space-between}.sm\:px-6{padding-inline:calc(var(--spacing) * 6)}}@media (width>=48rem){.md\:w-52{width:calc(var(--spacing) * 52)}.md\:w-full{width:100%}.md\:shrink-0{flex-shrink:0}.md\:flex-col{flex-direction:column}.md\:flex-row{flex-direction:row}.md\:border-r{border-right-style:var(--tw-border-style);border-right-width:1px}.md\:border-b-0{border-bottom-style:var(--tw-border-style);border-bottom-width:0}.md\:pr-3{padding-right:calc(var(--spacing) * 3)}.md\:pb-0{padding-bottom:0}.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\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.lg\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.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}}@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;--chart-series-a:#56b4e9;--chart-series-b:#8a6d00;--chart-series-c:#cc79a7;--chart-series-d:#4d4d4d;--status-warn:#a35c00;--bar-amber:#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;--chart-series-a:#56b4e9;--chart-series-b:#f0e442;--chart-series-c:#cc79a7;--chart-series-d:#b8b8b8;--status-warn:#f0ac1f;--bar-amber:#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-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@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-ease{syntax:"*";inherits:false}@property --tw-content{syntax:"*";inherits:false;initial-value:""}@keyframes spin{to{transform:rotate(360deg)}}@keyframes pulse{50%{opacity:.5}}@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-dywS8OpT.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/HomePage-xxao-DzQ.js","assets/Skeleton-B0ziB6Od.js","assets/tabs-YlhnHpK-.js","assets/useId-B9dJumoI.js","assets/ErrorState-ym6eSlj2.js","assets/badge-DUiBTDyA.js","assets/TryLongerRangeButton-CjkUnaOz.js","assets/SkeletonList-Cmqz3hfa.js","assets/EntityLink-Dg93KGVT.js","assets/events-PUxhEega.js","assets/events-filter-XFnjIaR7.js","assets/kpi-chm3BiuF.js","assets/provider-rate-DU7OgSeB.js","assets/SpendPage-6ZX2q3Zv.js","assets/DataTable-CQxRVDSY.js","assets/CompactNumber-pr8cJ4cv.js","assets/burndown-Bz44x7-d.js","assets/clipboard-B73fZ0c1.js","assets/ClampedRangeNotice-D2walnXf.js","assets/TimeSeriesChart-BFcT6woA.js","assets/catalog-lU41irIq.js","assets/series-NIRVBXMP.js","assets/ConsumersPage-i8sZV9MX.js","assets/search-expand-CHd4FWZZ.js","assets/consumers-CQtEJ9K7.js","assets/useSearchQuery-bQZP4TsZ.js","assets/ModelsPage-CcA1RHK6.js","assets/reliability-CFIkRxVV.js","assets/ReliabilityPage-6-bz5x6z.js","assets/ConfigPage-7IYcafPw.js","assets/TargetsPage-DYUVhhsj.js"])))=>i.map(i=>d[i]);
import{a as e,i as t,n,o as r,r as i,s as a,t as o}from"./useId-B9dJumoI.js";import{$ as s,A as c,Ar as l,B as u,Bn as d,C as f,D as p,Dn as m,E as h,F as g,Fr as _,G as v,H as y,Hn as b,Ht as x,I as S,In as C,Jt as w,Kn as T,L as E,Lr as ee,M as D,Mr as te,N as ne,O as re,On as O,P as ie,Qr as ae,Qt as oe,R as se,Rr as ce,S as le,Si as k,St as ue,T as de,Tn as fe,U as pe,Un as A,V as me,Vt as he,W as ge,X as _e,Xn as ve,Z as ye,_ as be,_n as j,_t as xe,a as Se,an as M,at as Ce,bi as we,bt as Te,ci as Ee,cn as N,cr as De,ei as Oe,er as ke,fr as Ae,g as je,gi as P,gn as Me,gt as Ne,h as Pe,hn as F,ht as Fe,i as Ie,ii as Le,in as I,ir as Re,j as ze,jr as L,k as Be,l as Ve,li as He,lr as R,lt as Ue,m as We,mi as Ge,mn as Ke,mt as qe,n as Je,nr as z,nt as Ye,o as Xe,oi as B,on as V,ot as Ze,p as Qe,pi as $e,q as et,qr as tt,r as nt,sn as H,t as rt,ti as it,tt as at,u as ot,ur as st,w as ct,x as lt,xi as ut,yi as dt,z as ft,zt as pt}from"./Skeleton-B0ziB6Od.js";function mt(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 ht(e){if(Array.isArray(e))return e}function gt(e){if(Array.isArray(e))return mt(e)}function _t(e,t){if(!(e instanceof t))throw TypeError(`Cannot call a class as a function`)}function vt(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,kt(r.key),r)}}function yt(e,t,n){return t&&vt(e.prototype,t),n&&vt(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function bt(e,t){var n=typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(!n){if(Array.isArray(e)||(n=jt(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 U(e,t,n){return(t=kt(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function xt(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function St(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 Ct(){throw TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function wt(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Tt(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 W(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Tt(Object(n),!0).forEach(function(t){U(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Tt(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function Et(e,t){return ht(e)||St(e,t)||jt(e,t)||Ct()}function Dt(e){return gt(e)||xt(e)||jt(e)||wt()}function Ot(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 kt(e){var t=Ot(e,`string`);return typeof t==`symbol`?t:t+``}function At(e){"@babel/helpers - typeof";return At=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},At(e)}function jt(e,t){if(e){if(typeof e==`string`)return mt(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)?mt(e,t):void 0}}var Mt=function(){},Nt={},Pt={},Ft=null,It={mark:Mt,measure:Mt};try{typeof window<`u`&&(Nt=window),typeof document<`u`&&(Pt=document),typeof MutationObserver<`u`&&(Ft=MutationObserver),typeof performance<`u`&&(It=performance)}catch{}var Lt=(Nt.navigator||{}).userAgent,Rt=Lt===void 0?``:Lt,zt=Nt,G=Pt,Bt=Ft,Vt=It;zt.document;var Ht=!!G.documentElement&&!!G.head&&typeof G.addEventListener==`function`&&typeof G.createElement==`function`,Ut=~Rt.indexOf(`MSIE`)||~Rt.indexOf(`Trident/`),Wt,Gt=/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)?[\-\ ]/,Kt=/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,qt={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`}},Jt={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},Yt=[`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`],K=`classic`,Xt=`duotone`,Zt=`sharp`,Qt=`sharp-duotone`,$t=`chisel`,en=`etch`,tn=`graphite`,nn=`jelly`,rn=`jelly-duo`,an=`jelly-fill`,on=`mosaic`,sn=`notdog`,cn=`notdog-duo`,ln=`pixel`,un=`slab`,dn=`slab-duo`,fn=`slab-press`,pn=`slab-press-duo`,mn=`thumbprint`,hn=`utility`,gn=`utility-duo`,_n=`utility-fill`,vn=`vellum`,yn=`whiteboard`,bn=`Classic`,xn=`Duotone`,Sn=`Sharp`,Cn=`Sharp Duotone`,wn=`Chisel`,Tn=`Etch`,En=`Graphite`,Dn=`Jelly`,On=`Jelly Duo`,kn=`Jelly Fill`,An=`Mosaic`,jn=`Notdog`,Mn=`Notdog Duo`,Nn=`Pixel`,Pn=`Slab`,Fn=`Slab Duo`,In=`Slab Press`,Ln=`Slab Press Duo`,Rn=`Thumbprint`,zn=`Utility`,Bn=`Utility Duo`,Vn=`Utility Fill`,Hn=`Vellum`,Un=`Whiteboard`,Wn=[K,Xt,Zt,Qt,$t,en,tn,nn,rn,an,on,sn,cn,ln,un,dn,fn,pn,mn,hn,gn,_n,vn,yn];Wt={},U(U(U(U(U(U(U(U(U(U(Wt,K,bn),Xt,xn),Zt,Sn),Qt,Cn),$t,wn),en,Tn),tn,En),nn,Dn),rn,On),an,kn),U(U(U(U(U(U(U(U(U(U(Wt,on,An),sn,jn),cn,Mn),ln,Nn),un,Pn),dn,Fn),fn,In),pn,Ln),mn,Rn),hn,zn),U(U(U(U(Wt,gn,Bn),_n,Vn),vn,Hn),yn,Un);var Gn={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`}},Kn={"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`}},qn=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}]]),Jn={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`}},Yn=[`fak`,`fa-kit`,`fakd`,`fa-kit-duotone`],Xn={kit:{fak:`kit`,"fa-kit":`kit`},"kit-duotone":{fakd:`kit-duotone`,"fa-kit-duotone":`kit-duotone`}},Zn=[`kit`];U(U({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var Qn={kit:{"fa-kit":`fak`},"kit-duotone":{"fa-kit-duotone":`fakd`}},$n={"Font Awesome Kit":{400:`fak`,normal:`fak`},"Font Awesome Kit Duotone":{400:`fakd`,normal:`fakd`}},er={kit:{fak:`fa-kit`},"kit-duotone":{fakd:`fa-kit-duotone`}},tr={kit:{kit:`fak`},"kit-duotone":{"kit-duotone":`fakd`}},nr,rr={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},ir=[`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`];nr={},U(U(U(U(U(U(U(U(U(U(nr,`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`),U(U(U(U(U(U(U(U(U(U(nr,`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`),U(U(U(U(nr,`utility-duo`,`Utility Duo`),`utility-fill`,`Utility Fill`),`vellum`,`Vellum`),`whiteboard`,`Whiteboard`),U(U({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var ar={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`}},or={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`]},sr={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`}},cr=`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(ir,[`fa-solid`,`fa-regular`,`fa-light`,`fa-thin`,`fa-duotone`,`fa-brands`,`fa-semibold`]),lr=[`solid`,`regular`,`light`,`thin`,`duotone`,`brands`,`semibold`],ur=[1,2,3,4,5,6,7,8,9,10],dr=ur.concat([11,12,13,14,15,16,17,18,19,20]),fr=[].concat(Dt(Object.keys(or)),lr,[`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`,rr.GROUP,rr.SWAP_OPACITY,rr.PRIMARY,rr.SECONDARY],ur.map(function(e){return`${e}x`}),dr.map(function(e){return`w-${e}`})),pr={"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`}},mr=`___FONT_AWESOME___`,hr=16,gr=`fa`,_r=`svg-inline--fa`,vr=`data-fa-i2svg`,yr=`data-fa-pseudo-element`,br=`data-fa-pseudo-element-pending`,xr=`data-prefix`,Sr=`data-icon`,Cr=`fontawesome-i2svg`,wr=`async`,Tr=[`HTML`,`HEAD`,`STYLE`,`SCRIPT`],Er=[`::before`,`::after`,`:before`,`:after`],Dr=function(){try{return!0}catch{return!1}}();function Or(e){return new Proxy(e,{get:function(e,t){return t in e?e[t]:e[K]}})}var kr=W({},qt);kr[K]=W(W(W(W({},{"fa-duotone":`duotone`}),qt[K]),Xn.kit),Xn[`kit-duotone`]);var Ar=Or(kr),jr=W({},Jn);jr[K]=W(W(W(W({},{duotone:`fad`}),jr[K]),tr.kit),tr[`kit-duotone`]);var Mr=Or(jr),Nr=W({},sr);Nr[K]=W(W({},Nr[K]),er.kit);var Pr=Or(Nr),Fr=W({},ar);Fr[K]=W(W({},Fr[K]),Qn.kit),Or(Fr);var Ir=Gt,Lr=`fa-layers-text`,Rr=Kt;Or(W({},Gn));var zr=[`class`,`data-prefix`,`data-icon`,`data-fa-transform`,`data-fa-mask`],Br=Jt,Vr=[].concat(Dt(Zn),Dt(fr)),Hr=zt.FontAwesomeConfig||{};function Ur(e){var t=G.querySelector(`script[`+e+`]`);if(t)return t.getAttribute(e)}function Wr(e){return e===``?!0:e===`false`?!1:e===`true`||e}G&&typeof G.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=Et(e,2),n=t[0],r=t[1],i=Wr(Ur(n));i!=null&&(Hr[r]=i)});var Gr={styleDefault:`solid`,familyDefault:K,cssPrefix:gr,replacementClass:_r,autoReplaceSvg:!0,autoAddCss:!0,searchPseudoElements:!1,searchPseudoElementsWarnings:!0,searchPseudoElementsFullScan:!1,observeMutations:!0,mutateApproach:`async`,keepOriginalSource:!0,measurePerformance:!1,showMissingIcons:!0};Hr.familyPrefix&&(Hr.cssPrefix=Hr.familyPrefix);var Kr=W(W({},Gr),Hr);Kr.autoReplaceSvg||(Kr.observeMutations=!1);var q={};Object.keys(Gr).forEach(function(e){Object.defineProperty(q,e,{enumerable:!0,set:function(t){Kr[e]=t,qr.forEach(function(e){return e(q)})},get:function(){return Kr[e]}})}),Object.defineProperty(q,"familyPrefix",{enumerable:!0,set:function(e){Kr.cssPrefix=e,qr.forEach(function(e){return e(q)})},get:function(){return Kr.cssPrefix}}),zt.FontAwesomeConfig=q;var qr=[];function Jr(e){return qr.push(e),function(){qr.splice(qr.indexOf(e),1)}}var Yr=hr,Xr={size:16,x:0,y:0,rotate:0,flipX:!1,flipY:!1};function Zr(e){if(!(!e||!Ht)){var t=G.createElement(`style`);t.setAttribute(`type`,`text/css`),t.innerHTML=e;for(var n=G.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 G.head.insertBefore(t,r),e}}var Qr=`0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`;function $r(){for(var e=12,t=``;e-->0;)t+=Qr[Math.random()*62|0];return t}function ei(e){for(var t=[],n=(e||[]).length>>>0;n--;)t[n]=e[n];return t}function ti(e){return e.classList?ei(e.classList):(e.getAttribute(`class`)||``).split(` `).filter(function(e){return e})}function ni(e){return`${e}`.replace(/&/g,`&amp;`).replace(/"/g,`&quot;`).replace(/'/g,`&#39;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`)}function ri(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}="${ni(e[n])}" `},``).trim()}function ii(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}: ${e[n].trim()};`},``)}function ai(e){return e.size!==Xr.size||e.x!==Xr.x||e.y!==Xr.y||e.rotate!==Xr.rotate||e.flipX||e.flipY}function oi(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 si(e){var t=e.transform,n=e.width,r=n===void 0?hr:n,i=e.height,a=i===void 0?hr:i,o=e.startCentered,s=o!==void 0&&o,c=``;return c+=s&&Ut?`translate(${t.x/Yr-r/2}em, ${t.y/Yr-a/2}em) `:s?`translate(calc(-50% + ${t.x/Yr}em), calc(-50% + ${t.y/Yr}em)) `:`translate(${t.x/Yr}em, ${t.y/Yr}em) `,c+=`scale(${t.size/Yr*(t.flipX?-1:1)}, ${t.size/Yr*(t.flipY?-1:1)}) `,c+=`rotate(${t.rotate}deg) `,c}var ci=`: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 li(){var e=gr,t=_r,n=q.cssPrefix,r=q.replacementClass,i=ci;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 ui=!1;function di(){q.autoAddCss&&!ui&&(Zr(li()),ui=!0)}var fi={mixout:function(){return{dom:{css:li,insertCss:di}}},hooks:function(){return{beforeDOMElementCreation:function(){di()},beforeI2svg:function(){di()}}}},pi=zt||{};pi[mr]||(pi[mr]={}),pi[mr].styles||(pi[mr].styles={}),pi[mr].hooks||(pi[mr].hooks={}),pi[mr].shims||(pi[mr].shims=[]);var mi=pi[mr],hi=[],gi=function(){G.removeEventListener(`DOMContentLoaded`,gi),_i=1,hi.map(function(e){return e()})},_i=!1;Ht&&(_i=(G.documentElement.doScroll?/^loaded|^c/:/^loaded|^i|^c/).test(G.readyState),_i||G.addEventListener(`DOMContentLoaded`,gi));function vi(e){Ht&&(_i?setTimeout(e,0):hi.push(e))}function yi(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`?ni(e):`<${t} ${ri(r)}>${a.map(yi).join(``)}</${t}>`}function bi(e,t,n){if(e&&e[t]&&e[t][n])return{prefix:t,iconName:n,icon:e[t][n]}}var xi=function(e,t){return function(n,r,i,a){return e.call(t,n,r,i,a)}},Si=function(e,t,n,r){var i=Object.keys(e),a=i.length,o=r===void 0?t:xi(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 Ci(e){return Dt(e).length===1?e.codePointAt(0).toString(16):null}function wi(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 Ti(e,t){var n=(arguments.length>2&&arguments[2]!==void 0?arguments[2]:{}).skipHooks,r=n!==void 0&&n,i=wi(t);typeof mi.hooks.addPack==`function`&&!r?mi.hooks.addPack(e,wi(t)):mi.styles[e]=W(W({},mi.styles[e]||{}),i),e===`fas`&&Ti(`fa`,t)}var Ei=mi.styles,Di=mi.shims,Oi=Object.keys(Pr),ki=Oi.reduce(function(e,t){return e[t]=Object.keys(Pr[t]),e},{}),Ai=null,ji={},Mi={},Ni={},Pi={},Fi={};function Ii(e){return~Vr.indexOf(e)}function Li(e,t){var n=t.split(`-`),r=n[0],i=n.slice(1).join(`-`);return r===e&&i!==``&&!Ii(i)?i:null}var Ri=function(){var e=function(e){return Si(Ei,function(t,n,r){return t[r]=Si(n,e,{}),t},{})};ji=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}),Mi=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}),Fi=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 Ei||q.autoFetchSvg,n=Si(Di,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:{}});Ni=n.names,Pi=n.unicodes,Ai=qi(q.styleDefault,{family:q.familyDefault})};Jr(function(e){Ai=qi(e.styleDefault,{family:q.familyDefault})}),Ri();function zi(e,t){return(ji[e]||{})[t]}function Bi(e,t){return(Mi[e]||{})[t]}function Vi(e,t){return(Fi[e]||{})[t]}function Hi(e){return Ni[e]||{prefix:null,iconName:null}}function Ui(e){var t=Pi[e],n=zi(`fas`,e);return t||(n?{prefix:`fas`,iconName:n}:null)||{prefix:null,iconName:null}}function Wi(){return Ai}var Gi=function(){return{prefix:null,iconName:null,rest:[]}};function Ki(e){var t=K,n=Oi.reduce(function(e,t){return e[t]=`${q.cssPrefix}-${t}`,e},{});return Wn.forEach(function(r){(e.includes(n[r])||e.some(function(e){return ki[r].includes(e)}))&&(t=r)}),t}function qi(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).family,n=t===void 0?K:t,r=Ar[n][e];if(n===Xt&&!e)return`fad`;var i=Mr[n][e]||Mr[n][r],a=e in mi.styles?e:null;return i||a||null}function Ji(e){var t=[],n=null;return e.forEach(function(e){var r=Li(q.cssPrefix,e);r?n=r:e&&t.push(e)}),{iconName:n,rest:t}}function Yi(e){return e.sort().filter(function(e,t,n){return n.indexOf(e)===t})}var Xi=cr.concat(Yn);function Zi(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).skipLookups,n=t!==void 0&&t,r=null,i=Yi(e.filter(function(e){return Xi.includes(e)})),a=Yi(e.filter(function(e){return!Xi.includes(e)})),o=Et(i.filter(function(e){return r=e,!Yt.includes(e)}),1)[0],s=o===void 0?null:o,c=Ki(i),l=W(W({},Ji(a)),{},{prefix:qi(s,{family:c})});return W(W(W({},l),ta({values:e,family:c,styles:Ei,config:q,canonical:l,givenPrefix:r})),Qi(n,r,l))}function Qi(e,t,n){var r=n.prefix,i=n.iconName;if(e||!r||!i)return{prefix:r,iconName:i};var a=t===`fa`?Hi(i):{},o=Vi(r,i);return i=a.iconName||o||i,r=a.prefix||r,r===`far`&&!Ei.far&&Ei.fas&&!q.autoFetchSvg&&(r=`fas`),{prefix:r,iconName:i}}var $i=Wn.filter(function(e){return e!==K||e!==Xt}),ea=Object.keys(sr).filter(function(e){return e!==K}).map(function(e){return Object.keys(sr[e])}).flat();function ta(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===Xt,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&&$i.includes(n)&&(Object.keys(s).find(function(e){return ea.includes(e)})||l.autoFetchSvg)&&(r.prefix=qn.get(n).defaultShortPrefixId,r.iconName=Vi(r.prefix,r.iconName)||r.iconName),(r.prefix===`fa`||a===`fa`)&&(r.prefix=Wi()||`fas`),r}var na=function(){function e(){_t(this,e),this.definitions={}}return yt(e,[{key:`add`,value:function(){var e=this,t=[...arguments].reduce(this._pullDefinitions,{});Object.keys(t).forEach(function(n){e.definitions[n]=W(W({},e.definitions[n]||{}),t[n]),Ti(n,t[n]);var r=Pr[K][n];r&&Ti(r,t[n]),Ri()})}},{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}}])}(),ra=[],ia={},aa={},oa=Object.keys(aa);function sa(e,t){var n=t.mixoutsTo;return ra=e,ia={},Object.keys(aa).forEach(function(e){oa.indexOf(e)===-1&&delete aa[e]}),ra.forEach(function(e){var t=e.mixout?e.mixout():{};if(Object.keys(t).forEach(function(e){typeof t[e]==`function`&&(n[e]=t[e]),At(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){ia[e]||(ia[e]=[]),ia[e].push(r[e])})}e.provides&&e.provides(aa)}),n}function ca(e,t){var n=[...arguments].slice(2);return(ia[e]||[]).forEach(function(e){t=e.apply(null,[t].concat(n))}),t}function la(e){var t=[...arguments].slice(1);(ia[e]||[]).forEach(function(e){e.apply(null,t)})}function ua(){var e=arguments[0],t=Array.prototype.slice.call(arguments,1);return aa[e]?aa[e].apply(null,t):void 0}function da(e){e.prefix===`fa`&&(e.prefix=`fas`);var t=e.iconName,n=e.prefix||Wi();if(t)return t=Vi(n,t)||t,bi(fa.definitions,n,t)||bi(mi.styles,n,t)}var fa=new na,J={noAuto:function(){q.autoReplaceSvg=!1,q.observeMutations=!1,la(`noAuto`)},config:q,dom:{i2svg:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return Ht?(la(`beforeI2svg`,e),ua(`pseudoElements2svg`,e),ua(`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,vi(function(){pa({autoReplaceSvgRoot:t}),la(`watch`,e)})}},parse:{icon:function(e){if(e===null)return null;if(At(e)===`object`&&e.prefix&&e.iconName)return{prefix:e.prefix,iconName:Vi(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=qi(e[0]);return{prefix:n,iconName:Vi(n,t)||t}}if(typeof e==`string`&&(e.indexOf(`${q.cssPrefix}-`)>-1||e.match(Ir))){var r=Zi(e.split(` `),{skipLookups:!0});return{prefix:r.prefix||Wi(),iconName:Vi(r.prefix,r.iconName)||r.iconName}}if(typeof e==`string`){var i=Wi();return{prefix:i,iconName:Vi(i,e)||e}}}},library:fa,findIconDefinition:da,toHtml:yi},pa=function(){var e=(arguments.length>0&&arguments[0]!==void 0?arguments[0]:{}).autoReplaceSvgRoot,t=e===void 0?G:e;(Object.keys(mi.styles).length>0||q.autoFetchSvg)&&Ht&&q.autoReplaceSvg&&J.dom.i2svg({node:t})};function ma(e,t){return Object.defineProperty(e,"abstract",{get:t}),Object.defineProperty(e,"html",{get:function(){return e.abstract.map(function(e){return yi(e)})}}),Object.defineProperty(e,"node",{get:function(){if(Ht){var t=G.createElement(`div`);return t.innerHTML=e.html,t.children}}}),e}function ha(e){var t=e.children,n=e.main,r=e.mask,i=e.attributes,a=e.styles,o=e.transform;if(ai(o)&&n.found&&!r.found){var s={x:n.width/n.height/2,y:.5};i.style=ii(W(W({},a),{},{"transform-origin":`${s.x+o.x/16}em ${s.y+o.y/16}em`}))}return[{tag:`svg`,attributes:i,children:t}]}function ga(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:W(W({},i),{},{id:o}),children:r}]}]}function _a(e){return[`aria-label`,`aria-labelledby`,`title`,`role`].some(function(t){return t in e})}function va(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:W(W({},l.attributes),{},{"data-prefix":i,"data-icon":a,class:h,role:l.attributes.role||`img`,viewBox:`0 0 ${p} ${m}`})};!_a(l.attributes)&&!l.attributes[`aria-hidden`]&&(g.attributes[`aria-hidden`]=`true`),d&&(g.attributes[vr]=``);var _=W(W({},g),{},{prefix:i,iconName:a,main:n,mask:r,maskId:c,transform:o,symbol:s,styles:W({},l.styles)}),v=r.found&&n.found?ua(`generateAbstractMask`,_)||{children:[],attributes:{}}:ua(`generateAbstractIcon`,_)||{children:[],attributes:{}},y=v.children,b=v.attributes;return _.children=y,_.attributes=b,s?ga(_):ha(_)}function ya(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=W(W({},a.attributes),{},{class:a.classes.join(` `)});s&&(c[vr]=``);var l=W({},a.styles);ai(i)&&(l.transform=si({transform:i,startCentered:!0,width:n,height:r}),l[`-webkit-transform`]=l.transform);var u=ii(l);u.length>0&&(c.style=u);var d=[];return d.push({tag:`span`,attributes:c,children:[t]}),d}function ba(e){var t=e.content,n=e.extra,r=W(W({},n.attributes),{},{class:n.classes.join(` `)}),i=ii(n.styles);i.length>0&&(r.style=i);var a=[];return a.push({tag:`span`,attributes:r,children:[t]}),a}var xa=mi.styles;function Sa(e){var t=e[0],n=e[1],r=Et(e.slice(4),1)[0],i=null;return i=Array.isArray(r)?{tag:`g`,attributes:{class:`${q.cssPrefix}-${Br.GROUP}`},children:[{tag:`path`,attributes:{class:`${q.cssPrefix}-${Br.SECONDARY}`,fill:`currentColor`,d:r[0]}},{tag:`path`,attributes:{class:`${q.cssPrefix}-${Br.PRIMARY}`,fill:`currentColor`,d:r[1]}}]}:{tag:`path`,attributes:{fill:`currentColor`,d:r}},{found:!0,width:t,height:n,icon:i}}var Ca={found:!1,width:512,height:512};function wa(e,t){!Dr&&!q.showMissingIcons&&e&&console.error(`Icon with name "${e}" and prefix "${t}" is missing.`)}function Ta(e,t){var n=t;return t===`fa`&&q.styleDefault!==null&&(t=Wi()),new Promise(function(r,i){if(n===`fa`){var a=Hi(e)||{};e=a.iconName||e,t=a.prefix||t}if(e&&t&&xa[t]&&xa[t][e]){var o=xa[t][e];return r(Sa(o))}wa(e,t),r(W(W({},Ca),{},{icon:q.showMissingIcons&&e&&ua(`missingIconAbstract`)||{}}))})}var Ea=function(){},Da=q.measurePerformance&&Vt&&Vt.mark&&Vt.measure?Vt:{mark:Ea,measure:Ea},Oa=`FA "7.3.1"`,ka=function(e){return Da.mark(`${Oa} ${e} begins`),function(){return Aa(e)}},Aa=function(e){Da.mark(`${Oa} ${e} ends`),Da.measure(`${Oa} ${e}`,`${Oa} ${e} begins`,`${Oa} ${e} ends`)},ja={begin:ka,end:Aa},Ma=function(){};function Na(e){return typeof(e.getAttribute?e.getAttribute(vr):null)==`string`}function Pa(e){var t=e.getAttribute?e.getAttribute(xr):null,n=e.getAttribute?e.getAttribute(Sr):null;return t&&n}function Fa(e){return e&&e.classList&&e.classList.contains&&e.classList.contains(q.replacementClass)}function Ia(){return q.autoReplaceSvg===!0?Va.replace:Va[q.autoReplaceSvg]||Va.replace}function La(e){return G.createElementNS(`http://www.w3.org/2000/svg`,e)}function Ra(e){return G.createElement(e)}function za(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).ceFn,n=t===void 0?e.tag===`svg`?La:Ra:t;if(typeof e==`string`)return G.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(za(e,{ceFn:n}))}),r}function Ba(e){var t=` ${e.outerHTML} `;return t=`${t}Font Awesome fontawesome.com `,t}var Va={replace:function(e){var t=e[0];if(t.parentNode){if(e[1].forEach(function(e){t.parentNode.insertBefore(za(e),t)}),t.getAttribute(vr)===null&&q.keepOriginalSource){var n=G.createComment(Ba(t));t.parentNode.replaceChild(n,t)}else t.remove()}},nest:function(e){var t=e[0],n=e[1];if(~ti(t).indexOf(q.replacementClass))return Va.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 yi(e)}).join(`
`);t.setAttribute(vr,``),t.innerHTML=a}};function Ha(e){e()}function Ua(e,t){var n=typeof t==`function`?t:Ma;if(e.length===0)n();else{var r=Ha;q.mutateApproach===wr&&(r=zt.requestAnimationFrame||Ha),r(function(){var t=Ia(),r=ja.begin(`mutate`);e.map(t),r(),n()})}}var Wa=!1;function Ga(){Wa=!0}function Ka(){Wa=!1}var qa=null;function Ja(e){if(Bt&&q.observeMutations){var t=e.treeCallback,n=t===void 0?Ma:t,r=e.nodeCallback,i=r===void 0?Ma:r,a=e.pseudoElementsCallback,o=a===void 0?Ma:a,s=e.observeMutationsRoot,c=s===void 0?G:s;qa=new Bt(function(e){if(!Wa){var t=Wi();ei(e).forEach(function(e){if(e.type===`childList`&&e.addedNodes.length>0&&!Na(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`&&Na(e.target)&&~zr.indexOf(e.attributeName)){if(e.attributeName===`class`&&Pa(e.target)){var r=Zi(ti(e.target)),a=r.prefix,s=r.iconName;e.target.setAttribute(xr,a||t),s&&e.target.setAttribute(Sr,s)}else Fa(e.target)&&i(e.target)}})}}),Ht&&qa.observe(c,{childList:!0,attributes:!0,characterData:!0,subtree:!0})}}function Ya(){qa&&qa.disconnect()}function Xa(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 Za(e){var t=e.getAttribute(`data-prefix`),n=e.getAttribute(`data-icon`),r=e.innerText===void 0?``:e.innerText.trim(),i=Zi(ti(e));return i.prefix||=Wi(),t&&n&&(i.prefix=t,i.iconName=n),i.iconName&&i.prefix?i:(i.prefix&&r.length>0&&(i.iconName=Bi(i.prefix,e.innerText)||zi(i.prefix,Ci(e.innerText))),!i.iconName&&q.autoFetchSvg&&e.firstChild&&e.firstChild.nodeType===Node.TEXT_NODE&&(i.iconName=e.firstChild.data),i)}function Qa(e){return ei(e.attributes).reduce(function(e,t){return e.name!==`class`&&e.name!==`style`&&(e[t.name]=t.value),e},{})}function $a(){return{iconName:null,prefix:null,transform:Xr,symbol:!1,mask:{iconName:null,prefix:null,rest:[]},maskId:null,extra:{classes:[],styles:{},attributes:{}}}}function eo(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{styleParser:!0},n=Za(e),r=n.iconName,i=n.prefix,a=n.rest,o=Qa(e),s=ca(`parseNodeAttributes`,{},e);return W({iconName:r,prefix:i,transform:Xr,mask:{iconName:null,prefix:null,rest:[]},maskId:null,symbol:!1,extra:{classes:a,styles:t.styleParser?Xa(e):[],attributes:o}},s)}var to=mi.styles;function no(e){var t=q.autoReplaceSvg===`nest`?eo(e,{styleParser:!1}):eo(e);return~t.extra.classes.indexOf(Lr)?ua(`generateLayersText`,e,t):ua(`generateSvgReplacementMutation`,e,t)}function ro(){return[].concat(Dt(Yn),Dt(cr))}function io(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(!Ht)return Promise.resolve();var n=G.documentElement.classList,r=function(e){return n.add(`${Cr}-${e}`)},i=function(e){return n.remove(`${Cr}-${e}`)},a=q.autoFetchSvg?ro():Yt.concat(Object.keys(to));a.includes(`fa`)||a.push(`fa`);var o=[`.${Lr}:not([${vr}])`].concat(a.map(function(e){return`.${e}:not([${vr}])`})).join(`, `);if(o.length===0)return Promise.resolve();var s=[];try{s=ei(e.querySelectorAll(o))}catch{}if(s.length>0)r(`pending`),i(`complete`);else return Promise.resolve();var c=ja.begin(`onTree`),l=s.reduce(function(e,t){try{var n=no(t);n&&e.push(n)}catch(e){Dr||e.name===`MissingIcon`&&console.error(e)}return e},[]);return new Promise(function(e,n){Promise.all(l).then(function(n){Ua(n,function(){r(`active`),r(`complete`),i(`pending`),typeof t==`function`&&t(),c(),e()})}).catch(function(e){c(),n(e)})})}function ao(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;no(e).then(function(e){e&&Ua([e],t)})}function oo(e){return function(t){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},r=(t||{}).icon?t:da(t||{}),i=n.mask;return i&&=(i||{}).icon?i:da(i||{}),e(r,W(W({},n),{},{mask:i}))}}var so=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?Xr: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 ma(W({type:`icon`},e),function(){return la(`beforeDOMElementCreation`,{iconDefinition:e,params:t}),va({icons:{main:Sa(v),mask:s?Sa(s.icon):{found:!1,width:null,height:null,icon:{}}},prefix:g,iconName:_,transform:W(W({},Xr),r),symbol:a,maskId:l,extra:{attributes:p,styles:h,classes:d}})})}},co={mixout:function(){return{icon:oo(so)}},hooks:function(){return{mutationObserverCallbacks:function(e){return e.treeCallback=io,e.nodeCallback=ao,e}}},provides:function(e){e.i2svg=function(e){var t=e.node,n=t===void 0?G:t,r=e.callback;return io(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([Ta(n,r),o.iconName?Ta(o.iconName,o.prefix):Promise.resolve({found:!1,width:512,height:512,icon:{}})]).then(function(o){var l=Et(o,2),u=l[0],d=l[1];t([e,va({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=ii(a);o.length>0&&(n.style=o);var s;return ai(i)&&(s=ua(`generateAbstractTransformGrouping`,{main:r,transform:i,containerWidth:r.width,iconWidth:r.width})),t.push(s||r.icon),{children:t,attributes:n}}}},lo={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 ma({type:`layer`},function(){la(`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(Dt(r)).join(` `)},children:n}]})}}}},uo={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 ma({type:`counter`,content:e},function(){return la(`beforeDOMElementCreation`,{content:e,params:t}),ba({content:e.toString(),title:r,extra:{attributes:s,styles:l,classes:[`${q.cssPrefix}-layers-counter`].concat(Dt(a))}})})}}}},fo={mixout:function(){return{text:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?Xr: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 ma({type:`text`,content:e},function(){return la(`beforeDOMElementCreation`,{content:e,params:t}),ya({content:e,transform:W(W({},Xr),r),extra:{attributes:s,styles:l,classes:[`${q.cssPrefix}-layers-text`].concat(Dt(a))}})})}}},provides:function(e){e.generateLayersText=function(e,t){var n=t.transform,r=t.extra,i=null,a=null;if(Ut){var o=parseInt(getComputedStyle(e).fontSize,10),s=e.getBoundingClientRect();i=s.width/o,a=s.height/o}return Promise.resolve([e,ya({content:e.innerHTML,width:i,height:a,transform:n,extra:r,watchable:!0})])}}},po=RegExp(`"`,`ug`),mo=[1105920,1112319],ho=W(W(W(W({},{FontAwesome:{normal:`fas`,400:`fas`}}),Kn),pr),$n),go=Object.keys(ho).reduce(function(e,t){return e[t.toLowerCase()]=ho[t],e},{}),_o=Object.keys(go).reduce(function(e,t){var n=go[t];return e[t]=n[900]||Dt(Object.entries(n))[0][1],e},{});function vo(e){return Ci(Dt(e.replace(po,``))[0]||``)}function yo(e){var t=e.getPropertyValue(`font-feature-settings`).includes(`ss01`),n=e.getPropertyValue(`content`).replace(po,``),r=n.codePointAt(0),i=r>=mo[0]&&r<=mo[1],a=n.length===2&&n[0]===n[1];return i||a||t}function bo(e,t){var n=e.replace(/^['"]|['"]$/g,``).toLowerCase(),r=parseInt(t),i=isNaN(r)?`normal`:r;return(go[n]||{})[i]||_o[n]}function xo(e,t){var n=`${br}${t.replace(`:`,`-`)}`;return new Promise(function(r,i){if(e.getAttribute(n)!==null)return r();var a=ei(e.children).filter(function(e){return e.getAttribute(yr)===t})[0],o=zt.getComputedStyle(e,t),s=o.getPropertyValue(`font-family`),c=s.match(Rr),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=bo(s,l),p=vo(d),m=c[0].startsWith(`FontAwesome`),h=yo(o),g=zi(f,p),_=g;if(m){var v=Ui(p);v.iconName&&v.prefix&&(g=v.iconName,f=v.prefix)}if(g&&!h&&(!a||a.getAttribute(xr)!==f||a.getAttribute(Sr)!==_)){e.setAttribute(n,_),a&&e.removeChild(a);var y=$a(),b=y.extra;b.attributes[yr]=t,Ta(g,f).then(function(i){var a=va(W(W({},y),{},{icons:{main:i,mask:Gi()},prefix:f,iconName:_,extra:b,watchable:!0})),o=G.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 yi(e)}).join(`
`),e.removeAttribute(n),r()}).catch(i)}else r()}else r()})}function So(e){return Promise.all([xo(e,`::before`),xo(e,`::after`)])}function Co(e){return e.parentNode!==document.head&&!~Tr.indexOf(e.tagName.toUpperCase())&&!e.getAttribute(yr)&&(!e.parentNode||e.parentNode.tagName!==`svg`)}var wo=function(e){return!!e&&Er.some(function(t){return e.includes(t)})},To=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=bt(n),i;try{for(r.s();!(i=r.n()).done;){var a=i.value;if(wo(a)){var o=Er.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 Eo(e){var t=arguments.length>1&&arguments[1]!==void 0&&arguments[1];if(Ht){var n;if(t)n=e;else if(q.searchPseudoElementsFullScan)n=e.querySelectorAll(`*`);else{var r=new Set,i=bt(document.styleSheets),a;try{for(i.s();!(a=i.n()).done;){var o=a.value;try{var s=bt(o.cssRules),c;try{for(s.s();!(c=s.n()).done;){var l=c.value,u=bt(To(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=ei(n).filter(Co).map(So),i=ja.begin(`searchPseudoElements`);Ga(),Promise.all(r).then(function(){i(),Ka(),e()}).catch(function(){i(),Ka(),t()})})}}var Do={hooks:function(){return{mutationObserverCallbacks:function(e){return e.pseudoElementsCallback=Eo,e}}},provides:function(e){e.pseudoElements2svg=function(e){var t=e.node,n=t===void 0?G:t;q.searchPseudoElements&&Eo(n)}}},Oo=!1,ko={mixout:function(){return{dom:{unwatch:function(){Ga(),Oo=!0}}}},hooks:function(){return{bootstrap:function(){Ja(ca(`mutationObserverCallbacks`,{}))},noAuto:function(){Ya()},watch:function(e){var t=e.observeMutationsRoot;Oo?Ka():Ja(ca(`mutationObserverCallbacks`,{observeMutationsRoot:t}))}}}},Ao=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})},jo={mixout:function(){return{parse:{transform:function(e){return Ao(e)}}}},hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-transform`);return n&&(e.transform=Ao(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:W({},a.outer),children:[{tag:`g`,attributes:W({},a.inner),children:[{tag:t.icon.tag,children:t.icon.children,attributes:W(W({},t.icon.attributes),a.path)}]}]}}}},Mo={x:0,y:0,width:`100%`,height:`100%`};function No(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 Po(e){return e.tag===`g`?e.children:[e]}sa([fi,co,lo,uo,fo,Do,ko,jo,{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-mask`),r=n?Zi(n.split(` `).map(function(e){return e.trim()})):Gi();return r.prefix||=Wi(),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=oi({transform:o,containerWidth:l,iconWidth:s}),f={tag:`rect`,attributes:W(W({},Mo),{},{fill:`white`})},p=c.children?{children:c.children.map(No)}:{},m={tag:`g`,attributes:W({},d.inner),children:[No(W({tag:c.tag,attributes:W(W({},c.attributes),d.path)},p))]},h={tag:`g`,attributes:W({},d.outer),children:[m]},g=`mask-${a||$r()}`,_=`clip-${a||$r()}`,v={tag:`mask`,attributes:W(W({},Mo),{},{id:g,maskUnits:`userSpaceOnUse`,maskContentUnits:`userSpaceOnUse`}),children:[f,h]},y={tag:`defs`,children:[{tag:`clipPath`,attributes:{id:_},children:Po(u)},v]};return t.push(y,{tag:`rect`,attributes:W({fill:`currentColor`,"clip-path":`url(#${_})`,mask:`url(#${g})`},Mo)}),{children:t,attributes:n}}}},{provides:function(e){var t=!1;zt.matchMedia&&(t=zt.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:W(W({},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=W(W({},r),{},{attributeName:`opacity`}),a={tag:`circle`,attributes:W(W({},n),{},{cx:`256`,cy:`364`,r:`28`}),children:[]};return t||a.children.push({tag:`animate`,attributes:W(W({},r),{},{attributeName:`r`,values:`28;14;28;28;14;28;`})},{tag:`animate`,attributes:W(W({},i),{},{values:`1;0;1;1;0;1;`})}),e.push(a),e.push({tag:`path`,attributes:W(W({},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:W(W({},i),{},{values:`1;0;0;0;0;1;`})}]}),t||e.push({tag:`path`,attributes:W(W({},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:W(W({},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:J}),J.noAuto;var Fo=J.config;J.library,J.dom;var Io=J.parse;J.findIconDefinition,J.toHtml;var Lo=J.icon;J.layer;var Ro=J.text;J.counter;function zo(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 Bo(e){if(Array.isArray(e))return zo(e)}function Y(e,t,n){return(t=Jo(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function Vo(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function Ho(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Uo(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 X(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Uo(Object(n),!0).forEach(function(t){Y(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Uo(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function Wo(e,t){if(e==null)return{};var n,r,i=Go(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 Go(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 Ko(e){return Bo(e)||Vo(e)||Xo(e)||Ho()}function qo(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 Jo(e){var t=qo(e,`string`);return typeof t==`symbol`?t:t+``}function Yo(e){"@babel/helpers - typeof";return Yo=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},Yo(e)}function Xo(e,t){if(e){if(typeof e==`string`)return zo(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)?zo(e,t):void 0}}function Zo(e,t){return Array.isArray(t)&&t.length>0||!Array.isArray(t)&&t?Y({},e,t):{}}function Qo(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`},Y(Y(Y(Y(Y(Y(Y(Y(Y(Y(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),Y(Y(Y(Y(Y(Y(Y(Y(Y(Y(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),Y(Y(Y(Y(Y(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 $o=typeof globalThis<`u`?globalThis:typeof window<`u`?window:typeof global<`u`?global:typeof self<`u`?self:{},es={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})($o)})(es);var ts=es.exports,ns=[`gradientFill`],rs=[`class`,`style`],is=[`type`,`stops`,`id`];function as(e){return e.split(`;`).map(function(e){return e.trim()}).filter(function(e){return e}).reduce(function(e,t){var n=t.indexOf(`:`),r=ts.camelize(t.slice(0,n));return e[r]=t.slice(n+1).trim(),e},{})}function os(e){return e.split(/\s+/).reduce(function(e,t){return e[t]=!0,e},{})}function ss(e,t){return O(`stop`,X({key:`${t}-${e.offset}`,offset:e.offset,"stop-color":e.color},e.opacity!==void 0&&{"stop-opacity":e.opacity}))}function cs(e){if(typeof e==`string`)return e;var t=(e.children||[]).map(cs);return e.tag===`path`&&e.attributes&&`fill`in e.attributes?X(X({},e),{},{attributes:X(X({},e.attributes),{},{fill:void 0}),children:t}):X(X({},e),{},{children:t})}function ls(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=Wo(t,ns),o=i||`fill`in n?cs(e):e,s=(o.children||[]).map(function(e){return ls(e,{},{})}),c=Object.keys(o.attributes||{}).reduce(function(e,t){var n=o.attributes[t];switch(t){case`class`:e.class=os(n);break;case`style`:e.style=as(n);break;default:e.attrs[t]=n}return e},{attrs:{},class:{},style:{}});n.class;var l=n.style,u=l===void 0?{}:l,d=Wo(n,rs);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=Wo(i,is),_=O(f===`linear`?`linearGradient`:`radialGradient`,X(X({},g),{},{id:h}),m.map(ss));return O(o.tag,X(X(X(X({},a),{},{class:c.class,style:X(X({},c.style),u)},c.attrs),d),{},{fill:`url(#${h})`}),[_].concat(Ko(s)))}return O(e.tag,X(X(X({},a),{},{class:c.class,style:X(X({},c.style),u)},c.attrs),d),s)}var us=!1;try{us=!0}catch{}function ds(){if(!us&&console&&typeof console.error==`function`){var e;(e=console).error.apply(e,arguments)}}function fs(e){if(e&&Yo(e)===`object`&&e.prefix&&e.iconName&&e.icon)return e;if(Io.icon)return Io.icon(e);if(e===null)return null;if(Yo(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 ps=j({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=I(function(){return fs(e.icon)}),i=I(function(){return Zo(`classes`,Qo(e))}),a=I(function(){return Zo(`transform`,typeof e.transform==`string`?Io.transform(e.transform):e.transform)}),o=I(function(){return Zo(`mask`,fs(e.mask))}),s=I(function(){var t=X(X(X(X({},i.value),a.value),o.value),{},{symbol:e.symbol,maskId:e.maskId});return t.title=e.title,t.titleId=e.titleId,Lo(r.value,t)});l(s,function(e){if(!e)return ds(`Could not find one or more icon(s)`,r.value,o.value)},{immediate:!0}),e.gradientFill&&e.symbol&&ds(`gradientFill is not supported when symbol is true and will be ignored`);var c=I(function(){return s.value?ls(s.value.abstract[0],{gradientFill:e.symbol?null:e.gradientFill},n):null});return function(){return c.value}}});j({name:`FontAwesomeLayers`,props:{fixedWidth:{type:Boolean,default:!1}},setup:function(e,t){var n=t.slots,r=Fo.familyPrefix,i=I(function(){return[`${r}-layers`].concat(Ko(e.fixedWidth?[`${r}-fw`]:[]))});return function(){return O(`div`,{class:i.value},n.default?n.default():[])}}}),j({name:`FontAwesomeLayersText`,props:{value:{type:[String,Number],default:``},transform:{type:[String,Object],default:null},counter:{type:Boolean,default:!1},position:{type:String,default:null,validator:function(e){return[`bottom-left`,`bottom-right`,`top-left`,`top-right`].indexOf(e)>-1}}},setup:function(e,t){var n=t.attrs,r=Fo.familyPrefix,i=I(function(){return Zo(`classes`,[].concat(Ko(e.counter?[`${r}-layers-counter`]:[]),Ko(e.position?[`${r}-layers-${e.position}`]:[])))}),a=I(function(){return Zo(`transform`,typeof e.transform==`string`?Io.transform(e.transform):e.transform)}),o=I(function(){var t=Ro(e.value.toString(),X(X({},a.value),i.value)).abstract;return e.counter&&(t[0].attributes.class=t[0].attributes.class.replace(`fa-layers-text`,``)),t[0]}),s=I(function(){return ls(o.value,{},n)});return function(){return s.value}}});var ms={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`]},hs=j({__name:`Alert`,props:{class:{type:[Boolean,null,String,Object,Array]},variant:{}},setup(e){let t=e;return(n,r)=>(z(),N(`div`,{"data-slot":`alert`,class:dt(P(ge)(P(vs)({variant:e.variant}),t.class)),role:`alert`},[R(n.$slots,`default`)],2))}}),gs=j({__name:`AlertDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(z(),N(`div`,{"data-slot":`alert-description`,class:dt(P(ge)(`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))},[R(e.$slots,`default`)],2))}}),_s=j({__name:`AlertTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(z(),N(`div`,{"data-slot":`alert-title`,class:dt(P(ge)(`font-medium group-has-[>svg]/alert:col-start-2 font-heading [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[R(e.$slots,`default`)],2))}}),vs=v(`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`,warn:`text-status-warn bg-card *:data-[slot=alert-description]:text-status-warn/90 *:[svg]:text-current`}},defaultVariants:{variant:`default`}});function ys(e){return typeof e==`string`?`'${e}'`:new Cs().serialize(e)}var bs=` _-,;:!?.'"()[]{}@*/\\&#%\`^+<=>|~$0123456789abcdefghijklmnopqrstuvwxyz`,xs=(function(){let e=new Uint8Array(128);for(let t=0;t<69;t++)e[bs.charCodeAt(t)]=t+1;for(let t=65;t<=90;t++)e[t]=e[t+32];return e})();function Ss(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&&xs[n]?xs[n]:n+128,s=a<128&&xs[a]?xs[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 Cs=(function(){class e{#e=new Map;compare(e,t){let n=typeof e,r=typeof t;return n===`string`&&r===`string`?Ss(e,t):n===`number`&&r===`number`?e-t:Ss(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(Ss),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 ws(e,t){return e===t||ys(e)===ys(t)}function Ts(e,t=-1/0,n=1/0){return Math.min(n,Math.max(t,e))}function Z(){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 Es(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)}function Ds(e){return e==null}var Q=Le({layersRoot:new Set,layersWithOutsidePointerEventsDisabled:new Set,originalBodyPointerEvents:void 0,branches:new Set});function Os(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 ks(e,t,n=`.`,r){if(!Os(t))return ks(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]]:Os(a)&&Os(i[t])?ks(a,i[t],(n?`${n}.`:``)+t.toString(),r):a))}return i}function As(e){return(...t)=>t.reduce((t,n)=>ks(t,n,``,e),{})}var js=As(),Ms=se(()=>{let e=B(new Map),t=B(),n=I(()=>{for(let t of e.value.values())if(t)return!0;return!1}),i=r({scrollBody:B(!0)}),a=null,o=()=>{document.body.style.paddingRight=``,document.body.style.marginRight=``,Q.layersWithOutsidePointerEventsDisabled.size===0&&(document.body.style.pointerEvents=``),document.documentElement.style.removeProperty(`--scrollbar-width`),document.body.style.overflow=t.value??``,u&&a?.(),t.value=void 0};return l(n,(e,r)=>{if(!ft)return;if(!e){r&&o();return}t.value===void 0&&(t.value=document.body.style.overflow);let s=window.innerWidth-document.documentElement.clientWidth,c={padding:s,margin:0},l=i.scrollBody?.value?typeof i.scrollBody.value==`object`?js({padding:i.scrollBody.value.padding===!0?s:i.scrollBody.value.padding,margin:i.scrollBody.value.margin===!0?s:i.scrollBody.value.margin},c):c:{padding:0,margin:0};s>0&&(document.body.style.paddingRight=typeof l.padding==`number`?`${l.padding}px`:String(l.padding),document.body.style.marginRight=typeof l.margin==`number`?`${l.margin}px`:String(l.margin),document.documentElement.style.setProperty(`--scrollbar-width`,`${s}px`),document.body.style.overflow=`hidden`),u&&(a=ne(document,`touchmove`,e=>Fs(e),{passive:!1})),A(()=>{n.value&&(document.body.style.pointerEvents=`none`,document.body.style.overflow=`hidden`)})},{immediate:!0,flush:`sync`}),e});function Ns(e){let t=Math.random().toString(36).substring(2,7),n=Ms();n.value.set(t,e??!1);let r=I({get:()=>n.value.get(t)??!1,set:e=>n.value.set(t,e)});return pe(()=>{n.value.delete(t)}),r}function Ps(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:Ps(t)}}function Fs(e){let t=e||window.event,n=t.target;return n instanceof Element&&Ps(n)?!1:t.touches.length>1||(t.preventDefault&&t.cancelable&&t.preventDefault(),!1)}var Is=0;function Ls(){L(e=>{if(!ft)return;let t=document.querySelectorAll(`[data-reka-focus-guard]`);document.body.insertAdjacentElement(`afterbegin`,t[0]??Rs()),document.body.insertAdjacentElement(`beforeend`,t[1]??Rs()),Is++,e(()=>{Is===1&&document.querySelectorAll(`[data-reka-focus-guard]`).forEach(e=>e.remove()),Is--})})}function Rs(){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 zs(e){return I(()=>!Ge(e)||!!D(e)?.closest(`form`))}var Bs=function(e){return typeof document>`u`?null:(Array.isArray(e)?e[0]:e).ownerDocument.body},Vs=new WeakMap,Hs=new WeakMap,Us={},Ws=0,Gs=function(e){return e&&(e.host||Gs(e.parentNode))},Ks=function(e,t){return t.map(function(t){if(e.contains(t))return t;var n=Gs(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})},qs=function(e,t,n,r){var i=Ks(t,Array.isArray(e)?e:[e]);Us[n]||(Us[n]=new WeakMap);var a=Us[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=(Vs.get(e)||0)+1,l=(a.get(e)||0)+1;Vs.set(e,c),a.set(e,l),o.push(e),c===1&&i&&Hs.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(),Ws++,function(){o.forEach(function(e){var t=Vs.get(e)-1,i=a.get(e)-1;Vs.set(e,t),a.set(e,i),t||(Hs.has(e)||e.removeAttribute(r),Hs.delete(e)),i||e.removeAttribute(n)}),Ws--,Ws||(Vs=new WeakMap,Vs=new WeakMap,Hs=new WeakMap,Us={})}},Js=function(e,t,n){n===void 0&&(n=`data-aria-hidden`);var r=Array.from(Array.isArray(e)?e:[e]),i=t||Bs(e);return i?(r.push.apply(r,Array.from(i.querySelectorAll(`[aria-live], script`))),qs(r,i,n,`aria-hidden`)):function(){return null}};function Ys(e){let t;l(()=>D(e),e=>{let n=!1;try{n=!!e?.closest(`[popover]:not(:popover-open)`)}catch{}e&&!n?t=Js(e):t&&t()}),ke(()=>{t&&t()})}function Xs(e){let t=B(),n=I(()=>t.value?.width??0),r=I(()=>t.value?.height??0),i;return ve(()=>{let n=D(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}),ke(()=>{i?.disconnect(),i=void 0}),{width:n,height:r}}function Zs(e,t){let n=B(e);function r(e){return t[n.value][e]??n.value}return{state:n,dispatch:e=>{n.value=r(e)}}}function Qs(e){let t=y(``,1e3);return{search:t,handleTypeaheadSearch:(n,r)=>{if(t.value+=n,e)e(n);else{let e=Z(),n=r.map(e=>({...e,textValue:e.value?.textValue??e.ref.textContent?.trim()??``})),i=n.find(t=>t.ref===e),a=ec(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 $s(e,t){return e.map((n,r)=>e[(t+r)%e.length])}function ec(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=$s(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}function tc(e,t){let n=B({}),r=B(`none`),i=B(e),a=e.value?`mounted`:`unmounted`,o,s=t.value?.ownerDocument.defaultView??c,{state:u,dispatch:d}=Zs(a,{mounted:{UNMOUNT:`unmounted`,ANIMATION_OUT:`unmountSuspended`},unmountSuspended:{MOUNT:`mounted`,ANIMATION_END:`unmounted`},unmounted:{MOUNT:`mounted`}}),f=e=>{if(ft){let n=new CustomEvent(e,{bubbles:!1,cancelable:!1});t.value?.dispatchEvent(n)}};l(e,async(e,i)=>{let a=i!==e;if(await A(),a){let a=r.value,o=nc(t.value);e?(d(`MOUNT`),f(`enter`),o===`none`&&f(`after-enter`)):o===`none`||o===`undefined`||n.value?.display===`none`?(d(`UNMOUNT`),f(`leave`),f(`after-leave`)):i&&a!==o?(d(`ANIMATION_OUT`),f(`leave`)):(d(`UNMOUNT`),f(`after-leave`))}},{immediate:!0});let p=e=>{if(e.target!==t.value)return;let n=nc(t.value),r=n.includes(CSS.escape(e.animationName)),a=u.value===`mounted`?`enter`:`leave`;if(r&&(f(`after-${a}`),d(`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`&&d(`ANIMATION_END`)},m=e=>{e.target===t.value&&(r.value=nc(t.value))},h=l(t,(e,t)=>{e?(n.value=getComputedStyle(e),e.addEventListener(`animationstart`,m),e.addEventListener(`animationcancel`,p),e.addEventListener(`animationend`,p)):(d(`ANIMATION_END`),o!==void 0&&s?.clearTimeout(o),t?.removeEventListener(`animationstart`,m),t?.removeEventListener(`animationcancel`,p),t?.removeEventListener(`animationend`,p))},{immediate:!0}),g=l(u,()=>{let e=nc(t.value);r.value=u.value===`mounted`?e:`none`});return ke(()=>{h(),g(),t.value&&(t.value.removeEventListener(`animationstart`,m),t.value.removeEventListener(`animationcancel`,p),t.value.removeEventListener(`animationend`,p)),o!==void 0&&s?.clearTimeout(o)}),{isPresent:I(()=>[`mounted`,`unmountSuspended`].includes(u.value))}}function nc(e){return e&&getComputedStyle(e).animationName||`none`}var rc=j({name:`Presence`,props:{present:{type:Boolean,required:!0},forceMount:{type:Boolean}},slots:{},setup(e,{slots:t,expose:n}){let{present:r,forceMount:i}=$e(e),a=B(),{isPresent:o}=tc(r,a);n({present:o});let s=t.default({present:o.value});s=Be(s||[]);let c=fe();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?O(t.default({present:o.value})[0],{ref:e=>{let t=D(e);return t?.hasAttribute===void 0||(t?.hasAttribute(`data-reka-popper-content-wrapper`)?a.value=t.firstElementChild:a.value=t),t}}):null}});function ic(){let e=B();return{primitiveElement:e,currentElement:I(()=>[`#text`,`#comment`].includes(e.value?.$el.nodeName)?e.value?.$el.nextElementSibling:D(e))}}var ac=`dismissableLayer.pointerDownOutside`,oc=`dismissableLayer.focusOutside`;function sc(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 cc(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=B(!1),a=B(()=>{});return L(o=>{if(!ft||!Ge(n))return;let s=async n=>{let o=n.target;if(!(!t?.value||!o)){if(sc(t.value,o)){i.value=!1;return}if(n.target&&!i.value){let t={originalEvent:n};function i(){Es(ac,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:()=>{Ge(n)&&(i.value=!0)}}}function lc(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=B(!1);return L(a=>{if(!ft||!Ge(n))return;let o=async n=>{if(!t?.value)return;await A(),await A();let r=n.target;!t.value||!r||sc(t.value,r)||n.target&&!i.value&&Es(oc,e,{originalEvent:n})};r.addEventListener(`focusin`,o),a(()=>r.removeEventListener(`focusin`,o))}),{onFocusCapture:()=>{Ge(n)&&(i.value=!0)},onBlurCapture:()=>{Ge(n)&&(i.value=!1)}}}var uc=j({__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:n}){let r=e,i=n,{forwardRef:a,currentElement:o}=t(),s=I(()=>o.value?.ownerDocument??globalThis.document),c=I(()=>Q.layersRoot),u=I(()=>o.value?Array.from(c.value).indexOf(o.value):-1),d=I(()=>Q.layersWithOutsidePointerEventsDisabled.size>0),f=I(()=>{let e=Array.from(c.value),[t]=[...Q.layersWithOutsidePointerEventsDisabled].slice(-1),n=e.indexOf(t);return u.value>=n}),m=cc(async e=>{let t=[...Q.branches].some(t=>t?.contains(e.target));!r.present||!f.value||t||(i(`pointerDownOutside`,e),i(`interactOutside`,e),await A(),e.defaultPrevented||i(`dismiss`))},o),h=lc(e=>{let t=[...Q.branches].some(t=>t?.contains(e.target));!r.present||t||(i(`focusOutside`,e),i(`interactOutside`,e),e.defaultPrevented||i(`dismiss`))},o);return ze(`Escape`,e=>{r.present&&u.value===c.value.size-1&&(i(`escapeKeyDown`,e),e.defaultPrevented||i(`dismiss`))}),l([o,()=>r.disableOutsidePointerEvents,()=>r.present],([e,t,n],r,i)=>{!e||!n||t&&(Q.layersWithOutsidePointerEventsDisabled.size===0&&(Q.originalBodyPointerEvents=s.value.body.style.pointerEvents,s.value.body.style.pointerEvents=`none`),Q.layersWithOutsidePointerEventsDisabled.add(e),i(()=>{Q.layersWithOutsidePointerEventsDisabled.delete(e),Q.layersWithOutsidePointerEventsDisabled.size===0&&!Ds(Q.originalBodyPointerEvents)&&(s.value.body.style.pointerEvents=Q.originalBodyPointerEvents)}))},{immediate:!0}),l([o,()=>r.present],([e,t],n,r)=>{!e||!t||(c.value.add(e),r(()=>{c.value.delete(e)}))},{immediate:!0}),L(e=>{e(()=>{o.value&&(c.value.delete(o.value),Q.layersWithOutsidePointerEventsDisabled.delete(o.value))})}),(e,t)=>(z(),V(P(p),{ref:P(a),"as-child":e.asChild,as:e.as,"data-dismissable-layer":``,style:ut({pointerEvents:d.value?f.value?`auto`:`none`:void 0}),onFocusCapture:P(h).onFocusCapture,onBlurCapture:P(h).onBlurCapture,onPointerdownCapture:P(m).onPointerDownCapture},{default:_(()=>[R(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`style`,`onFocusCapture`,`onBlurCapture`,`onPointerdownCapture`]))}}),dc=E(()=>B([]));function fc(){let e=dc();return{add(t){let n=e.value[0];t!==n&&n?.pause(),e.value=pc(e.value,t),e.value.unshift(t)},remove(t){e.value=pc(e.value,t),e.value[0]?.resume()}}}function pc(e,t){let n=[...e],r=n.indexOf(t);return r!==-1&&n.splice(r,1),n}var mc=`focusScope.autoFocusOnMount`,hc=`focusScope.autoFocusOnUnmount`,gc={bubbles:!1,cancelable:!0};function _c(e,{select:t=!1}={}){let n=Z();for(let r of e)if(Cc(r,{select:t}),Z()!==n)return!0}function vc(e){let t=yc(e);return[bc(t,e),bc(t.reverse(),e)]}function yc(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 bc(e,t){for(let n of e)if(!xc(n,{upTo:t}))return n}function xc(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 Sc(e){return e instanceof HTMLInputElement&&`select`in e}function Cc(e,{select:t=!1}={}){if(e&&e.focus){let n=Z();e.focus({preventScroll:!0}),e!==n&&Sc(e)&&t&&e.select()}}var wc=j({__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:n}){let r=e,i=n,{currentRef:a,currentElement:o}=t(),s=B(null),c=fc(),u=Le({paused:!1,pause(){this.paused=!0},resume(){this.paused=!1}});L(e=>{if(!ft)return;let t=o.value;if(!r.trapped)return;function n(e){if(u.paused||!t)return;let n=e.target;t.contains(n)?s.value=n:Cc(s.value,{select:!0})}function i(e){if(u.paused||!t)return;let n=e.relatedTarget;n!==null&&(t.contains(n)||Cc(s.value,{select:!0}))}function a(e){let n=s.value;n!==null&&e.some(e=>e.removedNodes.length>0)&&(t.contains(n)||Cc(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 d(e,t){let n=new CustomEvent(mc,gc),r=e=>i(`mountAutoFocus`,e);e.addEventListener(mc,r),e.dispatchEvent(n),e.removeEventListener(mc,r),n.defaultPrevented||(_c(yc(e),{select:!0}),Z()===t&&Cc(e))}L(async e=>{let t=o.value;if(await A(),!t)return;r.present!==!1&&c.add(u);let n=Z();!t.contains(n)&&r.present!==!1&&d(t,n),e(()=>{let e=new CustomEvent(hc,gc),r=e=>{i(`unmountAutoFocus`,e)};t.addEventListener(hc,r),t.dispatchEvent(e),t.setAttribute(`data-focus-scope-unmounting`,``),setTimeout(()=>{e.defaultPrevented||Cc(n??document.body,{select:!0}),t.removeEventListener(hc,r),c.remove(u),t.removeAttribute(`data-focus-scope-unmounting`)},0)})}),l(()=>r.present,async(e,t)=>{if(!ft)return;if(e===!1&&t===!0){c.remove(u);return}if(e!==!0||t!==!1)return;c.add(u),await A();let n=o.value;if(!n)return;let r=Z();n.contains(r)||d(n,r)});function f(e){if(!r.loop&&!r.trapped||u.paused)return;let t=e.key===`Tab`&&!e.altKey&&!e.ctrlKey&&!e.metaKey,n=Z();if(t&&n){let t=e.currentTarget,[i,a]=vc(t);i&&a?!e.shiftKey&&n===a?(e.preventDefault(),r.loop&&Cc(i,{select:!0})):e.shiftKey&&n===i&&(e.preventDefault(),r.loop&&Cc(a,{select:!0})):n===t&&e.preventDefault()}}return(e,t)=>(z(),V(P(p),{ref_key:`currentRef`,ref:a,tabindex:`-1`,"as-child":e.asChild,as:e.as,onKeydown:f},{default:_(()=>[R(e.$slots,`default`)]),_:3},8,[`as-child`,`as`]))}}),Tc=[`Enter`,` `],Ec=[`ArrowDown`,`PageUp`,`Home`],Dc=[`ArrowUp`,`PageDown`,`End`];[...Ec,...Dc],[...Tc],[...Tc];function Oc(e){let t=Z();for(let n of e)if(n===t||(n.focus(),Z()!==t))return}var kc=j({__name:`Teleport`,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,n=r({}),i=I(()=>t.to??n.teleportTo?.value??`body`),a=ie();return(e,t)=>P(a)||e.forceMount?(z(),V(oe,{key:0,to:i.value,disabled:e.disabled,defer:e.defer},[R(e.$slots,`default`)],8,[`to`,`disabled`,`defer`])):H(`v-if`,!0)}}),Ac=`data-reka-collection-item`;function jc(e={}){let{key:t=``,isProvider:n=!1}=e,r=`${t}CollectionProvider`,i;if(n){let e=B(new Map);i={collectionRef:B(),itemMap:e},Re(r,i)}else i=C(r);let a=(e=!1)=>{let t=i.collectionRef.value;if(!t)return[];let n=Array.from(t.querySelectorAll(`[${Ac}]`)),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=j({name:`CollectionSlot`,inheritAttrs:!1,setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=ic();return l(a,()=>{i.collectionRef.value=a.value}),()=>O(re,{ref:r,...n},t)}}),s=j({name:`CollectionItem`,inheritAttrs:!1,props:{value:{validator:()=>!0}},setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=ic();return L(t=>{if(a.value){let n=Oe(a.value);i.itemMap.value.set(n,{ref:a.value,value:e.value}),t(()=>i.itemMap.value.delete(n))}}),()=>O(re,{...n,[Ac]:``,ref:r},t)}});return{getItems:a,reactiveItems:I(()=>Array.from(i.itemMap.value.values())),itemMapSize:I(()=>i.itemMap.value.size),CollectionSlot:o,CollectionItem:s}}var Mc=j({__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)=>(z(),V(P(p),{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:_(()=>[R(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`aria-hidden`,`data-hidden`,`tabindex`]))}}),[Nc,Pc]=a(`PopperRoot`),Fc=j({inheritAttrs:!1,__name:`PopperRoot`,setup(e){let t=B();return Pc({anchor:t,onAnchorChange:e=>t.value=e}),(e,t)=>R(e.$slots,`default`)}}),Ic=j({__name:`PopperAnchor`,props:{reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let n=e,{forwardRef:r,currentElement:i}=t(),a=Nc();return te(()=>{a.onAnchorChange(n.reference??i.value)}),(e,t)=>(z(),V(P(p),{ref:P(r),as:e.as,"as-child":e.asChild},{default:_(()=>[R(e.$slots,`default`)]),_:3},8,[`as`,`as-child`]))}});function Lc(e){return e!==null}function Rc(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]=zc(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 zc(e){let[t,n=`center`]=e.split(`-`);return[t,n]}var Bc=[`top`,`right`,`bottom`,`left`],Vc=Math.min,Hc=Math.max,Uc=Math.round,Wc=Math.floor,Gc=e=>({x:e,y:e}),Kc={left:`right`,right:`left`,bottom:`top`,top:`bottom`};function qc(e,t,n){return Hc(e,Vc(t,n))}function Jc(e,t){return typeof e==`function`?e(t):e}function Yc(e){return e.split(`-`)[0]}function Xc(e){return e.split(`-`)[1]}function Zc(e){return e===`x`?`y`:`x`}function Qc(e){return e===`y`?`height`:`width`}function $c(e){let t=e[0];return t===`t`||t===`b`?`y`:`x`}function el(e){return Zc($c(e))}function tl(e,t,n){n===void 0&&(n=!1);let r=Xc(e),i=el(e),a=Qc(i),o=i===`x`?r===(n?`end`:`start`)?`right`:`left`:r===`start`?`bottom`:`top`;return t.reference[a]>t.floating[a]&&(o=ul(o)),[o,ul(o)]}function nl(e){let t=ul(e);return[rl(e),t,rl(t)]}function rl(e){return e.includes(`start`)?e.replace(`start`,`end`):e.replace(`end`,`start`)}var il=[`left`,`right`],al=[`right`,`left`],ol=[`top`,`bottom`],sl=[`bottom`,`top`];function cl(e,t,n){switch(e){case`top`:case`bottom`:return n?t?al:il:t?il:al;case`left`:case`right`:return t?ol:sl;default:return[]}}function ll(e,t,n,r){let i=Xc(e),a=cl(Yc(e),n===`start`,r);return i&&(a=a.map(e=>e+`-`+i),t&&(a=a.concat(a.map(rl)))),a}function ul(e){let t=Yc(e);return Kc[t]+e.slice(t.length)}function dl(e){return{top:e.top??0,right:e.right??0,bottom:e.bottom??0,left:e.left??0}}function fl(e){return typeof e==`number`?{top:e,right:e,bottom:e,left:e}:dl(e)}function pl(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 ml(e,t,n){let{reference:r,floating:i}=e,a=$c(t),o=el(t),s=Qc(o),c=Yc(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=Xc(t);return m&&(p[o]+=f*(m===`end`?1:-1)*(n&&l?-1:1)),p}async function hl(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}=Jc(t,e),p=fl(f),m=o[d?u===`floating`?`reference`:`floating`:u],h=pl(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=pl(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 gl=50,_l=async(e,t,n)=>{let{placement:r=`bottom`,strategy:i=`absolute`,middleware:a=[],platform:o}=n,s=o.detectOverflow?o:{...o,detectOverflow:hl},c=await(o.isRTL==null?void 0:o.isRTL(t)),l=await o.getElementRects({reference:e,floating:t,strategy:i}),{x:u,y:d}=ml(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<gl&&(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}=ml(l,f,c)),n=-1)}return{x:u,y:d,placement:f,strategy:i,middlewareData:m}},vl=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}=Jc(e,t)||{};if(l==null)return{};let d=fl(u),f={x:n,y:r},p=el(i),m=Qc(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=Vc(d[_],T),ee=Vc(d[v],T),D=C-h[m]-ee,te=C/2-h[m]/2+w,ne=qc(E,te,D),re=!c.arrow&&Xc(i)!=null&&te!==ne&&a.reference[m]/2-(te<E?E:ee)-h[m]/2<0,O=re?te<E?te-E:te-D:0;return{[p]:f[p]+O,data:{[p]:ne,centerOffset:te-ne-O,...re&&{alignmentOffset:O}},reset:re}}}),yl=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}=Jc(e,t);if((n=i.arrow)!=null&&n.alignmentOffset)return{};let g=Yc(r),_=$c(o),v=Yc(o)===o,y=await(s.isRTL==null?void 0:s.isRTL(c.floating)),b=d||(v||!m?[ul(o)]:nl(o)),x=p!==`none`;!d&&x&&b.push(...ll(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=tl(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`||_===$c(t)||T.every(e=>$c(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=$c(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 bl(e,t){return{top:e.top-t.height,right:e.right-t.width,bottom:e.bottom-t.height,left:e.left-t.width}}function xl(e){return Bc.some(t=>e[t]>=0)}var Sl=function(e){return e===void 0&&(e={}),{name:`hide`,options:e,async fn(t){let{rects:n,platform:r}=t,{strategy:i=`referenceHidden`,...a}=Jc(e,t);switch(i){case`referenceHidden`:{let e=bl(await r.detectOverflow(t,{...a,elementContext:`reference`}),n.reference);return{data:{referenceHiddenOffsets:e,referenceHidden:xl(e)}}}case`escaped`:{let e=bl(await r.detectOverflow(t,{...a,altBoundary:!0}),n.floating);return{data:{escapedOffsets:e,escaped:xl(e)}}}default:return{}}}}},Cl=new Set([`left`,`top`]);async function wl(e,t){let{placement:n,platform:r,elements:i}=e,a=await(r.isRTL==null?void 0:r.isRTL(i.floating)),o=Yc(n),s=Xc(n),c=$c(n)===`y`,l=Cl.has(o)?-1:1,u=a&&c?-1:1,d=Jc(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 Tl=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 wl(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}}}}},El=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}=Jc(e,t),u={x:n,y:r},d=await a.detectOverflow(t,l),f=$c(i),p=Zc(f),m=u[p],h=u[f],g=(e,t)=>qc(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}}}}}},Dl=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}=Jc(e,t),u={x:n,y:r},d=$c(i),f=Zc(d),p=u[f],m=u[d],h=Jc(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=Cl.has(Yc(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}}}},Ol=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}=Jc(e,t),c=await i.detectOverflow(t,s),l=Yc(n),u=Xc(n),d=$c(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=Vc(p-c[m],g),y=Vc(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*Hc(c.left,c.right):S=p-2*Hc(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 kl(){return typeof window<`u`}function Al(e){return Ml(e)?(e.nodeName||``).toLowerCase():`#document`}function $(e){var t;return(e==null||(t=e.ownerDocument)==null?void 0:t.defaultView)||window}function jl(e){return((Ml(e)?e.ownerDocument:e.document)||window.document)?.documentElement}function Ml(e){return kl()?e instanceof Node||e instanceof $(e).Node:!1}function Nl(e){return kl()?e instanceof Element||e instanceof $(e).Element:!1}function Pl(e){return kl()?e instanceof HTMLElement||e instanceof $(e).HTMLElement:!1}function Fl(e){return!kl()||typeof ShadowRoot>`u`?!1:e instanceof ShadowRoot||e instanceof $(e).ShadowRoot}function Il(e){let{overflow:t,overflowX:n,overflowY:r,display:i}=ql(e);return/auto|scroll|overlay|hidden|clip/.test(t+r+n)&&i!==`inline`&&i!==`contents`}function Ll(e){return/^(table|td|th)$/.test(Al(e))}function Rl(e){try{if(e.matches(`:popover-open`))return!0}catch{}try{return e.matches(`:modal`)}catch{return!1}}var zl=/transform|translate|scale|rotate|perspective|filter/,Bl=/paint|layout|strict|content/,Vl=e=>!!e&&e!==`none`,Hl;function Ul(e){let t=Nl(e)?ql(e):e;return Vl(t.transform)||Vl(t.translate)||Vl(t.scale)||Vl(t.rotate)||Vl(t.perspective)||!Gl()&&(Vl(t.backdropFilter)||Vl(t.filter))||zl.test(t.willChange||``)||Bl.test(t.contain||``)}function Wl(e){let t=Yl(e);for(;Pl(t)&&!Kl(t);){if(Ul(t))return t;if(Rl(t))return null;t=Yl(t)}return null}function Gl(){return Hl??=typeof CSS<`u`&&CSS.supports&&CSS.supports(`-webkit-backdrop-filter`,`none`),Hl}function Kl(e){return/^(html|body|#document)$/.test(Al(e))}function ql(e){return $(e).getComputedStyle(e)}function Jl(e){return Nl(e)?{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}:{scrollLeft:e.scrollX,scrollTop:e.scrollY}}function Yl(e){if(Al(e)===`html`)return e;let t=e.assignedSlot||e.parentNode||Fl(e)&&e.host||jl(e);return Fl(t)?t.host:t}function Xl(e){let t=Yl(e);return Kl(t)?(e.ownerDocument||e).body:Pl(t)&&Il(t)?t:Xl(t)}function Zl(e,t,n){t===void 0&&(t=[]),n===void 0&&(n=!0);let r=Xl(e),i=r===e.ownerDocument?.body,a=$(r);if(i){let e=Ql(a);return t.concat(a,a.visualViewport||[],Il(r)?r:[],e&&n?Zl(e):[])}return t.concat(r,Zl(r,[],n))}function Ql(e){return e.parent&&Object.getPrototypeOf(e.parent)?e.frameElement:null}function $l(e){let t=ql(e),n=parseFloat(t.width)||0,r=parseFloat(t.height)||0,i=Pl(e),a=i?e.offsetWidth:n,o=i?e.offsetHeight:r,s=Uc(n)!==a||Uc(r)!==o;return s&&(n=a,r=o),{width:n,height:r,$:s}}function eu(e){return Nl(e)?e:e.contextElement}function tu(e){let t=eu(e);if(!Pl(t))return Gc(1);let n=t.getBoundingClientRect(),{width:r,height:i,$:a}=$l(t),o=(a?Uc(n.width):n.width)/r,s=(a?Uc(n.height):n.height)/i;return(!o||!Number.isFinite(o))&&(o=1),(!s||!Number.isFinite(s))&&(s=1),{x:o,y:s}}var nu=Gc(0);function ru(e){let t=$(e);return!Gl()||!t.visualViewport?nu:{x:t.visualViewport.offsetLeft,y:t.visualViewport.offsetTop}}function iu(e,t,n){return t===void 0&&(t=!1),!!n&&t&&n===$(e)}function au(e,t,n,r){t===void 0&&(t=!1),n===void 0&&(n=!1);let i=e.getBoundingClientRect(),a=eu(e),o=Gc(1);t&&(r?Nl(r)&&(o=tu(r)):o=tu(e));let s=iu(a,n,r)?ru(a):Gc(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=$(a),t=Nl(r)?$(r):r,n=e,i=Ql(n);for(;i&&t!==n;){let e=tu(i),t=i.getBoundingClientRect(),r=ql(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=$(i),i=Ql(n)}}return pl({width:u,height:d,x:c,y:l})}function ou(e,t){let n=Jl(e).scrollLeft;return t?t.left+n:au(jl(e)).left+n}function su(e,t){let n=e.getBoundingClientRect();return{x:n.left+t.scrollLeft-ou(e,n),y:n.top+t.scrollTop}}function cu(e){let{elements:t,rect:n,offsetParent:r,strategy:i}=e,a=i===`fixed`,o=jl(r),s=t?Rl(t.floating):!1;if(r===o||s&&a)return n;let c={scrollLeft:0,scrollTop:0},l=Gc(1),u=Gc(0),d=Pl(r);if((d||!a)&&((Al(r)!==`body`||Il(o))&&(c=Jl(r)),d)){let e=au(r);l=tu(r),u.x=e.x+r.clientLeft,u.y=e.y+r.clientTop}let f=o&&!d&&!a?su(o,c):Gc(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 lu(e){return e.getClientRects?Array.from(e.getClientRects()):[]}function uu(e){let t=Jl(e),n=e.ownerDocument.body,r=Hc(e.scrollWidth,e.clientWidth,n.scrollWidth,n.clientWidth),i=Hc(e.scrollHeight,e.clientHeight,n.scrollHeight,n.clientHeight),a=-t.scrollLeft+ou(e),o=-t.scrollTop;return ql(n).direction===`rtl`&&(a+=Hc(e.clientWidth,n.clientWidth)-r),{width:r,height:i,x:a,y:o}}var du=25;function fu(e,t,n){n===void 0&&(n=`viewport`);let r=n===`layoutViewport`,i=$(e),a=jl(e),o=i.visualViewport,s=a.clientWidth,c=a.clientHeight,l=0,u=0;if(o){let e=!Gl()||t===`fixed`;r?e||(l=-o.offsetLeft,u=-o.offsetTop):(s=o.width,c=o.height,e&&(l=o.offsetLeft,u=o.offsetTop))}if(ou(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<=du&&(s-=o)}return{width:s,height:c,x:l,y:u}}function pu(e,t){let n=au(e,!0,t===`fixed`),r=n.top+e.clientTop,i=n.left+e.clientLeft,a=tu(e);return{width:e.clientWidth*a.x,height:e.clientHeight*a.y,x:i*a.x,y:r*a.y}}function mu(e,t,n){let r;if(t===`viewport`||t===`layoutViewport`)r=fu(e,n,t);else if(t===`document`)r=uu(jl(e));else if(Nl(t))r=pu(t,n);else{let n=ru(e);r={x:t.x-n.x,y:t.y-n.y,width:t.width,height:t.height}}return pl(r)}function hu(e,t){let n=t.get(e);if(n)return n;let r=Zl(e,[],!1).filter(e=>Nl(e)&&Al(e)!==`body`),i=null,a=ql(e).position===`fixed`,o=a?Yl(e):e;for(;Nl(o)&&!Kl(o);){let e=ql(o),t=Ul(o),n=i?i.position:a?`fixed`:``;!t&&(n===`fixed`||n===`absolute`&&e.position===`static`)?r=r.filter(e=>e!==o):i=e,o=Yl(o)}return t.set(e,r),r}function gu(e){let{element:t,boundary:n,rootBoundary:r,strategy:i}=e,a=[...n===`clippingAncestors`?Rl(t)?[]:hu(t,this._c):[].concat(n),r],o=mu(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=mu(t,a[e],i);s=Hc(n.top,s),c=Vc(n.right,c),l=Vc(n.bottom,l),u=Hc(n.left,u)}return{width:c-u,height:l-s,x:u,y:s}}function _u(e){let{width:t,height:n}=$l(e);return{width:t,height:n}}function vu(e,t,n){let r=Pl(t),i=jl(t),a=n===`fixed`,o=au(e,!0,a,t),s={scrollLeft:0,scrollTop:0},c=Gc(0);if((r||!a)&&((Al(t)!==`body`||Il(i))&&(s=Jl(t)),r)){let e=au(t,!0,a,t);c.x=e.x+t.clientLeft,c.y=e.y+t.clientTop}!r&&i&&(c.x=ou(i));let l=i&&!r&&!a?su(i,s):Gc(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 yu(e){return ql(e).position===`static`}function bu(e,t){if(!Pl(e)||ql(e).position===`fixed`)return null;if(t)return t(e);let n=e.offsetParent;return jl(e)===n&&(n=n.ownerDocument.body),n}function xu(e,t){let n=$(e);if(Rl(e))return n;if(!Pl(e)){let t=Yl(e);for(;t&&!Kl(t);){if(Nl(t)&&!yu(t))return t;t=Yl(t)}return n}let r=bu(e,t);for(;r&&Ll(r)&&yu(r);)r=bu(r,t);return r&&Kl(r)&&yu(r)&&!Ul(r)?n:r||Wl(e)||n}var Su=async function(e){let t=this.getOffsetParent||xu,n=this.getDimensions,r=await n(e.floating);return{reference:vu(e.reference,await t(e.floating),e.strategy),floating:{x:0,y:0,width:r.width,height:r.height}}};function Cu(e){return ql(e).direction===`rtl`}var wu={convertOffsetParentRelativeRectToViewportRelativeRect:cu,getDocumentElement:jl,getClippingRect:gu,getOffsetParent:xu,getElementRects:Su,getClientRects:lu,getDimensions:_u,getScale:tu,isElement:Nl,isRTL:Cu};function Tu(e,t){return e.x===t.x&&e.y===t.y&&e.width===t.width&&e.height===t.height}function Eu(e,t,n){let r=null,i,a=jl(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=Wc(d),h=Wc(a.clientWidth-(u+f)),g=Wc(a.clientHeight-(d+p)),_=Wc(u),v={rootMargin:-m+`px `+-h+`px `+-g+`px `+-_+`px`,threshold:Hc(0,Vc(1,c))||1},y=!0;function b(t){let n=t[0].intersectionRatio;if(!Tu(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=$(e),l=()=>s(n);return c.addEventListener(`resize`,l),s(!0),()=>{c.removeEventListener(`resize`,l),o()}}function Du(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=eu(e),u=i||a?[...l?Zl(l):[],...t?Zl(t):[]]:[];u.forEach(e=>{i&&e.addEventListener(`scroll`,n),a&&e.addEventListener(`resize`,n)});let d=l&&s?Eu(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?au(e):null;c&&g();function g(){let t=au(e);h&&!Tu(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 Ou=Tl,ku=El,Au=yl,ju=Ol,Mu=Sl,Nu=vl,Pu=Dl,Fu=(e,t,n)=>{let r=new Map,i=n??{},a={...wu,...i.platform,_c:r};return _l(e,t,{...i,platform:a})};function Iu(e){return typeof e==`object`&&!!e&&`$el`in e}function Lu(e){if(Iu(e)){let t=e.$el;return Ml(t)&&Al(t)===`#comment`?null:t}return e}function Ru(e){return typeof e==`function`?e():P(e)}function zu(e){return{name:`arrow`,options:e,fn(t){let n=Lu(Ru(e.element));return n==null?{}:Nu({element:n,padding:e.padding}).fn(t)}}}function Bu(e){return typeof window>`u`?1:(e.ownerDocument.defaultView||window).devicePixelRatio||1}function Vu(e,t){let n=Bu(e);return Math.round(t*n)/n}function Hu(e,t,n){n===void 0&&(n={});let r=n.whileElementsMounted,i=I(()=>Ru(n.open)??!0),a=I(()=>Ru(n.middleware)),o=I(()=>Ru(n.placement)??`bottom`),s=I(()=>Ru(n.strategy)??`absolute`),c=I(()=>Ru(n.transform)??!0),u=I(()=>Lu(e.value)),d=I(()=>Lu(t.value)),f=B(0),p=B(0),m=B(s.value),h=B(o.value),g=He({}),_=B(!1),v=I(()=>{let e={position:m.value,left:`0`,top:`0`};if(!d.value)return e;let t=Vu(d.value,f.value),n=Vu(d.value,p.value);return c.value?{...e,transform:`translate(`+t+`px, `+n+`px)`,...Bu(d.value)>=1.5&&{willChange:`transform`}}:{position:m.value,left:t+`px`,top:n+`px`}}),y;function b(){if(u.value==null||d.value==null)return;let e=i.value;Fu(u.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 S(){if(x(),r===void 0){b();return}if(u.value!=null&&d.value!=null){y=r(u.value,d.value,b);return}}function C(){i.value||(_.value=!1)}return l([a,o,s,i],b,{flush:`sync`}),l([u,d],S,{flush:`sync`}),l(i,C,{flush:`sync`}),tt()&&it(x),{x:Ee(f),y:Ee(p),strategy:Ee(m),placement:Ee(h),middlewareData:Ee(g),isPositioned:Ee(_),floatingStyles:v,update:b}}var Uu=[`dir`],Wu={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},[Gu,Ku]=a(`PopperContent`),qu=j({inheritAttrs:!1,__name:`PopperContent`,props:d({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}},{...Wu}),emits:[`placed`],setup(n,{emit:r}){let i=n,a=r,o=Nc(),{forwardRef:s,currentElement:c}=t(),l=e(I(()=>i.dir)),u=B(),d=B(),{width:f,height:m}=Xs(d),h=I(()=>i.side+(i.align===`center`?``:`-${i.align}`)),g=I(()=>typeof i.collisionPadding==`number`?i.collisionPadding:{top:0,right:0,bottom:0,left:0,...i.collisionPadding}),v=I(()=>Array.isArray(i.collisionBoundary)?i.collisionBoundary:[i.collisionBoundary]),y=I(()=>({padding:g.value,boundary:v.value.filter(Lc),altBoundary:v.value.length>0})),x=I(()=>({mainAxis:i.sideFlip,crossAxis:i.alignFlip})),S=I(()=>[Ou({mainAxis:i.sideOffset+m.value,alignmentAxis:i.alignOffset}),i.prioritizePosition&&i.avoidCollisions&&Au({...y.value,...x.value}),i.avoidCollisions&&ku({mainAxis:!0,crossAxis:!!i.prioritizePosition,limiter:i.sticky===`partial`?Pu():void 0,...y.value}),!i.prioritizePosition&&i.avoidCollisions&&Au({...y.value,...x.value}),ju({...y.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`)}}),d.value&&zu({element:d.value,padding:i.arrowPadding}),Rc({arrowWidth:f.value,arrowHeight:m.value,dir:l.value}),i.hideWhenDetached&&Mu({strategy:`referenceHidden`,...y.value})]),{floatingStyles:C,placement:w,isPositioned:T,middlewareData:E,update:ee}=Hu(I(()=>i.reference??o.anchor.value),u,{strategy:i.positionStrategy,placement:h,whileElementsMounted:(...e)=>Du(...e,{layoutShift:!i.disableUpdateOnLayoutShift,animationFrame:i.updatePositionStrategy===`always`}),middleware:S}),D=I(()=>zc(w.value)[0]),ne=I(()=>zc(w.value)[1]);te(()=>{T.value&&a(`placed`)});let re=I(()=>{let e=E.value.arrow?.centerOffset!==0;return i.hideShiftedArrow&&e}),O=B(``);return L(()=>{c.value&&(O.value=window.getComputedStyle(c.value).zIndex)}),Ku({placedSide:D,onArrowChange:e=>d.value=e,arrowX:I(()=>E.value.arrow?.x??0),arrowY:I(()=>E.value.arrow?.y??0),shouldHideArrow:re}),(e,t)=>(z(),N(`div`,{ref_key:`floatingRef`,ref:u,"data-reka-popper-content-wrapper":``,dir:P(l),style:ut({...P(C),transform:P(T)?P(C).transform:`translate(0, -200%)`,minWidth:`max-content`,zIndex:O.value,"--reka-popper-transform-origin":[P(E).transformOrigin?.x,P(E).transformOrigin?.y].join(` `),...P(E).hide?.referenceHidden&&{visibility:`hidden`,pointerEvents:`none`}})},[i.memoDependencies?ce([i.asChild,i.as,D.value,ne.value,P(T),...Object.values(e.$attrs),...i.memoDependencies],()=>(z(),V(P(p),b({key:0,ref:P(s)},e.$attrs,{"as-child":i.asChild,as:i.as,"data-side":D.value,"data-align":ne.value,style:{animation:P(T)?void 0:`none`}}),{default:_(()=>[R(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`style`])),t,0):(z(),V(P(p),b({key:1,ref:P(s)},e.$attrs,{"as-child":i.asChild,as:i.as,"data-side":D.value,"data-align":ne.value,dir:P(l),style:{animation:P(T)?void 0:`none`}}),{default:_(()=>[R(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`dir`,`style`]))],12,Uu))}});function Ju(e){let t=r({nonce:B()});return I(()=>e?.value||t.nonce?.value)}var Yu=[` `,`Enter`,`ArrowUp`,`ArrowDown`],Xu=[` `,`Enter`];function Zu(e,t,n){return e===void 0?!1:Array.isArray(e)?e.some(e=>Qu(e,t,n)):Qu(e,t,n)}function Qu(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]:ws(e,t)}function $u(e){return e==null||e===``||Array.isArray(e)&&e.length===0}var ed=[`value`],[td,nd]=a(`SelectRoot`),rd=j({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(t,{emit:n}){let r=t,i=n,{required:a,disabled:o,multiple:s,dir:c}=$e(r),l=S(r,`modelValue`,i,{defaultValue:r.defaultValue??(s.value?[]:void 0),passive:r.modelValue===void 0,deep:!0}),u=S(r,`open`,i,{defaultValue:r.defaultOpen,passive:r.open===void 0}),d=B(),f=B(),p=B({x:0,y:0}),m=I(()=>s.value&&Array.isArray(l.value)?l.value?.length===0:Ds(l.value));jc({isProvider:!0});let h=e(c),g=zs(d),v=B(new Set),y=I(()=>Array.from(v.value).map(e=>e.value).join(`;`));function x(e){if(s.value){let t=Array.isArray(l.value)?[...l.value]:[],n=t.findIndex(t=>Qu(t,e,r.by));n===-1?t.push(e):t.splice(n,1),l.value=[...t]}else l.value=e}function C(e){return Array.from(v.value).find(t=>Zu(e,t.value,r.by))}return nd({triggerElement:d,onTriggerChange:e=>{d.value=e},valueElement:f,onValueElementChange:e=>{f.value=e},contentId:``,modelValue:l,onValueChange:x,by:r.by,open:u,multiple:s,required:a,onOpenChange:e=>{u.value=e},dir:h,triggerPointerDownPosRef:p,disabled:o,isEmptyModelValue:m,optionsSet:v,onOptionAdd:e=>{let t=C(e.value);t&&v.value.delete(t),v.value.add(e)},onOptionRemove:e=>{let t=C(e.value);t&&v.value.delete(t)}}),(e,t)=>(z(),V(P(Fc),null,{default:_(()=>[R(e.$slots,`default`,{modelValue:P(l),open:P(u)}),P(g)&&e.name?(z(),V(id,{key:y.value,"aria-hidden":`true`,tabindex:`-1`,multiple:P(s),required:P(a),name:e.name,autocomplete:e.autocomplete,disabled:P(o),value:P(l)},{default:_(()=>[P(Ds)(P(l))?(z(),N(`option`,{key:0,value:e.nullableValue},null,8,ed)):H(`v-if`,!0),(z(!0),N(w,null,De(Array.from(v.value),e=>(z(),N(`option`,b({key:e.value??``},{ref_for:!0},e),null,16))),128))]),_:1},8,[`multiple`,`required`,`name`,`autocomplete`,`disabled`,`value`])):H(`v-if`,!0)]),_:3}))}}),id=j({__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=B(),r=td();l(()=>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)=>(z(),V(P(Mc),{"as-child":``},{default:_(()=>[M(`select`,b({ref_key:`selectElement`,ref:n},t,{onInput:i}),[R(e.$slots,`default`)],16)]),_:3}))}}),ad=j({__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=i(e);return(e,n)=>(z(),V(P(qu),b(P(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:_(()=>[R(e.$slots,`default`)]),_:3},16))}}),od={onViewportChange:()=>{},itemTextRefCallback:()=>{},itemRefCallback:()=>{}},[sd,cd]=a(`SelectContent`),ld=j({__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,a=td();Ls(),Ns(n.bodyLock);let{CollectionSlot:o,getItems:s}=jc(),c=B();Ys(c);let{search:u,handleTypeaheadSearch:d}=Qs(),f=B(),p=B(),m=B(),h=B(!1),g=B(!1),v=B(!1);function y(){p.value&&c.value&&Oc([p.value,c.value])}l(h,()=>{y()});let{onOpenChange:S,triggerPointerDownPosRef:C}=a;L(e=>{if(!c.value)return;let t={x:0,y:0},n=e=>{t={x:Math.abs(Math.round(e.pageX)-(C.value?.x??0)),y:Math.abs(Math.round(e.pageY)-(C.value?.y??0))}},r=e=>{e.pointerType!==`touch`&&(t.x<=10&&t.y<=10?e.preventDefault():c.value?.contains(e.target)||S(!1),document.removeEventListener(`pointermove`,n),C.value=null)};C.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 w(e){let t=e.ctrlKey||e.altKey||e.metaKey;if(e.key===`Tab`&&e.preventDefault(),!t&&e.key.length===1&&d(e.key,s()),[`ArrowUp`,`ArrowDown`,`Home`,`End`].includes(e.key)){let t=[...s().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(()=>Oc(t)),e.preventDefault()}}let T=I(()=>n.position===`popper`?n:{}),E=i(T.value);return cd({content:c,viewport:f,onViewportChange:e=>{f.value=e},itemRefCallback:(e,t,n)=>{let r=!g.value&&!n,i=Zu(a.modelValue.value,t,a.by);if(a.multiple.value){if(v.value)return;(i||r)&&(p.value=e,i&&(v.value=!0))}else(i||r)&&(p.value=e);r&&(g.value=!0)},selectedItem:p,selectedItemText:m,onItemLeave:()=>{c.value?.focus()},itemTextRefCallback:(e,t,n)=>{let r=!g.value&&!n;(Zu(a.modelValue.value,t,a.by)||r)&&(m.value=e)},focusSelectedItem:y,position:n.position,isPositioned:h,searchRef:u}),(e,t)=>(z(),V(P(o),null,{default:_(()=>[F(P(wc),{"as-child":``,onMountAutoFocus:t[6]||=x(()=>{},[`prevent`]),onUnmountAutoFocus:t[7]||=e=>{r(`closeAutoFocus`,e),!e.defaultPrevented&&(P(a).triggerElement.value?.focus({preventScroll:!0}),e.preventDefault())}},{default:_(()=>[F(P(uc),{"as-child":``,"disable-outside-pointer-events":e.disableOutsidePointerEvents,onFocusOutside:t[2]||=x(()=>{},[`prevent`]),onDismiss:t[3]||=e=>P(a).onOpenChange(!1),onEscapeKeyDown:t[4]||=e=>r(`escapeKeyDown`,e),onPointerDownOutside:t[5]||=e=>r(`pointerDownOutside`,e)},{default:_(()=>[(z(),V(Ae(e.position===`popper`?ad:fd),b({...e.$attrs,...P(E)},{id:P(a).contentId,ref:e=>{if(!e)return;let t=P(D)(e);t?.hasAttribute(`data-reka-popper-content-wrapper`)?c.value=t.firstElementChild:c.value=t},role:`listbox`,"data-state":P(a).open.value?`open`:`closed`,dir:P(a).dir.value,style:{display:`flex`,flexDirection:`column`,outline:`none`},onContextmenu:t[0]||=x(()=>{},[`prevent`]),onPlaced:t[1]||=e=>h.value=!0,onKeydown:w}),{default:_(()=>[R(e.$slots,`default`)]),_:3},16,[`id`,`data-state`,`dir`,`onKeydown`]))]),_:3},8,[`disable-outside-pointer-events`])]),_:3})]),_:3}))}}),[ud,dd]=a(`SelectItemAlignedPosition`),fd=j({inheritAttrs:!1,__name:`SelectItemAlignedPosition`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`placed`],setup(e,{emit:n}){let r=e,i=n,{getItems:a}=jc(),o=td(),s=sd(),c=B(!1),l=B(!0),u=B(),{forwardRef:d,currentElement:f}=t(),{viewport:m,selectedItem:h,selectedItemText:v,focusSelectedItem:y}=s;function x(){if(o.triggerElement.value&&o.valueElement.value&&u.value&&f.value&&m?.value&&h?.value&&v?.value){let e=o.triggerElement.value.getBoundingClientRect(),t=f.value.getBoundingClientRect(),n=o.valueElement.value.getBoundingClientRect(),r=v.value.getBoundingClientRect();if(o.dir.value!==`rtl`){let i=r.left-t.left,a=n.left-i,o=e.left-a,s=e.width+o,c=Math.max(s,t.width),l=window.innerWidth-10,d=Ts(a,10,Math.max(10,l-c));u.value.style.minWidth=`${s}px`,u.value.style.left=`${d}px`}else{let i=t.right-r.right,a=window.innerWidth-n.right-i,o=window.innerWidth-e.right-a,s=e.width+o,c=Math.max(s,t.width),l=window.innerWidth-10,d=Ts(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=m.value.scrollHeight,p=window.getComputedStyle(f.value),g=Number.parseInt(p.borderTopWidth,10),_=Number.parseInt(p.paddingTop,10),y=Number.parseInt(p.borderBottomWidth,10),b=Number.parseInt(p.paddingBottom,10),x=g+_+d+b+y,S=Math.min(h.value.offsetHeight*5,x),C=window.getComputedStyle(m.value),w=Number.parseInt(C.paddingTop,10),T=Number.parseInt(C.paddingBottom,10),E=e.top+e.height/2-10,ee=l-E,D=h.value.offsetHeight/2,te=h.value.offsetTop+D,ne=g+_+te,re=x-ne;if(ne<=E){let e=h.value===s.at(-1);u.value.style.bottom=`0px`;let t=f.value.clientHeight-m.value.offsetTop-m.value.offsetHeight,n=ne+Math.max(ee,D+(e?T:0)+t+y);u.value.style.height=`${n}px`}else{let e=h.value===s[0];u.value.style.top=`0px`;let t=Math.max(E,g+m.value.offsetTop+(e?w:0)+D)+re;u.value.style.height=`${t}px`,m.value.scrollTop=ne-E+m.value.offsetTop}u.value.style.margin=`10px 0`,u.value.style.minHeight=`${S}px`,u.value.style.maxHeight=`${l}px`,i(`placed`),requestAnimationFrame(()=>c.value=!0)}}let S=B(``);ve(async()=>{await A(),x(),f.value&&(S.value=window.getComputedStyle(f.value).zIndex)});function C(e){e&&l.value===!0&&(x(),y?.(),l.value=!1)}return g(o.triggerElement,()=>{x()}),dd({contentWrapper:u,shouldExpandOnScrollRef:c,onScrollButtonChange:C}),(e,t)=>(z(),N(`div`,{ref_key:`contentWrapperElement`,ref:u,style:ut({display:`flex`,flexDirection:`column`,position:`fixed`,zIndex:S.value})},[F(P(p),b({ref:P(d),style:{boxSizing:`border-box`,maxHeight:`100%`}},{...e.$attrs,...r}),{default:_(()=>[R(e.$slots,`default`)]),_:3},16)],4))}}),pd=j({inheritAttrs:!1,__name:`SelectProvider`,props:{context:{type:Object,required:!0}},setup(e){return nd(e.context),cd(od),(e,t)=>R(e.$slots,`default`)}}),md={key:1},hd=j({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(e,{emit:t}){let r=e,i=n(r,t),a=td(),o=B();ve(()=>{o.value=new DocumentFragment});let s=B(),c=I(()=>r.forceMount||a.open.value),u=B(c.value),d;function f(){d&&=(clearTimeout(d),void 0)}return l(c,(e,t,n)=>{f(),d=setTimeout(()=>{u.value=c.value,d=void 0}),n(f)}),ke(f),(e,t)=>c.value||u.value||s.value?.present?(z(),V(P(rc),{key:0,ref_key:`presenceRef`,ref:s,present:c.value},{default:_(()=>[F(ld,we(m({...P(i),...e.$attrs})),{default:_(()=>[R(e.$slots,`default`)]),_:3},16)]),_:3},8,[`present`])):o.value?(z(),N(`div`,md,[(z(),V(oe,{to:o.value},[F(pd,{context:P(a)},{default:_(()=>[R(e.$slots,`default`)]),_:3},8,[`context`])],8,[`to`]))])):H(`v-if`,!0)}}),gd=j({__name:`SelectIcon`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(z(),V(P(p),{"aria-hidden":`true`,as:e.as,"as-child":e.asChild},{default:_(()=>[R(e.$slots,`default`,{},()=>[t[0]||=Ke(`▼`)])]),_:3},8,[`as`,`as-child`]))}}),[_d,vd]=a(`SelectItem`),yd=j({__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:n}){let r=e,i=n,{disabled:a}=$e(r),s=td(),c=sd(),{forwardRef:l,currentElement:u}=t(),{CollectionItem:d}=jc(),f=I(()=>Zu(s.modelValue?.value,r.value,s.by)),m=B(!1),h=B(r.textValue??``),g=o(void 0,`reka-select-item-text`);async function v(e){e.defaultPrevented||Es(`select.select`,y,{originalEvent:e,value:r.value})}async function y(e){await A(),i(`select`,e),!e.defaultPrevented&&(a.value||(s.onValueChange(r.value),s.multiple.value||s.onOpenChange(!1)))}async function b(e){await A(),!e.defaultPrevented&&(a.value?c.onItemLeave?.():e.currentTarget?.focus({preventScroll:!0}))}async function S(e){await A(),!e.defaultPrevented&&e.currentTarget===Z()&&c.onItemLeave?.()}async function C(e){await A(),!e.defaultPrevented&&(c.searchRef?.value===``||e.key!==` `)&&(Xu.includes(e.key)&&v(e),e.key===` `&&e.preventDefault())}if(r.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 ve(()=>{u.value&&c.itemRefCallback(u.value,r.value,r.disabled)}),vd({value:r.value,disabled:a,textId:g,isSelected:f,onItemTextChange:e=>{h.value=((h.value||e?.textContent)??``).trim()}}),(e,t)=>(z(),V(P(d),{value:{textValue:h.value}},{default:_(()=>[F(P(p),{ref:P(l),role:`option`,"aria-labelledby":P(g),"data-highlighted":m.value?``:void 0,"aria-selected":f.value,"data-state":f.value?`checked`:`unchecked`,"aria-disabled":P(a)||void 0,"data-disabled":P(a)?``:void 0,tabindex:P(a)?void 0:-1,as:e.as,"as-child":e.asChild,onFocus:t[0]||=e=>m.value=!0,onBlur:t[1]||=e=>m.value=!1,onPointerup:v,onPointerdown:t[2]||=e=>{e.currentTarget.focus({preventScroll:!0})},onTouchend:t[3]||=x(()=>{},[`prevent`,`stop`]),onPointermove:b,onPointerleave:S,onKeydown:C},{default:_(()=>[R(e.$slots,`default`)]),_:3},8,[`aria-labelledby`,`data-highlighted`,`aria-selected`,`data-state`,`aria-disabled`,`data-disabled`,`tabindex`,`as`,`as-child`])]),_:3},8,[`value`]))}}),bd=j({__name:`SelectItemIndicator`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=_d();return(e,r)=>P(n).isSelected.value?(z(),V(P(p),b({key:0,"aria-hidden":`true`},t),{default:_(()=>[R(e.$slots,`default`)]),_:3},16)):H(`v-if`,!0)}}),xd=j({inheritAttrs:!1,__name:`SelectItemText`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let n=e,r=td(),i=sd(),a=_d(),{forwardRef:o,currentElement:s}=t(),c=I(()=>({value:a.value,disabled:a.disabled.value,textContent:s.value?.textContent??a.value?.toString()??``}));return ve(()=>{s.value&&(a.onItemTextChange(s.value),i.itemTextRefCallback(s.value,a.value,a.disabled.value),r.onOptionAdd(c.value))}),ke(()=>{r.onOptionRemove(c.value)}),(e,t)=>(z(),V(P(p),b({id:P(a).textId,ref:P(o)},{...n,...e.$attrs}),{default:_(()=>[R(e.$slots,`default`)]),_:3},16,[`id`]))}}),Sd=j({__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)=>(z(),V(P(kc),we(m(t)),{default:_(()=>[R(e.$slots,`default`)]),_:3},16))}}),Cd=j({__name:`SelectScrollButtonImpl`,emits:[`autoScroll`],setup(e,{emit:t}){let n=t,{getItems:r}=jc(),i=sd(),a=B(null);function o(){a.value!==null&&(window.clearInterval(a.value),a.value=null)}L(()=>{r().map(e=>e.ref).find(e=>e===Z())?.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 T(()=>o()),(e,t)=>(z(),V(P(p),b({"aria-hidden":`true`,style:{flexShrink:0}},e.$parent?.$props,{onPointerdown:s,onPointermove:c,onPointerleave:t[0]||=()=>{o()}}),{default:_(()=>[R(e.$slots,`default`)]),_:3},16))}}),wd=j({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let n=sd(),r=n.position===`item-aligned`?ud():void 0,{forwardRef:i,currentElement:a}=t(),o=B(!1);return L(e=>{if(n.viewport?.value&&n.isPositioned?.value){let t=n.viewport.value;function r(){let e=t.scrollHeight-t.clientHeight;o.value=Math.ceil(t.scrollTop)<e}r(),t.addEventListener(`scroll`,r),e(()=>t.removeEventListener(`scroll`,r))}}),l(a,()=>{a.value&&r?.onScrollButtonChange(a.value)}),(e,t)=>o.value?(z(),V(Cd,{key:0,ref:P(i),onAutoScroll:t[0]||=()=>{let{viewport:e,selectedItem:t}=P(n);e?.value&&t?.value&&(e.value.scrollTop=e.value.scrollTop+t.value.offsetHeight)}},{default:_(()=>[R(e.$slots,`default`)]),_:3},512)):H(`v-if`,!0)}}),Td=j({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let n=sd(),r=n.position===`item-aligned`?ud():void 0,{forwardRef:i,currentElement:a}=t(),o=B(!1);return L(e=>{if(n.viewport?.value&&n.isPositioned?.value){let t=n.viewport.value;function r(){o.value=t.scrollTop>0}r(),t.addEventListener(`scroll`,r),e(()=>t.removeEventListener(`scroll`,r))}}),l(a,()=>{a.value&&r?.onScrollButtonChange(a.value)}),(e,t)=>o.value?(z(),V(Cd,{key:0,ref:P(i),onAutoScroll:t[0]||=()=>{let{viewport:e,selectedItem:t}=P(n);e?.value&&t?.value&&(e.value.scrollTop=e.value.scrollTop-t.value.offsetHeight)}},{default:_(()=>[R(e.$slots,`default`)]),_:3},512)):H(`v-if`,!0)}}),Ed=j({__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 n=e,r=td(),{forwardRef:i,currentElement:a}=t(),s=I(()=>r.disabled?.value||n.disabled);r.contentId||=o(void 0,`reka-select-content`),ve(()=>{r.onTriggerChange(a.value)});let{getItems:c}=jc(),{search:l,handleTypeaheadSearch:u,resetTypeahead:d}=Qs();function f(){s.value||(r.onOpenChange(!0),d())}function m(e){f(),r.triggerPointerDownPosRef.value={x:Math.round(e.pageX),y:Math.round(e.pageY)}}function h(e){return e.button===0&&e.ctrlKey===!1}let g=!1;function v(e){if(e.pointerType===`touch`)return e.preventDefault();let t=e.target;t.hasPointerCapture(e.pointerId)&&t.releasePointerCapture(e.pointerId),h(e)&&(m(e),g=!0)}function y(e){h(e)&&e.preventDefault()}function b(e){g||e.currentTarget?.focus(),g=!1}return(e,t)=>(z(),V(P(Ic),{"as-child":``,reference:e.reference},{default:_(()=>[F(P(p),{ref:P(i),role:`combobox`,type:e.as===`button`?`button`:void 0,"aria-controls":P(r).contentId,"aria-expanded":P(r).open.value||!1,"aria-required":P(r).required?.value,"aria-autocomplete":`none`,disabled:s.value,dir:P(r)?.dir.value,"data-state":P(r)?.open.value?`open`:`closed`,"data-disabled":s.value?``:void 0,"data-placeholder":P($u)(P(r).modelValue?.value)?``:void 0,"as-child":e.asChild,as:e.as,onClick:b,onPointerdown:v,onMousedown:y,onPointerup:t[0]||=x(e=>{e.pointerType===`touch`&&m(e)},[`prevent`]),onKeydown:t[1]||=e=>{let t=P(l)!==``;!(e.ctrlKey||e.altKey||e.metaKey)&&e.key.length===1&&t&&e.key===` `||(P(u)(e.key,P(c)()),P(Yu).includes(e.key)&&(f(),e.preventDefault()))}},{default:_(()=>[R(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`]))}}),Dd=j({__name:`SelectValue`,props:{placeholder:{type:String,required:!1,default:``},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let n=e,{forwardRef:r,currentElement:i}=t(),a=td();ve(()=>{a.valueElement=i});let o=I(()=>{let e=[],t=Array.from(a.optionsSet.value),n=e=>t.find(t=>Zu(e,t.value,a.by));return e=Array.isArray(a.modelValue.value)?a.modelValue.value.map(e=>n(e)?.textContent??``):[n(a.modelValue.value)?.textContent??``],e.filter(Boolean)}),s=I(()=>o.value.length?o.value.join(`, `):n.placeholder);return(e,t)=>(z(),V(P(p),{ref:P(r),as:e.as,"as-child":e.asChild,style:{pointerEvents:`none`},"data-placeholder":o.value.length?void 0:n.placeholder},{default:_(()=>[R(e.$slots,`default`,{selectedLabel:o.value,modelValue:P(a).modelValue.value},()=>[Ke(k(s.value),1)])]),_:3},8,[`as`,`as-child`,`data-placeholder`]))}}),Od=j({__name:`SelectViewport`,props:{nonce:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let n=e,{nonce:r}=$e(n),i=Ju(r),a=sd(),o=a.position===`item-aligned`?ud():void 0,{forwardRef:s,currentElement:c}=t();ve(()=>{a?.onViewportChange(c.value)});let l=B(0);function u(e){let t=e.currentTarget,{shouldExpandOnScrollRef:n,contentWrapper:r}=o??{};if(n?.value&&r?.value){let e=Math.abs(l.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`)}}}l.value=t.scrollTop}return(e,t)=>(z(),N(w,null,[F(P(p),b({ref:P(s),"data-reka-select-viewport":``,role:`presentation`},{...e.$attrs,...n},{style:{position:`relative`,flex:1,overflow:`hidden auto`},onScroll:u}),{default:_(()=>[R(e.$slots,`default`)]),_:3},16),F(P(p),{as:`style`,nonce:P(i)},{default:_(()=>t[0]||=[Ke(` /* 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))}}),kd=j({__name:`CardDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(z(),N(`div`,{"data-slot":`card-description`,class:dt(P(ge)(`text-muted-foreground text-sm`,t.class))},[R(e.$slots,`default`)],2))}}),Ad=j({__name:`Input`,props:{defaultValue:{},modelValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=S(n,`modelValue`,t,{passive:!0,defaultValue:n.defaultValue});return(e,t)=>ee((z(),N(`input`,{"onUpdate:modelValue":t[0]||=e=>ae(r)?r.value=e:null,"data-slot":`input`,class:dt(P(ge)(`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)),[[pt,P(r)]])}}),jd={class:`mx-auto flex min-h-[70vh] max-w-md flex-col justify-center px-4`},Md={class:`flex size-12 items-center justify-center rounded-full bg-primary/10 text-primary`},Nd={class:`flex flex-col items-center gap-1`},Pd={"aria-labelledby":`authgate-security-heading`,class:`flex flex-col gap-1.5 text-xs text-muted-foreground`},Fd={class:`flex items-start gap-1.5`},Id={class:`flex items-start gap-1.5`},Ld={class:`flex items-start gap-1.5`},Rd={class:`relative`},zd=((e,t)=>{let n=e.__vccOpts||e;for(let[e,r]of t)n[e]=r;return n})(j({__name:`AuthGate`,setup(e){let t=lt(),n=je(),r=B(``),i=B(!1),a=B(null),o=I(()=>r.value.trim()!==``);function s(){let e=r.value;r.value=``,t.submit(e),n.refresh()}function c(){A(()=>a.value?.$el?.focus())}return ve(c),l(()=>t.error,e=>{e&&c()}),(e,n)=>{let c=st(`FontAwesomeIcon`);return z(),N(`div`,jd,[F(P(de),null,{default:_(()=>[F(P(f),{class:`flex flex-col items-center gap-3 text-center`},{default:_(()=>[M(`div`,Md,[F(c,{icon:P(Ue),class:`size-5`,"aria-hidden":`true`},null,8,[`icon`])]),M(`div`,Nd,[n[3]||=M(`span`,{class:`text-xs font-medium text-muted-foreground`},`LLM Gateway`,-1),F(P(le),{class:`text-lg font-semibold`},{default:_(()=>[...n[2]||=[Ke(`Admin key required`,-1)]]),_:1})]),F(P(kd),null,{default:_(()=>[...n[4]||=[Ke(`Enter an admin API key to continue.`,-1)]]),_:1})]),_:1}),F(P(ct),{class:`flex flex-col gap-4`},{default:_(()=>[n[10]||=M(`h2`,{id:`authgate-security-heading`,class:`sr-only`},` How this key is handled `,-1),M(`ul`,Pd,[M(`li`,Fd,[F(c,{icon:P(_e),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[5]||=M(`span`,null,`Kept only in this tab's session storage`,-1)]),M(`li`,Id,[F(c,{icon:P(_e),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[6]||=M(`span`,null,`Never written to disk`,-1)]),M(`li`,Ld,[F(c,{icon:P(_e),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[7]||=M(`span`,null,`Sent only to this page's own /admin/api/* requests`,-1)])]),M(`form`,{class:`flex flex-col gap-3`,onSubmit:x(s,[`prevent`])},[M(`div`,Rd,[F(P(Ad),{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":!!P(t).error,"aria-describedby":P(t).error?`authgate-error`:void 0,class:dt([`h-10 pr-10`,{"authgate-shake":P(t).error}])},null,8,[`modelValue`,`type`,`aria-invalid`,`aria-describedby`,`class`]),F(P(h),{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:_(()=>[F(c,{icon:i.value?P(Ze):P(Ce),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`aria-label`])]),F(P(h),{type:`submit`,class:`h-10 w-full`,disabled:!o.value},{default:_(()=>[...n[8]||=[Ke(` Continue `,-1)]]),_:1},8,[`disabled`])],32),P(t).error?(z(),V(P(hs),{key:0,id:`authgate-error`,variant:`destructive`},{default:_(()=>[F(P(_s),null,{default:_(()=>[...n[9]||=[Ke(`Authentication failed`,-1)]]),_:1}),F(P(gs),null,{default:_(()=>[Ke(k(P(t).error),1)]),_:1})]),_:1})):H(``,!0)]),_:1})]),_:1})])}}}),[[`__scopeId`,`data-v-b6d6fb1e`]]),Bd={class:`mt-1 list-disc space-y-0.5 pl-4 font-mono text-xs`},Vd={key:0,class:`mt-1 text-xs`},Hd=j({__name:`ConfigWarningsBanner`,props:{warnings:{},warningsDropped:{}},setup(e){let t=e,n=B(!1);function r(){n.value=!n.value}return(e,i)=>{let a=st(`FontAwesomeIcon`);return t.warnings.length>0?(z(),V(P(hs),{key:0,variant:`warn`},{default:_(()=>[F(a,{icon:P(qe),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`]),F(P(_s),{class:`flex items-center justify-between gap-2`},{default:_(()=>[M(`span`,null,k(t.warnings.length)+` configuration `+k(t.warnings.length===1?`warning`:`warnings`),1),F(P(h),{type:`button`,variant:`ghost`,size:`xs`,"aria-expanded":n.value,"aria-label":`${n.value?`Hide`:`Show`} configuration warning details`,onClick:r},{default:_(()=>[Ke(k(n.value?`Hide`:`Show`),1)]),_:1},8,[`aria-expanded`,`aria-label`])]),_:1}),n.value?(z(),V(P(gs),{key:0},{default:_(()=>[M(`ul`,Bd,[(z(!0),N(w,null,De(t.warnings,(e,t)=>(z(),N(`li`,{key:t},k(e),1))),128))]),t.warningsDropped?(z(),N(`p`,Vd,`and `+k(t.warningsDropped)+` more were not kept`,1)):H(``,!0)]),_:1})):H(``,!0)]),_:1})):H(``,!0)}}}),Ud=j({__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 r=n(e,t);return(e,t)=>(z(),V(P(rd),b({"data-slot":`select`},P(r)),{default:_(t=>[R(e.$slots,`default`,we(m(t)))]),_:3},16))}}),Wd=j({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 r=e,i=t,a=me(r,`class`),o=n(a,i);return(t,n)=>(z(),V(P(Sd),null,{default:_(()=>[F(P(hd),b({"data-slot":`select-content`,"data-align-trigger":e.position===`item-aligned`},{...t.$attrs,...P(o)},{class:P(ge)(`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`,r.class)}),{default:_(()=>[F(P(Jd)),F(P(Od),{"data-position":e.position,class:dt(P(ge)(`data-[position=popper]:h-(--reka-select-trigger-height) data-[position=popper]:w-full data-[position=popper]:min-w-(--reka-select-trigger-width)`))},{default:_(()=>[R(t.$slots,`default`)]),_:3},8,[`data-position`,`class`]),F(P(qd))]),_:3},16,[`data-align-trigger`,`class`])]),_:3}))}}),Gd={class:`pointer-events-none absolute right-2 flex size-4 items-center justify-center`},Kd=j({__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=me(t,`class`),r=i(n);return(e,n)=>(z(),V(P(yd),b({"data-slot":`select-item`},P(r),{class:P(ge)(`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:_(()=>[M(`span`,Gd,[F(P(bd),null,{default:_(()=>[R(e.$slots,`indicator-icon`,{},()=>[F(P(ps),{icon:P(_e),class:`pointer-events-none size-3.5`},null,8,[`icon`])])]),_:3})]),F(P(xd),null,{default:_(()=>[R(e.$slots,`default`)]),_:3})]),_:3},16,[`class`]))}}),qd=j({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=me(t,`class`),r=i(n);return(e,n)=>(z(),V(P(wd),b({"data-slot":`select-scroll-down-button`},P(r),{class:P(ge)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:_(()=>[R(e.$slots,`default`,{},()=>[F(P(ps),{icon:P(ye),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),Jd=j({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=me(t,`class`),r=i(n);return(e,n)=>(z(),V(P(Td),b({"data-slot":`select-scroll-up-button`},P(r),{class:P(ge)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:_(()=>[R(e.$slots,`default`,{},()=>[F(P(ps),{icon:P(s),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),Yd=j({__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=me(t,`class`,`size`),r=i(n);return(n,i)=>(z(),V(P(Ed),b({"data-slot":`select-trigger`,"data-size":e.size},P(r),{class:P(ge)(`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:_(()=>[R(n.$slots,`default`),F(P(gd),{"as-child":``},{default:_(()=>[F(P(ps),{icon:P(ye),class:`text-muted-foreground size-4 pointer-events-none`},null,8,[`icon`])]),_:1})]),_:3},16,[`data-size`,`class`]))}}),Xd=j({__name:`SelectValue`,props:{placeholder:{},asChild:{type:Boolean},as:{}},setup(e){let t=e;return(e,n)=>(z(),V(P(Dd),b({"data-slot":`select-value`},t),{default:_(()=>[R(e.$slots,`default`)]),_:3},16))}}),Zd={providers:`models`,usage:`consumers`,charts:`spend`,events:`reliability`,targets:`targets`};function Qd(e){let t=e.startsWith(`#`)?e.slice(1):e,n=t.indexOf(`?`),r=n===-1?t:t.slice(0,n),i=n===-1?``:t.slice(n+1);if(Pe(r))return{page:r,query:new URLSearchParams(i)};let a=Zd[r];return a?{page:a,query:new URLSearchParams}:{page:Qe,query:new URLSearchParams(i)}}function $d(e,t){let n=Object.entries(t).filter(([,e])=>e!==``);return n.length===0?`#${e}`:`#${e}?${new URLSearchParams(n).toString()}`}var ef=/^(all|group:.+|user:.+|provider:.+)$/;function tf(e){let t={},n=e.get(`range`);n&&ot(n)&&(t.range=n);let r=e.get(`cmp`);r&&Ve(r)&&(t.cmp=r);let i=e.get(`scope`);return i&&ef.test(i)&&(t.scope=i),t}var nf=new Set([`range`,`cmp`,`scope`]);function rf(e){let t={};for(let[n,r]of e.entries())nf.has(n)||r!==``&&(t[n]=r);return t}var af=xe(`filters`,{state:()=>({range:`7d`,cmp:nt,scope:`all`}),getters:{window:e=>Se[e.range].window,span:e=>Se[e.range].span,cmpSpec:e=>{let t=Xe(e.range);return{...t,requested:e.cmp===`prev`&&t.available}}},actions:{setFilters(e){e.range!==void 0&&(this.range=e.range),e.cmp!==void 0&&(this.cmp=e.cmp),e.scope!==void 0&&(this.scope=e.scope)}}}),of={class:`flex flex-wrap items-end gap-3`},sf={class:`flex flex-col gap-1`},cf={class:`flex flex-col gap-1`},lf=j({__name:`GlobalFilterBar`,setup(e){let t={"24h":`Last 24 hours`,"48h":`Last 48 hours`,"7d":`Last 7 days`,"14d":`Last 14 days`,"30d":`Last 30 days`,"3mo":`Last 3 months`,"6mo":`Last 6 months`,"12mo":`Last 12 months`},n=af();function r(e){typeof e==`string`&&n.setFilters({range:e})}function i(){if(n.cmp===`prev`){n.setFilters({cmp:`none`});return}n.cmpSpec.available&&n.setFilters({cmp:`prev`})}let a=I(()=>n.cmp!==`prev`&&!n.cmpSpec.available),o=I(()=>n.cmp===`prev`&&!n.cmpSpec.available?`Comparison unavailable for this range (${n.cmpSpec.reason}) — click to turn off`:n.cmpSpec.available?`Compare against the previous equal-length period`:`Comparison unavailable for this range: ${n.cmpSpec.reason}`),s=B(n.scope);l(()=>n.scope,e=>{s.value=e});function c(){let e=s.value.trim()||`all`;ef.test(e)?n.setFilters({scope:e}):s.value=n.scope}return(e,l)=>{let u=st(`FontAwesomeIcon`);return z(),N(`div`,of,[M(`div`,sf,[l[1]||=M(`label`,{id:`global-filter-range-label`,class:`text-xs font-medium text-muted-foreground`},`Range`,-1),F(P(Ud),{"model-value":P(n).range,"onUpdate:modelValue":r},{default:_(()=>[F(P(Yd),{"aria-labelledby":`global-filter-range-label`,class:`w-36`},{default:_(()=>[F(P(Xd))]),_:1}),F(P(Wd),null,{default:_(()=>[(z(!0),N(w,null,De(P(Ie),e=>(z(),V(P(Kd),{key:e,value:e},{default:_(()=>[Ke(k(t[e]),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])]),F(P(h),{type:`button`,variant:`outline`,"aria-pressed":P(n).cmp===`prev`,disabled:a.value,title:o.value,onClick:i},{default:_(()=>[F(u,{icon:P(et),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`]),l[2]||=Ke(` vs previous period `,-1)]),_:1},8,[`aria-pressed`,`disabled`,`title`]),M(`div`,cf,[l[3]||=M(`label`,{for:`global-filter-scope`,class:`text-xs font-medium text-muted-foreground`},`Scope`,-1),F(P(Ad),{id:`global-filter-scope`,modelValue:s.value,"onUpdate:modelValue":l[0]||=e=>s.value=e,class:`w-48`,placeholder:`all`,title:`all, group:<name>, user:<name>, or provider:<name>`,onKeyup:he(c,[`enter`]),onBlur:c},null,8,[`modelValue`])])])}}}),uf={"aria-label":`Primary`,class:`flex gap-1 overflow-x-auto border-b border-border pb-2 md:w-52 md:shrink-0 md:flex-col md:border-r md:border-b-0 md:pr-3 md:pb-0`},df=[`aria-current`,`onClick`],ff=j({__name:`SidebarNav`,setup(e){let t=Je();return(e,n)=>{let r=st(`FontAwesomeIcon`);return z(),N(`nav`,uf,[(z(!0),N(w,null,De(P(We),e=>(z(),N(`button`,{key:e.id,type:`button`,"aria-current":P(t).page===e.id?`page`:void 0,class:dt([`flex shrink-0 items-center gap-2 rounded-lg px-3 py-2 text-sm font-medium whitespace-nowrap transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50 md:w-full`,P(t).page===e.id?`bg-accent text-accent-foreground`:`text-muted-foreground hover:bg-muted hover:text-foreground`]),onClick:n=>P(t).goTo(e.id)},[F(r,{icon:e.icon,class:`size-4`,"aria-hidden":`true`},null,8,[`icon`]),M(`span`,null,k(e.label),1)],10,df))),128))])}}}),pf={class:`pointer-events-none fixed inset-x-0 bottom-0 z-50 flex flex-col-reverse gap-2 p-4 pb-[calc(env(safe-area-inset-bottom)+1rem)] sm:inset-x-auto sm:right-4 sm:bottom-4 sm:w-96`},mf={"aria-live":`assertive`,class:`flex flex-col-reverse gap-2`},hf={class:`min-w-0 flex-1 text-sm`},gf={"aria-live":`polite`,class:`flex flex-col-reverse gap-2`},_f={class:`min-w-0 flex-1 text-sm`},vf=j({__name:`ToastViewport`,setup(e){let t=be(),n={success:_e,error:qe,info:Ye},r={success:`text-chart-requests`,error:`text-destructive`,info:`text-muted-foreground`},i=I(()=>t.toasts.filter(e=>e.kind!==`error`)),a=I(()=>t.toasts.filter(e=>e.kind===`error`));function o(e){t.dismiss(e.id)}return(e,t)=>{let s=st(`FontAwesomeIcon`);return z(),N(`div`,pf,[M(`div`,mf,[F(Te,{tag:`div`,class:`flex flex-col-reverse gap-2`,"enter-active-class":`transition duration-150 ease-out motion-reduce:transition-none`,"enter-from-class":`translate-y-2 opacity-0`,"leave-active-class":`transition duration-150 ease-in motion-reduce:transition-none`,"leave-to-class":`opacity-0`},{default:_(()=>[(z(!0),N(w,null,De(a.value,e=>(z(),N(`div`,{key:e.id,class:`pointer-events-auto flex items-start gap-2 rounded-lg border bg-popover px-3 py-2.5 text-popover-foreground shadow-lg`},[F(s,{icon:n[e.kind],class:dt([`mt-0.5 size-3.5 shrink-0`,r[e.kind]]),"aria-hidden":`true`},null,8,[`icon`,`class`]),M(`p`,hf,k(e.message),1),F(P(h),{type:`button`,variant:`ghost`,size:`icon`,class:`-mt-1 -mr-1 size-6 shrink-0 text-muted-foreground hover:text-foreground`,"aria-label":`Dismiss: ${e.message}`,onClick:t=>o(e)},{default:_(()=>[F(s,{icon:P(Fe),class:`size-3`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`aria-label`,`onClick`])]))),128))]),_:1})]),M(`div`,gf,[F(Te,{tag:`div`,class:`flex flex-col-reverse gap-2`,"enter-active-class":`transition duration-150 ease-out motion-reduce:transition-none`,"enter-from-class":`translate-y-2 opacity-0`,"leave-active-class":`transition duration-150 ease-in motion-reduce:transition-none`,"leave-to-class":`opacity-0`},{default:_(()=>[(z(!0),N(w,null,De(i.value,e=>(z(),N(`div`,{key:e.id,class:`pointer-events-auto flex items-start gap-2 rounded-lg border bg-popover px-3 py-2.5 text-popover-foreground shadow-lg`},[F(s,{icon:n[e.kind],class:dt([`mt-0.5 size-3.5 shrink-0`,r[e.kind]]),"aria-hidden":`true`},null,8,[`icon`,`class`]),M(`p`,_f,k(e.message),1),F(P(h),{type:`button`,variant:`ghost`,size:`icon`,class:`-mt-1 -mr-1 size-6 shrink-0 text-muted-foreground hover:text-foreground`,"aria-label":`Dismiss: ${e.message}`,onClick:t=>o(e)},{default:_(()=>[F(s,{icon:P(Fe),class:`size-3`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`aria-label`,`onClick`])]))),128))]),_:1})])])}}});function yf(){let e=af(),t=Je();function n(n){let{page:r,query:i}=Qd(n),a=tf(i);e.setFilters({range:a.range??`7d`,cmp:a.cmp??`none`,scope:a.scope??`all`}),t.goTo(r,rf(i))}let r=typeof window<`u`;r&&n(window.location.hash);let i=I(()=>{let n={};return e.range!==`7d`&&(n.range=e.range),e.cmp!==`none`&&(n.cmp=e.cmp),e.scope!==`all`&&(n.scope=e.scope),Object.assign(n,t.params),$d(t.page,n)});l(i,e=>{r&&window.location.hash!==e&&window.history.replaceState(null,``,e)},{immediate:!0});function a(){n(window.location.hash)}r&&(ve(()=>window.addEventListener(`hashchange`,a)),ke(()=>window.removeEventListener(`hashchange`,a)))}var bf=(function(){let e=typeof document<`u`&&document.createElement(`link`).relList;return e&&e.supports&&e.supports(`modulepreload`)?`modulepreload`:`preload`})(),xf=function(e){return`/admin/`+e},Sf={},Cf=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=xf(t,n),t=s(t),t in Sf)return;Sf[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`:bf,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)})},wf={class:`flex w-full flex-col gap-4 px-4 py-6 sm:px-6 lg:px-8`},Tf={class:`flex flex-col gap-3`},Ef={class:`flex items-center justify-between gap-2`},Df={key:0,class:`flex items-center gap-1.5 text-sm text-muted-foreground`},Of={key:2,class:`flex flex-col gap-4 md:flex-row`},kf={class:`min-w-0 flex-1`},Af=`https://github.com/lukaszraczylo/traefik-llmgateway`,jf=ue(j({__name:`App`,setup(e){let t=lt(),n=je(),r=Je();yf();let i={home:Me(()=>Cf(()=>import(`./HomePage-xxao-DzQ.js`),__vite__mapDeps([0,1,2,3,4,5,6,7,8,9,10,11,12]))),spend:Me(()=>Cf(()=>import(`./SpendPage-6ZX2q3Zv.js`),__vite__mapDeps([13,1,2,3,4,5,14,15,6,16,17,8,18,19,11,12,20,21]))),consumers:Me(()=>Cf(()=>import(`./ConsumersPage-i8sZV9MX.js`),__vite__mapDeps([22,1,23,3,17,5,2,4,24,14,15,6,16,25,7,8,18,19,9]))),models:Me(()=>Cf(()=>import(`./ModelsPage-CcA1RHK6.js`),__vite__mapDeps([26,1,23,3,17,5,4,14,15,25,7,8,12,20,27,21]))),reliability:Me(()=>Cf(()=>import(`./ReliabilityPage-6-bz5x6z.js`),__vite__mapDeps([28,1,4,5,14,25,7,19,9,10,12,27,21]))),config:Me(()=>Cf(()=>import(`./ConfigPage-7IYcafPw.js`),__vite__mapDeps([29,1,2,3,17,4,24]))),targets:Me(()=>Cf(()=>import(`./TargetsPage-DYUVhhsj.js`),__vite__mapDeps([30,1,4,5,14,15,25,18])))},a=I(()=>i[r.page]),o=I(()=>{if(n.error)return`refresh failed: ${n.error}`;let e=n.overview?.replica;return`last updated ${n.lastUpdated?.toLocaleTimeString()??``}${e?` · replica ${e}`:``}`}),s=I(()=>!n.error&&!n.lastUpdated);return ve(()=>{n.startPolling()}),(e,r)=>{let i=st(`FontAwesomeIcon`);return z(),N(w,null,[M(`div`,wf,[M(`header`,Tf,[M(`div`,Ef,[r[0]||=M(`h1`,{class:`text-xl font-semibold tracking-tight`},`LLM Gateway — Admin`,-1),F(P(h),{as:`a`,href:Af,target:`_blank`,rel:`noopener noreferrer`,variant:`ghost`,size:`icon`,"aria-label":`GitHub repository`,class:`text-muted-foreground hover:text-foreground`},{default:_(()=>[F(i,{icon:P(ms),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`])]),_:1})]),P(t).isAuthenticated?(z(),N(`p`,Df,[s.value?(z(),N(w,{key:0},[F(P(rt),{class:`h-4 w-40`}),r[1]||=M(`span`,{class:`sr-only`},`Loading dashboard status…`,-1)],64)):(z(),N(w,{key:1},[P(n).error?(z(),V(i,{key:0,icon:P(at),class:`size-3.5 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):H(``,!0),M(`span`,{class:dt(P(n).error?`text-destructive`:void 0)},k(o.value),3)],64))])):H(``,!0),P(t).isAuthenticated?(z(),V(lf,{key:1})):H(``,!0)]),P(t).isAuthenticated?(z(),V(Hd,{key:0,warnings:P(n).overview?.warnings??[],"warnings-dropped":P(n).overview?.warningsDropped},null,8,[`warnings`,`warnings-dropped`])):H(``,!0),P(t).isAuthenticated?(z(),N(`div`,Of,[F(ff),M(`main`,kf,[(z(),V(Ae(a.value)))])])):(z(),V(zd,{key:1}))]),F(vf)],64)}}}));jf.use(Ne()),jf.component(`FontAwesomeIcon`,ps),jf.mount(`#app`);export{ps as _,Wd as a,kd as c,Ds as d,Z as f,hs as g,gs as h,Kd as i,jc as l,_s as m,Xd as n,Ud as o,ws as p,Yd as r,Ad as s,af as t,rc as u};",
		),
	},
	"kpi-chm3BiuF.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"aW1wb3J0e2MgYXMgZSxvIGFzIHR9ZnJvbSIuL1RyeUxvbmdlclJhbmdlQnV0dG9uLUNqa1VuYU96LmpzIjtpbXBvcnR7YyBhcyBuLHMgYXMgcn1mcm9tIi4vcHJvdmlkZXItcmF0ZS1EVTdPZ1NlQi5qcyI7ZnVuY3Rpb24gaShlKXtsZXQgbj0wO2ZvcihsZXQgciBvZiBlKXtsZXQgZT1yLmxpbWl0cz8uY29zdFBlck1vbnRoVVNEO2UmJmU+MCYmKG4rPU1hdGgucm91bmQoZSp0KSl9cmV0dXJuIG59ZnVuY3Rpb24gYShlLHQpe3JldHVybiB0PD0wP251bGw6ZS90fWZ1bmN0aW9uIG8odCl7aWYodD09PW51bGwpcmV0dXJuYG9rYDtzd2l0Y2goZSh0KSl7Y2FzZWBub3JtYWxgOnJldHVybmBva2A7Y2FzZWBhbWJlcmA6cmV0dXJuYHdhcm5gO2Nhc2VgcmVkYDpyZXR1cm5gY3JpdGljYWxgfX1mdW5jdGlvbiBzKGUpe3JldHVybiBlLmZpbHRlcihlPT5lLmhlYWx0aFN0YXRlIT09YGNsb3NlZGApLmxlbmd0aH1mdW5jdGlvbiBjKGUpe2xldCB0PTAscj0wO2ZvcihsZXQgbiBvZiBlKXQrPW4uYXR0ZW1wdHNNaW51dGUscis9bi5mYWlsdXJlc01pbnV0ZTtsZXQgaT1uKHQscik7cmV0dXJue3JhdGU6aT09PW51bGw/bnVsbDoxLWksYXR0ZW1wdHM6dCxmYWlsdXJlczpyfX1mdW5jdGlvbiBsKGUpe2lmKGU9PT1udWxsKXJldHVybmBva2A7c3dpdGNoKHIoMS1lKSl7Y2FzZWBuby10cmFmZmljYDpjYXNlYGhlYWx0aHlgOnJldHVybmBva2A7Y2FzZWBkZWdyYWRlZGA6cmV0dXJuYHdhcm5gO2Nhc2Vgc2V2ZXJlYDpyZXR1cm5gY3JpdGljYWxgfX1leHBvcnR7cyBhcyBhLGMgYXMgaSxvIGFzIG4saSBhcyBvLGwgYXMgcixhIGFzIHR9Ow==",
		),
	},
	"provider-rate-DU7OgSeB.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"ZnVuY3Rpb24gZShlLHQpe3JldHVybiFOdW1iZXIuaXNGaW5pdGUoZSl8fGU8PTA/bnVsbDooZS0oTnVtYmVyLmlzRmluaXRlKHQpP3Q6MCkpL2V9ZnVuY3Rpb24gdChlKXtyZXR1cm4gZT09PW51bGw/YG5vLXRyYWZmaWNgOmU8Ljk/YHNldmVyZWA6ZTwuOTk/YGRlZ3JhZGVkYDpgaGVhbHRoeWB9ZnVuY3Rpb24gbih0LG4pe2xldCByPWUodCxuKTtyZXR1cm4gciE9PW51bGwmJnI8Ljk5fWZ1bmN0aW9uIHIoZSl7cmV0dXJuIGU+PTE/YDEwMCVgOmAke01hdGguZmxvb3IoZSoxMDApfSVgfWZ1bmN0aW9uIGkoZSx0KXtyZXR1cm4hTnVtYmVyLmlzRmluaXRlKGUpfHxlPD0wP251bGw6KE51bWJlci5pc0Zpbml0ZSh0KT90OjApL2V9ZnVuY3Rpb24gYShlKXtyZXR1cm4gZT09PW51bGw/YG5vIGRhdGFgOmU8PTA/YDAlYDpgJHtNYXRoLmNlaWwoZSoxMDApfSVgfWZ1bmN0aW9uIG8oZSx0LG4pe3JldHVybiBlPT09MT90Om59ZnVuY3Rpb24gcyh0LG4pe2lmKHQ8PTApcmV0dXJuYG5vIHRyYWZmaWMgaW4gdGhlIGxhc3QgbWludXRlYDtsZXQgaT1lKHQsbiksYT1pPT09bnVsbD9gYDpgICgke3IoaSl9KWA7cmV0dXJuYCR7dH0gJHtvKHQsYGF0dGVtcHRgLGBhdHRlbXB0c2ApfSwgJHtufSAke28obixgZmFpbHVyZWAsYGZhaWx1cmVzYCl9IGluIHRoZSBsYXN0IG1pbnV0ZSR7YX1gfWZ1bmN0aW9uIGModCxuKXtpZih0PD0wKXJldHVybmBubyB0cmFmZmljIHRvZGF5YDtsZXQgaT1lKHQsbiksYT1pPT09bnVsbD9gYDpgICgke3IoaSl9KWA7cmV0dXJuYCR7dH0gJHtvKHQsYGF0dGVtcHRgLGBhdHRlbXB0c2ApfSwgJHtufSAke28obixgZmFpbHVyZWAsYGZhaWx1cmVzYCl9IHRvZGF5JHthfWB9ZXhwb3J0e3MgYXMgYSxlIGFzIGMsbiBhcyBpLGEgYXMgbixpIGFzIG8scix0IGFzIHMsYyBhcyB0fTs=",
		),
	},
	"reliability-CFIkRxVV.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"aW1wb3J0e190IGFzIGUsYiBhcyB0LGQgYXMgbixnIGFzIHIseSBhcyBpfWZyb20iLi9Ta2VsZXRvbi1CMHppQjZPZC5qcyI7aW1wb3J0e3QgYXMgYX1mcm9tIi4vaW5kZXgtZHl3UzhPcFQuanMiO2ltcG9ydHtuIGFzIG99ZnJvbSIuL3Nlcmllcy1OSVJWQlhNUC5qcyI7ZnVuY3Rpb24gcyhlLHQpe3JldHVybiBlPT09YGhvdXJgP3t3aW5kb3c6YGhvdXJgLHNwYW46dH06ZT09PWBkYXlgP3t3aW5kb3c6YGRheWAsc3Bhbjp0fTp7d2luZG93OmBkYXlgLHNwYW46MzB9fWZ1bmN0aW9uIGMoZSx0KXtsZXQgbj1uZXcgTWFwKHQuc2VyaWVzLm1hcChlPT5bZS5zY29wZSxlLnBvaW50c10pKTtyZXR1cm4gZS5zZXJpZXMubWFwKGU9Pih7c2NvcGU6ZS5zY29wZSxwb2ludHM6byhuLmdldChlLnNjb3BlKT8/QXJyYXkoZS5wb2ludHMubGVuZ3RoKS5maWxsKDApLGUucG9pbnRzKX0pKX12YXIgbD1bYC0tY2hhcnQtcmVxdWVzdHNgLGAtLWNoYXJ0LXRva2Vucy1pbmAsYC0tY2hhcnQtdG9rZW5zLW91dGAsYC0tY2hhcnQtY29zdGBdO2Z1bmN0aW9uIHUoZSl7cmV0dXJuIGxbZSVsLmxlbmd0aF19dmFyIGQ9ZShgcmVsaWFiaWxpdHlgLHtzdGF0ZTooKT0+KHtidWNrZXRzOltdLHdpbmRvd1VzZWQ6YGRheWAsZXJyb3JSYXRlOltdLHRpbWVvdXRzOltdLGZhaWxvdmVyczpbXSxyZWplY3Rpb25zOltdLHVucHJpY2VkOltdLGxvYWRpbmc6ITEsbGFzdFVwZGF0ZWQ6bnVsbCxlcnJvcjpgYCxyZXFJZDowLHByb3ZpZGVyUGVyZkJ1Y2tldHM6W10scHJvdmlkZXJQZXJmV2luZG93VXNlZDpgZGF5YCxwcm92aWRlclBlcmZQb2ludHM6W10scHJvdmlkZXJQZXJmTGF0ZW5jeUVuYWJsZWQ6ITEscHJvdmlkZXJQZXJmTG9hZGluZzohMSxwcm92aWRlclBlcmZFcnJvcjpgYCxwcm92aWRlclBlcmZSZXFJZDowfSksYWN0aW9uczp7YXN5bmMgZmV0Y2goKXtsZXQgZT1yKCkub3ZlcnZpZXc7aWYoZT09PW51bGwpcmV0dXJuO2xldCBvPSsrdGhpcy5yZXFJZDt0aGlzLmxvYWRpbmc9ITA7dHJ5e2xldCByPWEoKSxpPWUucHJvdmlkZXJzLm1hcChlPT5lLm5hbWUpO2lmKGkubGVuZ3RoPT09MCl7aWYobyE9PXRoaXMucmVxSWQpcmV0dXJuO3RoaXMuYnVja2V0cz1bXSx0aGlzLndpbmRvd1VzZWQ9cyhyLndpbmRvdyxyLnNwYW4pLndpbmRvdyx0aGlzLmVycm9yUmF0ZT1bXSx0aGlzLnRpbWVvdXRzPVtdLHRoaXMuZmFpbG92ZXJzPVtdLHRoaXMucmVqZWN0aW9ucz1bXSx0aGlzLnVucHJpY2VkPVtdLHRoaXMubGFzdFVwZGF0ZWQ9bmV3IERhdGUsdGhpcy5lcnJvcj1gYDtyZXR1cm59bGV0e3dpbmRvdzpsLHNwYW46dX09cyhyLndpbmRvdyxyLnNwYW4pLGQ9aS5tYXAoZT0+YHByb3ZpZGVyOiR7ZX1gKSxbZixwLG0saCxnLF9dPWF3YWl0IFByb21pc2UuYWxsKFt0KG4oe3Njb3BlOmQsbWV0cmljOmBhdHRlbXB0YCx3aW5kb3c6bCxzcGFuOnV9KSksdChuKHtzY29wZTpkLG1ldHJpYzpgZmFpbGAsd2luZG93Omwsc3Bhbjp1fSkpLHQobih7c2NvcGU6ZCxtZXRyaWM6YHRpbWVvdXRgLHdpbmRvdzpsLHNwYW46dX0pKSx0KG4oe3Njb3BlOmQsbWV0cmljOmBmb3ZlcmAsd2luZG93Omwsc3Bhbjp1fSkpLHQobih7c2NvcGU6W2B0b3RhbGBdLG1ldHJpYzpgcmVqYCx3aW5kb3c6bCxzcGFuOnV9KSksdChuKHtzY29wZTpbYHRvdGFsYF0sbWV0cmljOmByNDAyYCx3aW5kb3c6bCxzcGFuOnV9KSldKTtpZihvIT09dGhpcy5yZXFJZClyZXR1cm47dGhpcy5idWNrZXRzPWYuYnVja2V0cyx0aGlzLndpbmRvd1VzZWQ9bCx0aGlzLmVycm9yUmF0ZT1jKGYscCksdGhpcy50aW1lb3V0cz1tLnNlcmllcyx0aGlzLmZhaWxvdmVycz1oLnNlcmllcyx0aGlzLnJlamVjdGlvbnM9Zy5zZXJpZXNbMF0/LnBvaW50cz8/W10sdGhpcy51bnByaWNlZD1fLnNlcmllc1swXT8ucG9pbnRzPz9bXSx0aGlzLmxhc3RVcGRhdGVkPW5ldyBEYXRlLHRoaXMuZXJyb3I9YGB9Y2F0Y2goZSl7aWYobyE9PXRoaXMucmVxSWR8fGUgaW5zdGFuY2VvZiBpJiYoZS5zdGF0dXM9PT00MDF8fGUuc3RhdHVzPT09NDAzKSlyZXR1cm47dGhpcy5lcnJvcj1lIGluc3RhbmNlb2YgRXJyb3I/ZS5tZXNzYWdlOlN0cmluZyhlKX1maW5hbGx5e289PT10aGlzLnJlcUlkJiYodGhpcy5sb2FkaW5nPSExKX19LGFzeW5jIGZldGNoUHJvdmlkZXJQZXJmKGUpe2xldCBuPSsrdGhpcy5wcm92aWRlclBlcmZSZXFJZCxvPXIoKS5vdmVydmlldz8uZmVhdHVyZXMubGF0ZW5jeVN0YXRzPz8hMTtpZighZXx8IW8pe2lmKG4hPT10aGlzLnByb3ZpZGVyUGVyZlJlcUlkKXJldHVybjt0aGlzLnByb3ZpZGVyUGVyZkJ1Y2tldHM9W10sdGhpcy5wcm92aWRlclBlcmZQb2ludHM9W10sdGhpcy5wcm92aWRlclBlcmZMYXRlbmN5RW5hYmxlZD0hMSx0aGlzLnByb3ZpZGVyUGVyZkVycm9yPWBgLHRoaXMucHJvdmlkZXJQZXJmTG9hZGluZz0hMTtyZXR1cm59dGhpcy5wcm92aWRlclBlcmZMb2FkaW5nPSEwO3RyeXtsZXQgcj1hKCkse3dpbmRvdzppLHNwYW46b309cyhyLndpbmRvdyxyLnNwYW4pLGM9bmV3IFVSTFNlYXJjaFBhcmFtcyh7a2luZDpgcHJvdmlkZXJgLHdpbmRvdzppLHNwYW46U3RyaW5nKG8pLHNlcmllczpgMWB9KTtjLmFwcGVuZChgaWRgLGUpO2xldCBsPWF3YWl0IHQoYC9hZG1pbi9hcGkvcGVyZm9ybWFuY2U/JHtjLnRvU3RyaW5nKCl9YCk7aWYobiE9PXRoaXMucHJvdmlkZXJQZXJmUmVxSWQpcmV0dXJuO3RoaXMucHJvdmlkZXJQZXJmQnVja2V0cz1sLmJ1Y2tldHM/P1tdLHRoaXMucHJvdmlkZXJQZXJmV2luZG93VXNlZD1pLHRoaXMucHJvdmlkZXJQZXJmUG9pbnRzPWwucG9pbnRzPz9bXSx0aGlzLnByb3ZpZGVyUGVyZkxhdGVuY3lFbmFibGVkPWwubGF0ZW5jeUVuYWJsZWQsdGhpcy5wcm92aWRlclBlcmZFcnJvcj1gYH1jYXRjaChlKXtpZihuIT09dGhpcy5wcm92aWRlclBlcmZSZXFJZHx8ZSBpbnN0YW5jZW9mIGkmJihlLnN0YXR1cz09PTQwMXx8ZS5zdGF0dXM9PT00MDMpKXJldHVybjt0aGlzLnByb3ZpZGVyUGVyZkVycm9yPWUgaW5zdGFuY2VvZiBFcnJvcj9lLm1lc3NhZ2U6U3RyaW5nKGUpfWZpbmFsbHl7bj09PXRoaXMucHJvdmlkZXJQZXJmUmVxSWQmJih0aGlzLnByb3ZpZGVyUGVyZkxvYWRpbmc9ITEpfX19fSk7ZXhwb3J0e3UgYXMgbixkIGFzIHIscyBhcyB0fTs=",
		),
	},
	"search-expand-CHd4FWZZ.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{a as e,i as t,n,r,s as i,t as a}from"./useId-B9dJumoI.js";import{$ as o,Ar as s,D as c,Dn as l,Er as u,Fr as d,Hn as f,I as p,N as m,Si as h,Un as g,V as _,Vt as v,W as y,X as b,Xn as ee,Z as x,_ as S,_n as C,an as w,bi as T,er as te,gi as E,hn as D,in as O,it as ne,lr as k,mt as re,nr as A,oi as j,on as M,pi as N,sn as P,ur as F,yi as I}from"./Skeleton-B0ziB6Od.js";import{d as ie,p as L,u as R}from"./index-dywS8OpT.js";import{t as z}from"./clipboard-B73fZ0c1.js";import{a as B,d as V,t as H}from"./badge-DUiBTDyA.js";function U(e,t){return ie(e)?!1:Array.isArray(e)?e.some(e=>L(e,t)):L(e,t)}var W=[`INPUT`,`TEXTAREA`];function G(e,t,n,r={}){if(!t||r.enableIgnoredElement&&W.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=K(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 K(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`?K(e,o,n,r):o:null}var[q,J]=i(`CollapsibleRoot`),Y=C({__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:n,emit:r}){let i=e,a=p(i,`open`,r,{defaultValue:i.defaultOpen,passive:i.open===void 0}),{disabled:o,unmountOnHide:s}=N(i);return J({contentId:``,disabled:o,open:a,unmountOnHide:s,onOpenToggle:()=>{o.value||(a.value=!a.value)}}),n({open:a}),t(),(e,t)=>(A(),M(E(c),{as:e.as,"as-child":i.asChild,"data-state":E(a)?`open`:`closed`,"data-disabled":E(o)?``:void 0},{default:d(()=>[k(e.$slots,`default`,{open:E(a)})]),_:3},8,[`as`,`as-child`,`data-state`,`data-disabled`]))}}),X=C({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:n}){let r=e,i=n,o=q();o.contentId||=a(void 0,`reka-collapsible-content`);let l=j(),{forwardRef:u,currentElement:p}=t(),h=j(0),_=j(0),v=O(()=>o.open.value),y=j(v.value),b=j();s(()=>[v.value,l.value?.present],async()=>{await g();let e=p.value;if(!e)return;b.value=b.value||{transitionDuration:e.style.transitionDuration,animationName:e.style.animationName},e.style.transitionDuration=`0s`,e.style.animationName=`none`;let t=e.getBoundingClientRect();_.value=t.height,h.value=t.width,y.value||(e.style.transitionDuration=b.value.transitionDuration,e.style.animationName=b.value.animationName)},{immediate:!0});let x=O(()=>y.value&&o.open.value);return ee(()=>{requestAnimationFrame(()=>{y.value=!1})}),m(p,`beforematch`,e=>{requestAnimationFrame(()=>{o.onOpenToggle(),i(`contentFound`)})}),(e,t)=>(A(),M(E(R),{ref_key:`presentRef`,ref:l,present:e.forceMount||E(o).open.value,"force-mount":!0},{default:d(({present:t})=>[D(E(c),f(e.$attrs,{id:E(o).contentId,ref:E(u),"as-child":r.asChild,as:e.as,hidden:t?void 0:E(o).unmountOnHide.value?``:`until-found`,"data-state":x.value?void 0:E(o).open.value?`open`:`closed`,"data-disabled":E(o).disabled?.value?``:void 0,style:{"--reka-collapsible-content-height":`${_.value}px`,"--reka-collapsible-content-width":`${h.value}px`}}),{default:d(()=>[!E(o).unmountOnHide.value||t?k(e.$slots,`default`,{key:0}):P(`v-if`,!0)]),_:2},1040,[`id`,`as-child`,`as`,`hidden`,`data-state`,`data-disabled`,`style`])]),_:3},8,[`present`]))}}),ae=C({__name:`CollapsibleTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let n=e;t();let r=q();return(e,t)=>(A(),M(E(c),{type:e.as===`button`?`button`:void 0,as:e.as,"as-child":n.asChild,"aria-controls":E(r).contentId,"aria-expanded":E(r).open.value,"data-state":E(r).open.value?`open`:`closed`,"data-disabled":E(r).disabled?.value?``:void 0,disabled:E(r).disabled?.value,onClick:E(r).onOpenToggle},{default:d(()=>[k(e.$slots,`default`)]),_:3},8,[`type`,`as`,`as-child`,`aria-controls`,`aria-expanded`,`data-state`,`data-disabled`,`disabled`,`onClick`]))}});function oe({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 se({type:e,defaultValue:t,modelValue:n}){return e||oe({type:e,defaultValue:t,modelValue:n})}function ce({type:e,defaultValue:t}){return t===void 0?e===`single`?void 0:[]:t}function le(e,t){let n=O(()=>se(e)),r=p(e,`modelValue`,t,{defaultValue:ce(e),passive:e.modelValue===void 0,deep:!0});function i(e){if(n.value===`single`)r.value=L(e,r.value)?void 0:e;else{let t=Array.isArray(r.value)?[...r.value||[]]:[r.value].filter(Boolean);if(U(t,e)){let n=t.findIndex(t=>L(t,e));t.splice(n,1)}else t.push(e);r.value=t}}return{modelValue:r,changeModelValue:i,isSingle:O(()=>n.value===`single`)}}var[Z,ue]=i(`AccordionRoot`),de=C({__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(n,{emit:r}){let i=n,a=r,{dir:o,disabled:s,unmountOnHide:l}=N(i),u=e(o),{modelValue:f,changeModelValue:p,isSingle:m}=le(i,a),{forwardRef:h,currentElement:g}=t();return ue({disabled:s,direction:u,orientation:i.orientation,parentElement:g,isSingle:m,collapsible:i.collapsible,modelValue:f,changeModelValue:p,unmountOnHide:l}),(e,t)=>(A(),M(E(c),{ref:E(h),"as-child":e.asChild,as:e.as},{default:d(()=>[k(e.$slots,`default`,{modelValue:E(f)})]),_:3},8,[`as-child`,`as`]))}}),Q=function(e){return e.Open=`open`,e.Closed=`closed`,e}(Q||{}),[$,fe]=i(`AccordionItem`),pe=C({__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:n}){let r=e,i=Z(),a=O(()=>i.isSingle.value?r.value===i.modelValue.value:Array.isArray(i.modelValue.value)&&i.modelValue.value.includes(r.value)),o=O(()=>i.disabled.value||r.disabled),s=O(()=>o.value?``:void 0),c=O(()=>a.value?Q.Open:Q.Closed);n({open:a,dataDisabled:s});let{currentRef:l,currentElement:u}=t();fe({open:a,dataState:c,disabled:o,dataDisabled:s,triggerId:``,currentRef:l,currentElement:u,value:O(()=>r.value)});function f(e){let t=e.target;if(Array.from(i.parentElement.value?.querySelectorAll(`[data-reka-collection-item]`)??[]).findIndex(e=>e===t)===-1)return null;G(e,t,i.parentElement.value,{arrowKeyOptions:i.orientation,dir:i.direction.value,focus:!0})}return(e,t)=>(A(),M(E(Y),{"data-orientation":E(i).orientation,"data-disabled":s.value,"data-state":c.value,disabled:o.value,open:a.value,as:r.as,"as-child":r.asChild,"unmount-on-hide":r.unmountOnHide??E(i).unmountOnHide.value,onKeydown:v(f,[`up`,`down`,`left`,`right`,`home`,`end`])},{default:d(()=>[k(e.$slots,`default`,{open:a.value})]),_:3},8,[`data-orientation`,`data-disabled`,`data-state`,`disabled`,`open`,`as`,`as-child`,`unmount-on-hide`]))}}),me=C({__name:`AccordionContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let n=e,r=Z(),i=$();return t(),(e,t)=>(A(),M(E(X),{role:`region`,"as-child":n.asChild,as:e.as,"force-mount":n.forceMount,"aria-labelledby":E(i).triggerId,"data-state":E(i).dataState.value,"data-disabled":E(i).dataDisabled.value,"data-orientation":E(r).orientation,style:{"--reka-accordion-content-width":`var(--reka-collapsible-content-width)`,"--reka-accordion-content-height":`var(--reka-collapsible-content-height)`},onContentFound:t[0]||=e=>E(r).changeModelValue(E(i).value.value)},{default:d(()=>[k(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`force-mount`,`aria-labelledby`,`data-state`,`data-disabled`,`data-orientation`]))}}),he=C({__name:`AccordionHeader`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`h3`}},setup(e){let n=e,r=Z(),i=$();return t(),(e,t)=>(A(),M(E(c),{as:n.as,"as-child":n.asChild,"data-orientation":E(r).orientation,"data-state":E(i).dataState.value,"data-disabled":E(i).dataDisabled.value},{default:d(()=>[k(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`data-orientation`,`data-state`,`data-disabled`]))}}),ge=C({__name:`AccordionTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=Z(),r=$();r.triggerId||=a(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)=>(A(),M(E(ae),{id:E(r).triggerId,ref:E(r).currentRef,"data-reka-collection-item":``,as:t.as,"as-child":t.asChild,"aria-disabled":E(r).disabled.value||void 0,"aria-expanded":E(r).open.value||!1,"data-disabled":E(r).dataDisabled.value,"data-orientation":E(n).orientation,"data-state":E(r).dataState.value,disabled:E(r).disabled.value,onClick:i},{default:d(()=>[k(e.$slots,`default`)]),_:3},8,[`id`,`as`,`as-child`,`aria-disabled`,`aria-expanded`,`data-disabled`,`data-orientation`,`data-state`,`disabled`]))}}),_e=C({__name:`ModelChip`,props:{id:{},contextTokens:{},inputPerMTokUsd:{},outputPerMTokUsd:{}},setup(e){let t=e,n=u(`label`),r=j(`idle`),i,a=S();function o(){clearTimeout(i),i=setTimeout(()=>{r.value=`idle`},1500)}async function s(){let e=await z(t.id,n.value??void 0);r.value=e,e===`failed`&&a.push({kind:`error`,message:`Could not copy ${t.id}.`}),o()}let c={idle:ne,copied:b,selected:b,failed:re},l=O(()=>({idle:`Copy ${t.id}`,copied:`Copied`,selected:`Selected — press Ctrl/Cmd+C`,failed:`Copy failed`})),f=O(()=>{let e=[];return t.inputPerMTokUsd!==void 0&&t.outputPerMTokUsd!==void 0&&e.push(V(t.inputPerMTokUsd,t.outputPerMTokUsd)),t.contextTokens!==void 0&&e.push(`${B(t.contextTokens)} context`),e.join(` · `)}),p=O(()=>{let e=l.value[r.value];return f.value?`${e} · ${f.value}`:e});return te(()=>{clearTimeout(i)}),(t,n)=>{let i=F(`FontAwesomeIcon`);return A(),M(E(H),{as:`button`,type:`button`,variant:`secondary`,class:I([`max-w-full cursor-pointer gap-1 truncate font-mono text-xs font-normal transition-colors hover:bg-accent hover:text-accent-foreground`,r.value===`failed`?`text-destructive`:``]),title:p.value,"aria-label":p.value,onClick:s},{default:d(()=>[w(`span`,{ref:`label`,class:`min-w-0 truncate select-text`},h(e.id),513),D(i,{icon:c[r.value],class:`size-2.5 shrink-0`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`class`,`title`,`aria-label`])}}}),ve=C({__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 r=e,i=t,a=_(r,`class`),o=n(a,i);return(e,t)=>(A(),M(E(de),f({"data-slot":`accordion`},E(o),{class:E(y)(`flex w-full flex-col`,r.class)}),{default:d(t=>[k(e.$slots,`default`,T(l(t)))]),_:3},16,[`class`]))}}),ye=C({__name:`AccordionContent`,props:{forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=_(t,`class`);return(e,r)=>(A(),M(E(me),f({"data-slot":`accordion-content`},E(n),{class:`data-open:animate-accordion-down data-closed:animate-accordion-up text-sm overflow-hidden`}),{default:d(()=>[w(`div`,{class:I(E(y)(`pt-0 pb-2.5 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4`,t.class))},[k(e.$slots,`default`)],2)]),_:3},16))}}),be=C({__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=_(t,`class`),i=r(n);return(e,n)=>(A(),M(E(pe),f({"data-slot":`accordion-item`},E(i),{class:E(y)(`not-last:border-b`,t.class)}),{default:d(t=>[k(e.$slots,`default`,T(l(t)))]),_:3},16,[`class`]))}}),xe=C({__name:`AccordionTrigger`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]},headerClass:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=_(t,`class`,`headerClass`);return(e,r)=>{let i=F(`FontAwesomeIcon`);return A(),M(E(he),{class:I(E(y)(`flex`,t.headerClass))},{default:d(()=>[D(E(ge),f({"data-slot":`accordion-trigger`},E(n),{class:E(y)(`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:d(()=>[k(e.$slots,`default`),k(e.$slots,`icon`,{},()=>[D(i,{icon:E(x),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden`},null,8,[`icon`]),D(i,{icon:E(o),"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},8,[`class`])}}});function Se(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 Ce(e,t,n){n?(e.manuallyExpanded.delete(t),e.manuallyCollapsed.add(t)):(e.manuallyCollapsed.delete(t),e.manuallyExpanded.add(t))}function we(e){e.manuallyCollapsed.clear()}export{be as a,_e as c,xe as i,Se as n,ye as o,Ce as r,ve as s,we as t};",
		),
	},
	"series-NIRVBXMP.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"ZnVuY3Rpb24gZShlKXtsZXQgdD0wO2ZvcihsZXQgbiBvZiBlKXQrPW47cmV0dXJuIHR9ZnVuY3Rpb24gdCh0LG4pe3JldHVybiBuPD0wP1tdOlsuLi50XS5zb3J0KCh0LG4pPT5lKG4ucG9pbnRzKS1lKHQucG9pbnRzKSkuc2xpY2UoMCxuKX1mdW5jdGlvbiBuKGUsdCl7cmV0dXJuIGUubWFwKChlLG4pPT57bGV0IHI9MDtmb3IobGV0IGUgb2YgdClyKz1lLnBvaW50c1tuXT8/MDtyZXR1cm4gTWF0aC5tYXgoMCxlLXIpfSl9ZnVuY3Rpb24gcih0KXtsZXQgbj1uZXcgTWFwO2ZvcihsZXQgZSBvZiB0KXtsZXQgdD1lLnNjb3BlLnN0YXJ0c1dpdGgoYG1vZGVsOmApP2Uuc2NvcGUuc2xpY2UoNik6ZS5zY29wZSxyPXQuaW5kZXhPZihgL2ApLGk9cj09PS0xP3Q6dC5zbGljZSgwLHIpLGE9bi5nZXQoaSk/P0FycmF5KGUucG9pbnRzLmxlbmd0aCkuZmlsbCgwKTtmb3IobGV0IHQ9MDt0PGUucG9pbnRzLmxlbmd0aDt0KyspYVt0XT0oYVt0XT8/MCkrKGUucG9pbnRzW3RdPz8wKTtuLnNldChpLGEpfXJldHVybiBBcnJheS5mcm9tKG4uZW50cmllcygpKS5tYXAoKFtlLHRdKT0+KHtzY29wZTplLHBvaW50czp0fSkpLnNvcnQoKHQsbik9PmUobi5wb2ludHMpLWUodC5wb2ludHMpKX1mdW5jdGlvbiBpKGUsdCl7cmV0dXJuIHQubWFwKCh0LG4pPT50PjA/KGVbbl0/PzApL3Q6bnVsbCl9ZXhwb3J0e3IgYXMgaSxpIGFzIG4sdCBhcyByLG4gYXMgdH07",
		),
	},
	"tabs-YlhnHpK-.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{a as e,i as t,n,r,s as i,t as a}from"./useId-B9dJumoI.js";import{Ar as o,D as s,Dn as c,Fr as l,G as u,Hn as d,Ht as f,I as p,Un as m,V as h,Vt as g,W as _,Xn as v,_n as y,bi as b,er as x,gi as S,hn as C,in as w,li as T,lr as E,nr as D,oi as O,on as k,pi as A}from"./Skeleton-B0ziB6Od.js";import{f as j,l as M}from"./index-dywS8OpT.js";var N=`rovingFocusGroup.onEntryFocus`,P={bubbles:!1,cancelable:!0},F={ArrowLeft:`prev`,ArrowUp:`prev`,ArrowRight:`next`,ArrowDown:`next`,PageUp:`first`,Home:`first`,PageDown:`last`,End:`last`};function I(e,t){return t===`rtl`?e===`ArrowLeft`?`ArrowRight`:e===`ArrowRight`?`ArrowLeft`:e:e}function L(e,t,n){let r=I(e.key,n);if(!(t===`vertical`&&[`ArrowLeft`,`ArrowRight`].includes(r))&&!(t===`horizontal`&&[`ArrowUp`,`ArrowDown`].includes(r)))return F[r]}function R(e,t=!1){let n=j();for(let r of e)if(r===n||(r.focus({preventScroll:t}),j()!==n))return}function z(e,t){return e.map((n,r)=>e[(t+r)%e.length])}var[B,V]=i(`RovingFocusGroup`),H=y({__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(t,{expose:n,emit:r}){let i=t,a=r,{loop:o,orientation:c,dir:u}=A(i),d=e(u),f=p(i,`currentTabStopId`,a,{defaultValue:i.defaultCurrentTabStopId,passive:i.currentTabStopId===void 0}),m=O(!1),h=O(!1),g=O(0),{getItems:_,CollectionSlot:v}=M({isProvider:!0});function y(e){let t=!h.value;if(e.currentTarget&&e.target===e.currentTarget&&t&&!m.value){let t=new CustomEvent(N,P);if(e.currentTarget.dispatchEvent(t),a(`entryFocus`,t),!t.defaultPrevented){let e=_().map(e=>e.ref).filter(e=>e.dataset.disabled!==``);R([e.find(e=>e.getAttribute(`data-active`)===``),e.find(e=>e.getAttribute(`data-highlighted`)===``),e.find(e=>e.id===f.value),...e].filter(Boolean),i.preventScrollOnEntryFocus)}}h.value=!1}function b(){setTimeout(()=>{h.value=!1},1)}return n({getItems:_}),V({loop:o,dir:d,orientation:c,currentTabStopId:f,onItemFocus:e=>{f.value=e},onItemShiftTab:()=>{m.value=!0},onFocusableItemAdd:()=>{g.value++},onFocusableItemRemove:()=>{g.value--}}),(e,t)=>(D(),k(S(v),null,{default:l(()=>[C(S(s),{tabindex:m.value||g.value===0?-1:0,"data-orientation":S(c),as:e.as,"as-child":e.asChild,dir:S(d),style:{outline:`none`},onMousedown:t[0]||=e=>h.value=!0,onMouseup:b,onFocus:y,onBlur:t[1]||=e=>m.value=!1},{default:l(()=>[E(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`as`,`as-child`,`dir`])]),_:3}))}}),U=y({__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=B(),r=a(),i=w(()=>t.tabStopId||r),c=w(()=>n.currentTabStopId.value===i.value),{getItems:u,CollectionItem:d}=M();v(()=>{t.focusable&&n.onFocusableItemAdd()}),x(()=>{t.focusable&&n.onFocusableItemRemove()}),o(()=>t.focusable,(e,t)=>{e!==t&&(e?n.onFocusableItemAdd():n.onFocusableItemRemove())});function f(e){if(e.key===`Tab`&&e.shiftKey){n.onItemShiftTab();return}if(e.target!==e.currentTarget)return;let r=L(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=[...u().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?z(i,t+1):i.slice(t+1)}m(()=>R(i))}}return(e,t)=>(D(),k(S(d),null,{default:l(()=>[C(S(s),{tabindex:c.value?0:-1,"data-orientation":S(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?S(n).onItemFocus(i.value):t.preventDefault()},onFocus:t[1]||=e=>S(n).onItemFocus(i.value),onKeydown:f},{default:l(()=>[E(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`data-active`,`data-disabled`,`as`,`as-child`])]),_:3}))}}),[W,G]=i(`TabsRoot`),K=y({__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(n,{emit:r}){let i=n,o=r,{orientation:c,unmountOnHide:u,dir:d}=A(i),f=e(d);t();let m=p(i,`modelValue`,o,{defaultValue:i.defaultValue,passive:i.modelValue===void 0}),h=O(),g=T(new Set);return G({modelValue:m,changeModelValue:e=>{m.value=e},orientation:c,dir:f,unmountOnHide:u,activationMode:i.activationMode,baseId:a(void 0,`reka-tabs`),tabsList:h,contentIds:g,registerContent:e=>{g.value=new Set([...g.value,e])},unregisterContent:e=>{let t=new Set(g.value);t.delete(e),g.value=t}}),(e,t)=>(D(),k(S(s),{dir:S(f),"data-orientation":S(c),"as-child":e.asChild,as:e.as},{default:l(()=>[E(e.$slots,`default`,{modelValue:S(m)})]),_:3},8,[`dir`,`data-orientation`,`as-child`,`as`]))}});function q(e,t){return`${e}-trigger-${t}`}function J(e,t){return`${e}-content-${t}`}var Y=y({__name:`TabsList`,props:{loop:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let{loop:n}=A(e),{forwardRef:r,currentElement:i}=t(),a=W();return a.tabsList=i,(e,t)=>(D(),k(S(H),{"as-child":``,orientation:S(a).orientation.value,dir:S(a).dir.value,loop:S(n)},{default:l(()=>[C(S(s),{ref:S(r),role:`tablist`,"as-child":e.asChild,as:e.as,"aria-orientation":S(a).orientation.value},{default:l(()=>[E(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`aria-orientation`])]),_:3},8,[`orientation`,`dir`,`loop`]))}}),X=y({__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 n=e,{forwardRef:r}=t(),i=W(),a=w(()=>q(i.baseId,n.value)),o=w(()=>i.contentIds.value.has(n.value)?J(i.baseId,n.value):void 0),c=w(()=>n.value===i.modelValue.value);return(e,t)=>(D(),k(S(U),{"as-child":``,focusable:!e.disabled,active:c.value},{default:l(()=>[C(S(s),{id:a.value,ref:S(r),role:`tab`,type:e.as===`button`?`button`:void 0,as:e.as,"as-child":e.asChild,"aria-selected":c.value?`true`:`false`,"aria-controls":o.value,"data-state":c.value?`active`:`inactive`,disabled:e.disabled,"data-disabled":e.disabled?``:void 0,"data-orientation":S(i).orientation.value,onMousedown:t[0]||=f(t=>{!e.disabled&&t.ctrlKey===!1?S(i).changeModelValue(e.value):t.preventDefault()},[`left`]),onKeydown:t[1]||=g(t=>S(i).changeModelValue(e.value),[`enter`,`space`]),onFocus:t[2]||=()=>{let t=S(i).activationMode!==`manual`;!c.value&&!e.disabled&&t&&S(i).changeModelValue(e.value)}},{default:l(()=>[E(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`]))}}),Z=y({__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 r=e,i=t,a=h(r,`class`),o=n(a,i);return(e,t)=>(D(),k(S(K),d({"data-slot":`tabs`,"data-orientation":S(o).orientation||`horizontal`},S(o),{class:S(_)(`gap-2 group/tabs flex data-horizontal:flex-col`,r.class)}),{default:l(t=>[E(e.$slots,`default`,b(c(t)))]),_:3},16,[`data-orientation`,`class`]))}}),Q=y({__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=h(t,`class`,`variant`);return(r,i)=>(D(),k(S(Y),d({"data-slot":`tabs-list`,"data-variant":e.variant},S(n),{class:S(_)(S(ee)({variant:e.variant}),t.class)}),{default:l(()=>[E(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),$=y({__name:`TabsTrigger`,props:{value:{},disabled:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=h(t,`class`),i=r(n);return(e,n)=>(D(),k(S(X),d({"data-slot":`tabs-trigger`,class:S(_)(`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-horizontal/tabs:flex-none 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)},S(i)),{default:l(()=>[E(e.$slots,`default`)]),_:3},16,[`class`]))}}),ee=u(`rounded-lg p-0.75 group-data-horizontal/tabs:h-8 group-data-horizontal/tabs:max-w-full group-data-horizontal/tabs:justify-start group-data-horizontal/tabs:overflow-x-auto group-data-horizontal/tabs:overflow-y-hidden 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`}});export{Q as n,Z as r,$ as t};",
		),
	},
	"useId-B9dJumoI.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"import{$n as e,$r as t,$t as n,An as r,Ar as i,At as a,Bn as o,Br as ee,Bt as s,Ci as c,Cn as te,Cr as ne,Ct as re,Dn as ie,Dr as ae,Dt as oe,En as se,Er as ce,Et as le,Fn as ue,Fr as de,Ft as fe,Gn as pe,Gr as me,Gt as l,Hn as u,Hr as d,Ht as f,In as p,Ir as m,It as h,Jn as g,Jr as _,Jt as v,Kn as y,Kr as b,Kt as x,Ln as S,Lr as C,Lt as w,M as T,Mn as E,Mr as D,Mt as O,Nn as k,Nr as A,Nt as j,On as M,Or as N,Ot as P,Pn as F,Pr as I,Pt as L,Qn as R,Qr as z,Qt as he,Rn as ge,Rr as _e,Rt as ve,Si as ye,Sn as be,Sr as B,St as xe,Tn as V,Tr as Se,Tt as Ce,Un as we,Ur as Te,Ut as Ee,Vn as De,Vr as Oe,Vt as ke,Wn as Ae,Wr as je,Wt as Me,Xn as Ne,Xr as Pe,Xt as Fe,Yn as Ie,Yr as Le,Yt as Re,Zn as ze,Zr as Be,Zt as Ve,_i as H,_n as He,_r as Ue,ai as We,an as Ge,ar as Ke,bi as qe,bn as Je,br as Ye,bt as Xe,ci as Ze,cn as Qe,cr as U,di as $e,dn as et,dr as tt,ei as nt,en as rt,er as it,fi as W,fn as at,fr as ot,gi as st,gn as ct,gr as lt,hi as G,hn as ut,hr as dt,ii as ft,in as K,ir as q,jn as pt,jr as mt,jt as ht,kn as gt,kr as _t,kt as vt,li as yt,ln as bt,lr as xt,mi as St,mn as Ct,mr as wt,ni as Tt,nn as Et,nr as Dt,oi as J,on as Ot,or as kt,pi as At,pn as jt,pr as Mt,qn as Nt,qr as Pt,qt as Ft,ri as It,rn as Lt,rr as Rt,si as zt,sn as Bt,sr as Vt,ti as Ht,tn as Ut,tr as Y,ui as Wt,un as Gt,ur as Kt,vi as qt,vn as Jt,vr as Yt,wn as Xt,wr as Zt,wt as Qt,xi as $t,xn as en,xr as tn,xt as nn,yi as rn,yn as an,yr as on,yt as sn,zn as cn,zr as ln,zt as un}from"./Skeleton-B0ziB6Od.js";var X=Object.defineProperty,dn=((e,t)=>{let n={};for(var r in e)X(n,r,{get:e[r],enumerable:!0});return t||X(n,Symbol.toStringTag,{value:`Module`}),n})({BaseTransition:()=>Ee,BaseTransitionPropsValidators:()=>Me,Comment:()=>l,DeprecationTypes:()=>null,EffectScope:()=>ee,ErrorCodes:()=>x,ErrorTypeStrings:()=>Ft,Fragment:()=>v,KeepAlive:()=>Re,ReactiveEffect:()=>Oe,Static:()=>Fe,Suspense:()=>Ve,Teleport:()=>he,Text:()=>n,TrackOpTypes:()=>d,Transition:()=>sn,TransitionGroup:()=>Xe,TriggerOpTypes:()=>Te,VueElement:()=>nn,assertNumber:()=>rt,callWithAsyncErrorHandling:()=>Ut,callWithErrorHandling:()=>Et,camelize:()=>H,capitalize:()=>qt,cloneVNode:()=>Lt,compatUtils:()=>null,compile:()=>fn,computed:()=>K,createApp:()=>xe,createBlock:()=>Ot,createCommentVNode:()=>Bt,createElementBlock:()=>Qe,createElementVNode:()=>Ge,createHydrationRenderer:()=>bt,createPropsRestProxy:()=>Gt,createRenderer:()=>et,createSSRApp:()=>re,createSlots:()=>at,createStaticVNode:()=>jt,createTextVNode:()=>Ct,createVNode:()=>ut,customRef:()=>je,defineAsyncComponent:()=>ct,defineComponent:()=>He,defineCustomElement:()=>Qt,defineEmits:()=>Jt,defineExpose:()=>an,defineModel:()=>Je,defineOptions:()=>en,defineProps:()=>be,defineSSRCustomElement:()=>Ce,defineSlots:()=>te,devtools:()=>Xt,effect:()=>me,effectScope:()=>b,getCurrentInstance:()=>V,getCurrentScope:()=>Pt,getCurrentWatcher:()=>_,getTransitionRawChildren:()=>se,guardReactiveProps:()=>ie,h:()=>M,handleError:()=>gt,hasInjectionContext:()=>r,hydrate:()=>le,hydrateOnIdle:()=>pt,hydrateOnInteraction:()=>E,hydrateOnMediaQuery:()=>k,hydrateOnVisible:()=>F,initCustomFormatter:()=>ue,initDirectivesForSSR:()=>oe,inject:()=>p,isMemoSame:()=>S,isProxy:()=>Le,isReactive:()=>Pe,isReadonly:()=>Be,isRef:()=>z,isRuntimeOnly:()=>ge,isShallow:()=>t,isVNode:()=>cn,markRaw:()=>nt,mergeDefaults:()=>o,mergeModels:()=>De,mergeProps:()=>u,nextTick:()=>we,nodeOps:()=>P,normalizeClass:()=>rn,normalizeProps:()=>qe,normalizeStyle:()=>$t,onActivated:()=>Ae,onBeforeMount:()=>pe,onBeforeUnmount:()=>y,onBeforeUpdate:()=>Nt,onDeactivated:()=>g,onErrorCaptured:()=>Ie,onMounted:()=>Ne,onRenderTracked:()=>ze,onRenderTriggered:()=>R,onScopeDispose:()=>Ht,onServerPrefetch:()=>e,onUnmounted:()=>it,onUpdated:()=>Y,onWatcherCleanup:()=>Tt,openBlock:()=>Dt,patchProp:()=>vt,popScopeId:()=>Rt,provide:()=>q,proxyRefs:()=>It,pushScopeId:()=>Ke,queuePostFlushCb:()=>kt,reactive:()=>ft,readonly:()=>We,ref:()=>J,registerRuntimeCompiler:()=>Vt,render:()=>a,renderList:()=>U,renderSlot:()=>xt,resolveComponent:()=>Kt,resolveDirective:()=>tt,resolveDynamicComponent:()=>ot,resolveFilter:()=>null,resolveTransitionHooks:()=>Mt,setBlockTracking:()=>wt,setDevtoolsHook:()=>dt,setTransitionHooks:()=>lt,shallowReactive:()=>zt,shallowReadonly:()=>Ze,shallowRef:()=>yt,ssrContextKey:()=>Ue,ssrUtils:()=>Yt,stop:()=>Wt,toDisplayString:()=>ye,toHandlerKey:()=>c,toHandlers:()=>on,toRaw:()=>$e,toRef:()=>W,toRefs:()=>At,toValue:()=>St,transformVNodeArgs:()=>Ye,triggerRef:()=>G,unref:()=>st,useAttrs:()=>tn,useCssModule:()=>ht,useCssVars:()=>O,useHost:()=>j,useId:()=>B,useModel:()=>ne,useSSRContext:()=>Zt,useShadowRoot:()=>L,useSlots:()=>Se,useTemplateRef:()=>ce,useTransitionState:()=>ae,vModelCheckbox:()=>fe,vModelDynamic:()=>h,vModelRadio:()=>w,vModelSelect:()=>ve,vModelText:()=>un,vShow:()=>s,version:()=>N,warn:()=>_t,watch:()=>i,watchEffect:()=>mt,watchPostEffect:()=>D,watchSyncEffect:()=>A,withAsyncContext:()=>I,withCtx:()=>de,withDefaults:()=>m,withDirectives:()=>C,withKeys:()=>ke,withMemo:()=>_e,withModifiers:()=>f,withScopeId:()=>ln}),fn=()=>{};function Z(e,t){let n=typeof e==`string`&&!t?`${e}Context`:t,r=Symbol(n);return[t=>{let n=p(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=>(q(r,e),e)]}var[Q,pn]=Z(`ConfigProvider`);function mn(e){let t=Q({dir:J(`ltr`)});return K(()=>e?.value||t.dir?.value||`ltr`)}function hn(e){let t=V(),n=t?.type.emits,r={};return n?.length||console.warn(`No emitted event found. Please check component: ${t?.type.__name}`),n?.forEach(t=>{r[c(H(t))]=(...n)=>e(t,...n)}),r}function gn(){let e=V(),t=J(),n=K(()=>r());Y(()=>{n.value!==r()&&G(t)});function r(){return t.value&&`$el`in t.value&&[`#text`,`#comment`].includes(t.value.$el.nodeName)?t.value.$el.nextElementSibling:T(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 $(e){let t=V(),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=W(e);return K(()=>{let e={},i=t?.vnode.props??{};return Object.keys(i).forEach(t=>{e[H(t)]=i[t]}),Object.keys({...n,...e}).reduce((e,t)=>(r.value[t]!==void 0&&(e[t]=r.value[t]),e),{})})}function _n(e,t){let n=$(e),r=t?hn(t):{};return K(()=>({...n.value,...r}))}var vn=0;function yn(e,t=`reka`){if(e)return e;let n,r=Q({useId:void 0});return n=r.useId?r.useId():`useId`in dn?B?.():`${++vn}`,t?`${t}-${n}`:n}export{mn as a,gn as i,_n as n,Q as o,$ as r,Z as s,yn as t};",
		),
	},
	"useSearchQuery-bQZP4TsZ.js": {
		contentType: "text/javascript; charset=utf-8",
		body: decodeAdminAsset(
			"aW1wb3J0e0UgYXMgZSxGciBhcyB0LFcgYXMgbixfbiBhcyByLGNuIGFzIGksZ2kgYXMgYSxobiBhcyBvLGh0IGFzIHMsaW4gYXMgYyxuciBhcyBsLG9pIGFzIHUsb24gYXMgZCxzbiBhcyBmLHVyIGFzIHAsdXQgYXMgbSx5aSBhcyBofWZyb20iLi9Ta2VsZXRvbi1CMHppQjZPZC5qcyI7aW1wb3J0e3MgYXMgZ31mcm9tIi4vaW5kZXgtZHl3UzhPcFQuanMiO3ZhciBfPXIoe19fbmFtZTpgU2VhcmNoSW5wdXRgLHByb3BzOnttb2RlbFZhbHVlOnt9LHBsYWNlaG9sZGVyOnt9LGNsYXNzOnt0eXBlOltCb29sZWFuLG51bGwsU3RyaW5nLE9iamVjdCxBcnJheV19fSxlbWl0czpbYHVwZGF0ZTptb2RlbFZhbHVlYF0sc2V0dXAocix7ZW1pdDp1fSl7bGV0IF89cix2PXUseT1jKCgpPT5fLm1vZGVsVmFsdWUubGVuZ3RoPjApO2Z1bmN0aW9uIGIoZSl7dihgdXBkYXRlOm1vZGVsVmFsdWVgLFN0cmluZyhlKSl9ZnVuY3Rpb24geCgpe3YoYHVwZGF0ZTptb2RlbFZhbHVlYCxgYCl9cmV0dXJuKGMsdSk9PntsZXQgdj1wKGBGb250QXdlc29tZUljb25gKTtyZXR1cm4gbCgpLGkoYGRpdmAse2NsYXNzOmgoYShuKShgcmVsYXRpdmVgLF8uY2xhc3MpKX0sW28odix7aWNvbjphKG0pLGNsYXNzOmBwb2ludGVyLWV2ZW50cy1ub25lIGFic29sdXRlIHRvcC0xLzIgbGVmdC0yLjUgc2l6ZS0zLjUgLXRyYW5zbGF0ZS15LTEvMiB0ZXh0LW11dGVkLWZvcmVncm91bmRgLCJhcmlhLWhpZGRlbiI6YHRydWVgfSxudWxsLDgsW2BpY29uYF0pLG8oYShnKSx7Im1vZGVsLXZhbHVlIjpyLm1vZGVsVmFsdWUsdHlwZTpgdGV4dGAscGxhY2Vob2xkZXI6ci5wbGFjZWhvbGRlciwiYXJpYS1sYWJlbCI6ci5wbGFjZWhvbGRlcixjbGFzczpgcHItOCBwbC04YCwib25VcGRhdGU6bW9kZWxWYWx1ZSI6Yn0sbnVsbCw4LFtgbW9kZWwtdmFsdWVgLGBwbGFjZWhvbGRlcmAsYGFyaWEtbGFiZWxgXSkseS52YWx1ZT8obCgpLGQoYShlKSx7a2V5OjAsdHlwZTpgYnV0dG9uYCx2YXJpYW50OmBnaG9zdGAsc2l6ZTpgaWNvbi14c2AsImFyaWEtbGFiZWwiOmBDbGVhciBzZWFyY2hgLGNsYXNzOmBhYnNvbHV0ZSB0b3AtMS8yIHJpZ2h0LTEgLXRyYW5zbGF0ZS15LTEvMiB0ZXh0LW11dGVkLWZvcmVncm91bmQgaG92ZXI6dGV4dC1mb3JlZ3JvdW5kYCxvbkNsaWNrOnh9LHtkZWZhdWx0OnQoKCk9PltvKHYse2ljb246YShzKSxjbGFzczpgc2l6ZS0zLjVgLCJhcmlhLWhpZGRlbiI6YHRydWVgfSxudWxsLDgsW2BpY29uYF0pXSksXzoxfSkpOmYoYGAsITApXSwyKX19fSk7ZnVuY3Rpb24gdihlKXtsZXQgdD1lPz91KGBgKSxuPWMoKCk9PnQudmFsdWUudHJpbSgpLnRvTG93ZXJDYXNlKCkpO3JldHVybntxdWVyeTp0LG5vcm1hbGl6ZWQ6bixoYXNRdWVyeTpjKCgpPT5uLnZhbHVlLmxlbmd0aD4wKX19ZXhwb3J0e18gYXMgbix2IGFzIHR9Ow==",
		),
	},
}