diff --git a/admin_assets_gen.go b/admin_assets_gen.go
index f750758..b8530ac 100644
--- a/admin_assets_gen.go
+++ b/admin_assets_gen.go
@@ -1,6 +1,6 @@
 // Code generated by webui/generate.mjs; DO NOT EDIT.
 //
-// Source: webui/dist/ (vite build output), digest 0a8b56f9a958a1a3.
+// Source: webui/dist/ (vite build output), digest 416a7df5cafd2da6.
 // Regenerate via `make admin-ui` after any webui/ source change.
 //
 // Every asset body below is base64-encoded and decoded once at package-var
@@ -34,28 +34,202 @@ func decodeAdminAsset(encoded string) []byte {
 // adminIndexHTML is GET /admin's response body (admin.go's serveAdminPage) —
 // the built Vue app's HTML shell.
 var adminIndexHTML = decodeAdminAsset(
-	"PCFkb2N0eXBlIGh0bWw+CjxodG1sIGxhbmc9ImVuIj4KICA8aGVhZD4KICAgIDxtZXRhIGNoYXJzZXQ9IlVURi04IiAvPgogICAgPCEtLSBJbmxpbmUgZGF0YTogVVJJLCBub3QgYSBmaWxlIHVuZGVyIHB1YmxpYy86IGFkbWluLmdvJ3MgYXNzZXQgbWFwIG9ubHkKICAgICAgICAgZXZlciBob2xkcyBjb250ZW50LWhhc2hlZCBmaWxlcyB1bmRlciAvYWRtaW4vYXNzZXRzLyosIGFuZCB0aGUgYWRtaW4KICAgICAgICAgQ1NQJ3MgaW1nLXNyYyBhbGxvd3MgJ3NlbGYnIHBsdXMgZGF0YTogZm9yIGV4YWN0bHkgdGhpcyByZWFzb24g4oCUIG5vCiAgICAgICAgIGV4dHJhIHVuaGFzaGVkLWFzc2V0IHJvdXRlIGlzIG5lZWRlZCBmb3Igb25lIHNtYWxsIGljb24uIC0tPgogICAgPGxpbmsKICAgICAgcmVsPSJpY29uIgogICAgICB0eXBlPSJpbWFnZS9zdmcreG1sIgogICAgICBocmVmPSJkYXRhOmltYWdlL3N2Zyt4bWwsJTNDc3ZnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zycgdmlld0JveD0nMCAwIDI0IDI0JyUzRSUzQ3JlY3Qgd2lkdGg9JzI0JyBoZWlnaHQ9JzI0JyByeD0nNScgZmlsbD0nJTIzMDA3MmIyJy8lM0UlM0NwYXRoIGQ9J002IDE2LjUgMTAgOGwzIDYgMi0zLjUgMyA2JyBzdHJva2U9JyUyM2ZmZicgc3Ryb2tlLXdpZHRoPScyJyBmaWxsPSdub25lJyBzdHJva2UtbGluZWNhcD0ncm91bmQnIHN0cm9rZS1saW5lam9pbj0ncm91bmQnLyUzRSUzQy9zdmclM0UiCiAgICAvPgogICAgPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwgaW5pdGlhbC1zY2FsZT0xLjAiIC8+CiAgICA8dGl0bGU+TExNIEdhdGV3YXkgLSBBZG1pbjwvdGl0bGU+CiAgICA8c2NyaXB0IHR5cGU9Im1vZHVsZSIgY3Jvc3NvcmlnaW4gc3JjPSIvYWRtaW4vYXNzZXRzL2luZGV4LTJoUkxob0tMLmpzIj48L3NjcmlwdD4KICAgIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgY3Jvc3NvcmlnaW4gaHJlZj0iL2FkbWluL2Fzc2V0cy9pbmRleC1CU3NlZmk0aC5jc3MiPgogIDwvaGVhZD4KICA8Ym9keT4KICAgIDxkaXYgaWQ9ImFwcCI+PC9kaXY+CiAgPC9ib2R5Pgo8L2h0bWw+Cg==",
+	"PCFkb2N0eXBlIGh0bWw+CjxodG1sIGxhbmc9ImVuIj4KICA8aGVhZD4KICAgIDxtZXRhIGNoYXJzZXQ9IlVURi04IiAvPgogICAgPCEtLSBJbmxpbmUgZGF0YTogVVJJLCBub3QgYSBmaWxlIHVuZGVyIHB1YmxpYy86IGFkbWluLmdvJ3MgYXNzZXQgbWFwIG9ubHkKICAgICAgICAgZXZlciBob2xkcyBjb250ZW50LWhhc2hlZCBmaWxlcyB1bmRlciAvYWRtaW4vYXNzZXRzLyosIGFuZCB0aGUgYWRtaW4KICAgICAgICAgQ1NQJ3MgaW1nLXNyYyBhbGxvd3MgJ3NlbGYnIHBsdXMgZGF0YTogZm9yIGV4YWN0bHkgdGhpcyByZWFzb24g4oCUIG5vCiAgICAgICAgIGV4dHJhIHVuaGFzaGVkLWFzc2V0IHJvdXRlIGlzIG5lZWRlZCBmb3Igb25lIHNtYWxsIGljb24uIC0tPgogICAgPGxpbmsKICAgICAgcmVsPSJpY29uIgogICAgICB0eXBlPSJpbWFnZS9zdmcreG1sIgogICAgICBocmVmPSJkYXRhOmltYWdlL3N2Zyt4bWwsJTNDc3ZnIHhtbG5zPSdodHRwOi8vd3d3LnczLm9yZy8yMDAwL3N2Zycgdmlld0JveD0nMCAwIDI0IDI0JyUzRSUzQ3JlY3Qgd2lkdGg9JzI0JyBoZWlnaHQ9JzI0JyByeD0nNScgZmlsbD0nJTIzMDA3MmIyJy8lM0UlM0NwYXRoIGQ9J002IDE2LjUgMTAgOGwzIDYgMi0zLjUgMyA2JyBzdHJva2U9JyUyM2ZmZicgc3Ryb2tlLXdpZHRoPScyJyBmaWxsPSdub25lJyBzdHJva2UtbGluZWNhcD0ncm91bmQnIHN0cm9rZS1saW5lam9pbj0ncm91bmQnLyUzRSUzQy9zdmclM0UiCiAgICAvPgogICAgPG1ldGEgbmFtZT0idmlld3BvcnQiIGNvbnRlbnQ9IndpZHRoPWRldmljZS13aWR0aCwgaW5pdGlhbC1zY2FsZT0xLjAiIC8+CiAgICA8dGl0bGU+TExNIEdhdGV3YXkgLSBBZG1pbjwvdGl0bGU+CiAgICA8c2NyaXB0IHR5cGU9Im1vZHVsZSIgY3Jvc3NvcmlnaW4gc3JjPSIvYWRtaW4vYXNzZXRzL2luZGV4LUJpVFFfZ0NFLmpzIj48L3NjcmlwdD4KICAgIDxsaW5rIHJlbD0ibW9kdWxlcHJlbG9hZCIgY3Jvc3NvcmlnaW4gaHJlZj0iL2FkbWluL2Fzc2V0cy9uYXYtRHpiME9UTl8uanMiPgogICAgPGxpbmsgcmVsPSJtb2R1bGVwcmVsb2FkIiBjcm9zc29yaWdpbiBocmVmPSIvYWRtaW4vYXNzZXRzL0NhcmREZXNjcmlwdGlvbi1JZE90MzE3Yy5qcyI+CiAgICA8bGluayByZWw9Im1vZHVsZXByZWxvYWQiIGNyb3Nzb3JpZ2luIGhyZWY9Ii9hZG1pbi9hc3NldHMvUHJlc2VuY2UtQ3VRVUdGeVMuanMiPgogICAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBjcm9zc29yaWdpbiBocmVmPSIvYWRtaW4vYXNzZXRzL2luZGV4LURZWF9xaXFSLmNzcyI+CiAgPC9oZWFkPgogIDxib2R5PgogICAgPGRpdiBpZD0iYXBwIj48L2Rpdj4KICA8L2JvZHk+CjwvaHRtbD4K",
 )
 
 // adminAssets maps each hashed filename under /admin/assets/ (admin.go's
 // serveAdminAsset) to its content.
 var adminAssets = map[string]adminAsset{
-	"ChartsView-L9LBTr3e.js": {
+	"CardDescription-IdOt317c.js": {
 		contentType: "text/javascript; charset=utf-8",
 		body: decodeAdminAsset(
-			"import{$ as e,A as t,B as n,C as r,D as i,E as a,F as o,G as s,H as c,I as l,J as u,K as d,L as f,M as p,N as m,O as h,P as g,R as _,S as v,T as y,U as b,V as x,W as S,X as C,Y as w,Z as T,_ as E,a as D,at as O,b as ee,c as te,ct as ne,d as re,et as k,f as ie,g as ae,h as oe,i as se,it as ce,j as le,k as ue,l as de,m as fe,n as pe,nt as me,o as he,ot as A,p as ge,q as _e,r as ve,rt as ye,s as be,st as xe,t as Se,tt as Ce,u as we,v as Te,w as Ee,x as De,y as Oe,z as ke}from"./index-2hRLhoKL.js";function Ae(e){return e+.5|0}var je=(e,t,n)=>Math.max(Math.min(e,n),t);function Me(e){return je(Ae(e*2.55),0,255)}function Ne(e){return je(Ae(e*255),0,255)}function Pe(e){return je(Ae(e/2.55)/100,0,1)}function Fe(e){return je(Ae(e*100),0,100)}var j={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},Ie=[...`0123456789ABCDEF`],Le=e=>Ie[e&15],Re=e=>Ie[(e&240)>>4]+Ie[e&15],ze=e=>(e&240)>>4==(e&15),Be=e=>ze(e.r)&&ze(e.g)&&ze(e.b)&&ze(e.a);function Ve(e){var t=e.length,n;return e[0]===`#`&&(t===4||t===5?n={r:255&j[e[1]]*17,g:255&j[e[2]]*17,b:255&j[e[3]]*17,a:t===5?j[e[4]]*17:255}:(t===7||t===9)&&(n={r:j[e[1]]<<4|j[e[2]],g:j[e[3]]<<4|j[e[4]],b:j[e[5]]<<4|j[e[6]],a:t===9?j[e[7]]<<4|j[e[8]]:255})),n}var He=(e,t)=>e<255?t(e):``;function Ue(e){var t=Be(e)?Le:Re;return e?`#`+t(e.r)+t(e.g)+t(e.b)+He(e.a,t):void 0}var We=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function Ge(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 Ke(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 qe(e,t,n){let r=Ge(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 Je(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 Ye(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=Je(t,n,r,l,i),s=s*60+.5),[s|0,c||0,o]}function Xe(e,t,n,r){return(Array.isArray(t)?e(t[0],t[1],t[2]):e(t,n,r)).map(Ne)}function Ze(e,t,n){return Xe(Ge,e,t,n)}function Qe(e,t,n){return Xe(qe,e,t,n)}function $e(e,t,n){return Xe(Ke,e,t,n)}function et(e){return(e%360+360)%360}function tt(e){let t=We.exec(e),n=255,r;if(!t)return;t[5]!==r&&(n=t[6]?Me(+t[5]):Ne(+t[5]));let i=et(+t[2]),a=t[3]/100,o=t[4]/100;return r=t[1]===`hwb`?Qe(i,a,o):t[1]===`hsv`?$e(i,a,o):Ze(i,a,o),{r:r[0],g:r[1],b:r[2],a:n}}function nt(e,t){var n=Ye(e);n[0]=et(n[0]+t),n=Ze(n),e.r=n[0],e.g=n[1],e.b=n[2]}function rt(e){if(!e)return;let t=Ye(e),n=t[0],r=Fe(t[1]),i=Fe(t[2]);return e.a<255?`hsla(${n}, ${r}%, ${i}%, ${Pe(e.a)})`:`hsl(${n}, ${r}%, ${i}%)`}var it={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`},at={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 ot(){let e={},t=Object.keys(at),n=Object.keys(it),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,it[a]);a=parseInt(at[o],16),e[s]=[a>>16&255,a>>8&255,a&255]}return e}var st;function ct(e){st||(st=ot(),st.transparent=[0,0,0,0]);let t=st[e.toLowerCase()];return t&&{r:t[0],g:t[1],b:t[2],a:t.length===4?t[3]:255}}var lt=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;function ut(e){let t=lt.exec(e),n=255,r,i,a;if(t){if(t[7]!==r){let e=+t[7];n=t[8]?Me(e):je(e*255,0,255)}return r=+t[1],i=+t[3],a=+t[5],r=255&(t[2]?Me(r):je(r,0,255)),i=255&(t[4]?Me(i):je(i,0,255)),a=255&(t[6]?Me(a):je(a,0,255)),{r,g:i,b:a,a:n}}}function dt(e){return e&&(e.a<255?`rgba(${e.r}, ${e.g}, ${e.b}, ${Pe(e.a)})`:`rgb(${e.r}, ${e.g}, ${e.b})`)}var ft=e=>e<=.0031308?e*12.92:e**(1/2.4)*1.055-.055,pt=e=>e<=.04045?e/12.92:((e+.055)/1.055)**2.4;function mt(e,t,n){let r=pt(Pe(e.r)),i=pt(Pe(e.g)),a=pt(Pe(e.b));return{r:Ne(ft(r+n*(pt(Pe(t.r))-r))),g:Ne(ft(i+n*(pt(Pe(t.g))-i))),b:Ne(ft(a+n*(pt(Pe(t.b))-a))),a:e.a+n*(t.a-e.a)}}function ht(e,t,n){if(e){let r=Ye(e);r[t]=Math.max(0,Math.min(r[t]+r[t]*n,t===0?360:1)),r=Ze(r),e.r=r[0],e.g=r[1],e.b=r[2]}}function gt(e,t){return e&&Object.assign(t||{},e)}function _t(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=Ne(e[3]))):(t=gt(e,{r:0,g:0,b:0,a:1}),t.a=Ne(t.a)),t}function vt(e){return e.charAt(0)===`r`?ut(e):tt(e)}var yt=class e{constructor(t){if(t instanceof e)return t;let n=typeof t,r;n===`object`?r=_t(t):n===`string`&&(r=Ve(t)||ct(t)||vt(t)),this._rgb=r,this._valid=!!r}get valid(){return this._valid}get rgb(){var e=gt(this._rgb);return e&&(e.a=Pe(e.a)),e}set rgb(e){this._rgb=_t(e)}rgbString(){return this._valid?dt(this._rgb):void 0}hexString(){return this._valid?Ue(this._rgb):void 0}hslString(){return this._valid?rt(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=mt(this._rgb,e._rgb,t)),this}clone(){return new e(this.rgb)}alpha(e){return this._rgb.a=Ne(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=Ae(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 ht(this._rgb,2,e),this}darken(e){return ht(this._rgb,2,-e),this}saturate(e){return ht(this._rgb,1,e),this}desaturate(e){return ht(this._rgb,1,-e),this}rotate(e){return nt(this._rgb,e),this}};function M(){}var bt=(()=>{let e=0;return()=>e++})();function N(e){return e==null}function P(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 F(e){return e!==null&&Object.prototype.toString.call(e)===`[object Object]`}function I(e){return(typeof e==`number`||e instanceof Number)&&isFinite(+e)}function L(e,t){return I(e)?e:t}function R(e,t){return e===void 0?t:e}var xt=(e,t)=>typeof e==`string`&&e.endsWith(`%`)?parseFloat(e)/100*t:+e;function z(e,t,n){if(e&&typeof e.call==`function`)return e.apply(n,t)}function B(e,t,n,r){let i,a,o;if(P(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(F(e))for(o=Object.keys(e),a=o.length,i=0;i<a;i++)t.call(n,e[o[i]],o[i])}function St(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 Ct(e){if(P(e))return e.map(Ct);if(F(e)){let t=Object.create(null),n=Object.keys(e),r=n.length,i=0;for(;i<r;++i)t[n[i]]=Ct(e[n[i]]);return t}return e}function wt(e){return[`__proto__`,`prototype`,`constructor`].indexOf(e)===-1}function Tt(e,t,n,r){if(!wt(e))return;let i=t[e],a=n[e];F(i)&&F(a)?Et(i,a,r):t[e]=Ct(a)}function Et(e,t,n){let r=P(t)?t:[t],i=r.length;if(!F(e))return e;n||={};let a=n.merger||Tt,o;for(let t=0;t<i;++t){if(o=r[t],!F(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 Dt(e,t){return Et(e,t,{merger:Ot})}function Ot(e,t,n){if(!wt(e))return;let r=t[e],i=n[e];F(r)&&F(i)?Dt(r,i):Object.prototype.hasOwnProperty.call(t,e)||(t[e]=Ct(i))}var kt={"":e=>e,x:e=>e.x,y:e=>e.y};function At(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 jt(e){let t=At(e);return e=>{for(let n of t){if(n===``)break;e&&=e[n]}return e}}function Mt(e,t){return(kt[t]||(kt[t]=jt(t)))(e)}function Nt(e){return e.charAt(0).toUpperCase()+e.slice(1)}var Pt=e=>e!==void 0,Ft=e=>typeof e==`function`,It=(e,t)=>{if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0};function Lt(e){return e.type===`mouseup`||e.type===`click`||e.type===`contextmenu`}var V=Math.PI,H=2*V;H+V;var Rt=1/0,zt=V/180,U=V/2,Bt=V/4,Vt=V*2/3,Ht=Math.log10,Ut=Math.sign;function Wt(e,t,n){return Math.abs(e-t)<n}function Gt(e){let t=Math.round(e);e=Wt(e,t,e/1e3)?t:e;let n=10**Math.floor(Ht(e)),r=e/n;return(r<=1?1:r<=2?2:r<=5?5:10)*n}function Kt(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 qt(e){return typeof e==`symbol`||typeof e==`object`&&!!e&&!(Symbol.toPrimitive in e||`toString`in e||`valueOf`in e)}function Jt(e){return!qt(e)&&!isNaN(parseFloat(e))&&isFinite(e)}function Yt(e,t){let n=Math.round(e);return n-t<=e&&n+t>=e}function Xt(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 Zt(e){return V/180*e}function Qt(e){return 180/V*e}function $t(e){if(!I(e))return;let t=1,n=0;for(;Math.round(e*t)/t!==e;)t*=10,n++;return n}function en(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*V&&(a+=H),{angle:a,distance:i}}function tn(e,t){return Math.sqrt((t.x-e.x)**2+(t.y-e.y)**2)}function W(e){return(e%H+H)%H}function nn(e,t,n,r){let i=W(e),a=W(t),o=W(n),s=W(a-i),c=W(o-i),l=W(i-a),u=W(i-o);return i===a||i===o||r&&a===o||s>c&&l<u}function G(e,t,n){return Math.max(t,Math.min(n,e))}function rn(e){return G(e,-32768,32767)}function an(e,t,n,r=1e-6){return e>=Math.min(t,n)-r&&e<=Math.max(t,n)+r}function on(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 sn=(e,t,n,r)=>on(e,n,r?r=>{let i=e[r][t];return i<n||i===n&&e[r+1][t]===n}:r=>e[r][t]<n),cn=(e,t,n)=>on(e,n,r=>e[r][t]>=n);function ln(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 un=[`push`,`pop`,`shift`,`splice`,`unshift`];function dn(e,t){if(e._chartjs){e._chartjs.listeners.push(t);return}Object.defineProperty(e,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[t]}}),un.forEach(t=>{let n=`_onData`+Nt(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 fn(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)&&(un.forEach(t=>{delete e[t]}),delete e._chartjs)}function pn(e){let t=new Set(e);return t.size===e.length?e:Array.from(t)}var mn=function(){return typeof window>`u`?function(e){return e()}:window.requestAnimationFrame}();function hn(e,t){let n=[],r=!1;return function(...i){n=i,r||(r=!0,mn.call(window,()=>{r=!1,e.apply(t,n)}))}}function gn(e,t){let n;return function(...r){return t?(clearTimeout(n),n=setTimeout(e,t,r)):e.apply(this,r),t}}var _n=e=>e===`start`?`left`:e===`end`?`right`:`center`,K=(e,t,n)=>e===`start`?t:e===`end`?n:(t+n)/2,vn=(e,t,n,r)=>e===(r?`left`:`right`)?n:e===`center`?(t+n)/2:t,yn=e=>e===0||e===1,bn=(e,t,n)=>-(2**(10*--e)*Math.sin((e-t)*H/n)),xn=(e,t,n)=>2**(-10*e)*Math.sin((e-t)*H/n)+1,Sn={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*U)+1,easeOutSine:e=>Math.sin(e*U),easeInOutSine:e=>-.5*(Math.cos(V*e)-1),easeInExpo:e=>e===0?0:2**(10*(e-1)),easeOutExpo:e=>e===1?1:-(2**(-10*e))+1,easeInOutExpo:e=>yn(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=>yn(e)?e:bn(e,.075,.3),easeOutElastic:e=>yn(e)?e:xn(e,.075,.3),easeInOutElastic(e){let t=.1125,n=.45;return yn(e)?e:e<.5?.5*bn(e*2,t,n):.5+.5*xn(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-Sn.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?Sn.easeInBounce(e*2)*.5:Sn.easeOutBounce(e*2-1)*.5+.5};function Cn(e){if(e&&typeof e==`object`){let t=e.toString();return t===`[object CanvasPattern]`||t===`[object CanvasGradient]`}return!1}function wn(e){return Cn(e)?e:new yt(e)}function Tn(e){return Cn(e)?e:new yt(e).saturate(.5).darken(.1).hexString()}var En=[`x`,`y`,`borderWidth`,`radius`,`tension`],Dn=[`color`,`borderColor`,`backgroundColor`];function On(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:Dn},numbers:{type:`number`,properties:En}}),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 kn(e){e.set(`layout`,{autoPadding:!0,padding:{top:0,right:0,bottom:0,left:0}})}var An=new Map;function jn(e,t){t||={};let n=e+JSON.stringify(t),r=An.get(n);return r||(r=new Intl.NumberFormat(e,t),An.set(n,r)),r}function Mn(e,t,n){return jn(t,n).format(e)}var Nn={values(e){return P(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=Pn(e,n)}let o=Ht(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),Mn(e,r,c)},logarithmic(e,t,n){if(e===0)return`0`;let r=n[t].significand||e/10**Math.floor(Ht(e));return[1,2,3,5,10,15].includes(r)||t>.8*n.length?Nn.numeric.call(this,e,t,n):``}};function Pn(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 Fn={formatters:Nn};function In(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:Fn.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 Ln=Object.create(null),Rn=Object.create(null);function zn(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 Bn(e,t,n){return typeof t==`string`?Et(zn(e,t),n):Et(zn(e,``),t)}var q=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)=>Tn(t.backgroundColor),this.hoverBorderColor=(e,t)=>Tn(t.borderColor),this.hoverColor=(e,t)=>Tn(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 Bn(this,e,t)}get(e){return zn(this,e)}describe(e,t){return Bn(Rn,e,t)}override(e,t){return Bn(Ln,e,t)}route(e,t,n,r){let i=zn(this,e),a=zn(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 F(e)?Object.assign({},t,e):R(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}},[On,kn,In]);function Vn(e){return!e||N(e.size)||N(e.family)?null:(e.style?e.style+` `:``)+(e.weight?e.weight+` `:``)+e.size+`px `+e.family}function Hn(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 Un(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&&!P(d))o=Hn(e,i,a,o,d);else if(P(d))for(l=0,u=d.length;l<u;l++)f=d[l],f!=null&&!P(f)&&(o=Hn(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 Wn(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 Gn(e,t){!t&&!e||(t||=e.getContext(`2d`),t.save(),t.resetTransform(),t.clearRect(0,0,e.width,e.height),t.restore())}function Kn(e,t,n,r){qn(e,t,n,r,null)}function qn(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)*zt;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,H):e.arc(n,r,h,0,H),e.closePath();break;case`triangle`:u=i?i/2:h,e.moveTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=Vt,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=Vt,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+Bt)*c,d=Math.cos(g+Bt)*(i?i/2-l:c),s=Math.sin(g+Bt)*c,f=Math.sin(g+Bt)*(i?i/2-l:c),e.arc(n-d,r-s,l,g-V,g-U),e.arc(n+f,r-o,l,g-U,g),e.arc(n+d,r+s,l,g,g+U),e.arc(n-f,r+o,l,g+U,g+V),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+=Bt;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+=Bt;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+=Bt,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 Jn(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 Yn(e,t){e.save(),e.beginPath(),e.rect(t.left,t.top,t.right-t.left,t.bottom-t.top),e.clip()}function Xn(e){e.restore()}function Zn(e,t){t.translation&&e.translate(t.translation[0],t.translation[1]),N(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 Qn(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 $n(e,t){let n=e.fillStyle;e.fillStyle=t.color,e.fillRect(t.left,t.top,t.width,t.height),e.fillStyle=n}function er(e,t,n,r,i,a={}){let o=P(t)?t:[t],s=a.strokeWidth>0&&a.strokeColor!==``,c,l;for(e.save(),e.font=i.string,Zn(e,a),c=0;c<o.length;++c)l=o[c],a.backdrop&&$n(e,a.backdrop),s&&(a.strokeColor&&(e.strokeStyle=a.strokeColor),N(a.strokeWidth)||(e.lineWidth=a.strokeWidth),e.strokeText(l,n,r,a.maxWidth)),e.fillText(l,n,r,a.maxWidth),Qn(e,n,r,l,a),r+=Number(i.lineHeight);e.restore()}function tr(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*V,V,!0),e.lineTo(n,r+a-o.bottomLeft),e.arc(n+o.bottomLeft,r+a-o.bottomLeft,o.bottomLeft,V,U,!0),e.lineTo(n+i-o.bottomRight,r+a),e.arc(n+i-o.bottomRight,r+a-o.bottomRight,o.bottomRight,U,0,!0),e.lineTo(n+i,r+o.topRight),e.arc(n+i-o.topRight,r+o.topRight,o.topRight,0,-U,!0),e.lineTo(n+o.topLeft,r)}var nr=/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/,rr=/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;function ir(e,t){let n=(``+e).match(nr);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 ar=e=>+e||0;function or(e,t){let n={},r=F(t),i=r?Object.keys(t):t,a=F(e)?r?n=>R(e[n],e[t[n]]):t=>e[t]:()=>e;for(let e of i)n[e]=ar(a(e));return n}function sr(e){return or(e,{top:`y`,right:`x`,bottom:`y`,left:`x`})}function cr(e){return or(e,[`topLeft`,`topRight`,`bottomLeft`,`bottomRight`])}function J(e){let t=sr(e);return t.width=t.left+t.right,t.height=t.top+t.bottom,t}function Y(e,t){e||={},t||=q.font;let n=R(e.size,t.size);typeof n==`string`&&(n=parseInt(n,10));let r=R(e.style,t.style);r&&!(``+r).match(rr)&&(console.warn(`Invalid font style specified: "`+r+`"`),r=void 0);let i={family:R(e.family,t.family),lineHeight:ir(R(e.lineHeight,t.lineHeight),n),size:n,style:r,weight:R(e.weight,t.weight),string:``};return i.string=Vn(i),i}function lr(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&&P(s)&&(s=s[n%s.length],i=!1),s!==void 0))return r&&!i&&(r.cacheable=!1),s}function ur(e,t,n){let{min:r,max:i}=e,a=xt(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 dr(e,t){return Object.assign(Object.create(e),t)}function fr(e,t=[``],n,r,i=()=>e[0]){let a=n||e;return r===void 0&&(r=Or(`_fallback`,e)),new Proxy({[Symbol.toStringTag]:`Object`,_cacheable:!0,_scopes:e,_rootScopes:a,_fallback:r,_getTarget:i,override:n=>fr([n,...e],t,a,r)},{deleteProperty(t,n){return delete t[n],delete t._keys,delete e[0][n],!0},get(n,r){return _r(n,r,()=>Dr(r,t,e,n))},getOwnPropertyDescriptor(e,t){return Reflect.getOwnPropertyDescriptor(e._scopes[0],t)},getPrototypeOf(){return Reflect.getPrototypeOf(e[0])},has(e,t){return kr(e).includes(t)},ownKeys(e){return kr(e)},set(e,t,n){let r=e._storage||=i();return e[t]=r[t]=n,delete e._keys,!0}})}function pr(e,t,n,r){let i={_cacheable:!1,_proxy:e,_context:t,_subProxy:n,_stack:new Set,_descriptors:mr(e,r),setContext:t=>pr(e,t,n,r),override:i=>pr(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 _r(e,t,()=>vr(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 mr(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:Ft(n)?n:()=>n,isIndexable:Ft(r)?r:()=>r}}var hr=(e,t)=>e?e+Nt(t):t,gr=(e,t)=>F(t)&&e!==`adapters`&&(Object.getPrototypeOf(t)===null||t.constructor===Object);function _r(e,t,n){if(Object.prototype.hasOwnProperty.call(e,t)||t===`constructor`)return e[t];let r=n();return e[t]=r,r}function vr(e,t,n){let{_proxy:r,_context:i,_subProxy:a,_descriptors:o}=e,s=r[t];return Ft(s)&&o.isScriptable(t)&&(s=yr(t,s,e,n)),P(s)&&s.length&&(s=br(t,s,e,o.isIndexable)),gr(t,s)&&(s=pr(s,i,a&&a[t],o)),s}function yr(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),gr(e,c)&&(c=wr(i._scopes,i,e,c)),c}function br(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(F(t[0])){let n=t,r=i._scopes.filter(e=>e!==n);t=[];for(let c of n){let n=wr(r,i,e,c);t.push(pr(n,a,o&&o[e],s))}}return t}function xr(e,t,n){return Ft(e)?e(t,n):e}var Sr=(e,t)=>e===!0?t:typeof e==`string`?Mt(t,e):void 0;function Cr(e,t,n,r,i){for(let a of t){let t=Sr(n,a);if(t){e.add(t);let a=xr(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 wr(e,t,n,r){let i=t._rootScopes,a=xr(t._fallback,n,r),o=[...e,...i],s=new Set;s.add(r);let c=Tr(s,o,n,a||n,r);return c===null||a!==void 0&&a!==n&&(c=Tr(s,o,a,c,r),c===null)?!1:fr(Array.from(s),[``],i,a,()=>Er(t,n,r))}function Tr(e,t,n,r,i){for(;n;)n=Cr(e,t,n,r,i);return n}function Er(e,t,n){let r=e._getTarget();t in r||(r[t]={});let i=r[t];return P(i)&&F(n)?n:i||{}}function Dr(e,t,n,r){let i;for(let a of t)if(i=Or(hr(a,e),n),i!==void 0)return gr(e,i)?wr(n,r,e,i):i}function Or(e,t){for(let n of t){if(!n)continue;let t=n[e];if(t!==void 0)return t}}function kr(e){let t=e._keys;return t||=e._keys=Ar(e._scopes),t}function Ar(e){let t=new Set;for(let n of e)for(let e of Object.keys(n).filter(e=>!e.startsWith(`_`)))t.add(e);return Array.from(t)}function jr(){return typeof window<`u`&&typeof document<`u`}function Mr(e){let t=e.parentNode;return t&&t.toString()===`[object ShadowRoot]`&&(t=t.host),t}function Nr(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 Pr=e=>e.ownerDocument.defaultView.getComputedStyle(e,null);function Fr(e,t){return Pr(e).getPropertyValue(t)}var Ir=[`top`,`right`,`bottom`,`left`];function Lr(e,t,n){let r={};n=n?`-`+n:``;for(let i=0;i<4;i++){let a=Ir[i];r[a]=parseFloat(e[t+`-`+a+n])||0}return r.width=r.left+r.right,r.height=r.top+r.bottom,r}var Rr=(e,t,n)=>(e>0||t>0)&&(!n||!n.shadowRoot);function zr(e,t){let n=e.touches,r=n&&n.length?n[0]:e,{offsetX:i,offsetY:a}=r,o=!1,s,c;if(Rr(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=Pr(n),a=i.boxSizing===`border-box`,o=Lr(i,`padding`),s=Lr(i,`border`,`width`),{x:c,y:l,box:u}=zr(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 Vr(e,t,n){let r,i;if(t===void 0||n===void 0){let a=e&&Mr(e);if(!a)t=e.clientWidth,n=e.clientHeight;else{let e=a.getBoundingClientRect(),o=Pr(a),s=Lr(o,`border`,`width`),c=Lr(o,`padding`);t=e.width-c.width-s.width,n=e.height-c.height-s.height,r=Nr(o.maxWidth,a,`clientWidth`),i=Nr(o.maxHeight,a,`clientHeight`)}}return{width:t,height:n,maxWidth:r||Rt,maxHeight:i||Rt}}var Hr=e=>Math.round(e*10)/10;function Ur(e,t,n,r){let i=Pr(e),a=Lr(i,`margin`),o=Nr(i.maxWidth,e,`clientWidth`)||Rt,s=Nr(i.maxHeight,e,`clientHeight`)||Rt,c=Vr(e,t,n),{width:l,height:u}=c;if(i.boxSizing===`content-box`){let e=Lr(i,`border`,`width`),t=Lr(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=Hr(Math.min(l,o,c.maxWidth)),u=Hr(Math.min(u,s,c.maxHeight)),l&&!u&&(u=Hr(l/2)),(t!==void 0||n!==void 0)&&r&&c.height&&u>c.height&&(u=c.height,l=Hr(Math.floor(u*r))),{width:l,height:u}}function Wr(e,t,n){let r=t||1,i=Hr(e.height*r),a=Hr(e.width*r);e.height=Hr(e.height),e.width=Hr(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 Gr=function(){let e=!1;try{let t={get passive(){return e=!0,!1}};jr()&&(window.addEventListener(`test`,null,t),window.removeEventListener(`test`,null,t))}catch{}return e}();function Kr(e,t){let n=Fr(e,t),r=n&&n.match(/^(\d+)(\.\d+)?px$/);return r?+r[1]:void 0}var qr=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 Yr(e,t,n){return e?qr(t,n):Jr()}function Xr(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 Zr(e,t){t!==void 0&&(delete e.prevTextDirection,e.canvas.style.setProperty(`direction`,t[0],t[1]))}function Qr(e,t,n){return e.options.clip?e[n]:t[n]}function $r(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 ei(e,t){let n=t._clip;if(n.disabled)return!1;let r=$r(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 ti=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,mn.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)}},ni=`transparent`,ri={boolean(e,t,n){return n>.5?t:e},color(e,t,n){let r=wn(e||ni),i=r.valid&&wn(t||ni);return i&&i.valid?i.mix(r,n).hexString():t},number(e,t,n){return e+(t-e)*n}},ii=class{constructor(e,t,n,r){let i=t[n];r=lr([e.to,r,i,e.from]);let a=lr([e.from,i,r]);this._active=!0,this._fn=e.fn||ri[e.type||typeof a],this._easing=Sn[e.easing]||Sn.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=lr([e.to,t,r,e.from]),this._from=lr([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]()}},ai=class{constructor(e,t){this._chart=e,this._properties=new Map,this.configure(t)}configure(e){if(!F(e))return;let t=Object.keys(q.animation),n=this._properties;Object.getOwnPropertyNames(e).forEach(r=>{let i=e[r];if(!F(i))return;let a={};for(let e of t)a[e]=i[e];(P(i.properties)&&i.properties||[r]).forEach(e=>{(e===r||!n.has(e))&&n.set(e,a)})})}_animateOptions(e,t){let n=t.options,r=si(e,n);if(!r)return[];let i=this._createAnimations(r,n);return n.$shared&&oi(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 ii(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 ti.add(this._chart,n),!0}};function oi(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 si(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 ci(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 li(e,t,n){if(n===!1)return!1;let r=ci(e,n),i=ci(t,n);return{top:i.end,right:r.end,bottom:i.start,left:r.start}}function ui(e){let t,n,r,i;return F(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 di(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 fi(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],I(l)&&(a||t===0||Ut(t)===Ut(l))&&(t+=l)}return!u&&!r.all?0:t}function pi(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 mi(e,t){let n=e&&e.options.stacked;return n||n===void 0&&t.stack!==void 0}function hi(e,t,n){return`${e.id}.${t.id}.${n.stack||n.type}`}function gi(e){let{min:t,max:n,minDefined:r,maxDefined:i}=e.getUserBounds();return{min:r?t:-1/0,max:i?n:1/0}}function _i(e,t,n){let r=e[t]||(e[t]={});return r[n]||(r[n]={})}function vi(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 yi(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=hi(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]=_i(i,u,a),f[s]=d,f._top=vi(f,o,!0,r.type),f._bottom=vi(f,o,!1,r.type);let m=f._visualValues||(f._visualValues={});m[s]=d}}function bi(e,t){let n=e.scales;return Object.keys(n).filter(e=>n[e].axis===t).shift()}function xi(e,t){return dr(e,{active:!1,dataset:void 0,datasetIndex:t,index:t,mode:`default`,type:`dataset`})}function Si(e,t,n){return dr(e,{active:!1,dataIndex:t,parsed:void 0,raw:void 0,element:n,index:t,mode:`default`,type:`data`})}function Ci(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 wi=e=>e===`reset`||e===`none`,Ti=(e,t)=>t?e:Object.assign({},e),Ei=(e,t,n)=>e&&!t.hidden&&t._stacked&&{keys:di(n,!0),values:null},Di=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=mi(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&&Ci(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=R(n.xAxisID,bi(e,`x`)),a=t.yAxisID=R(n.yAxisID,bi(e,`y`)),o=t.rAxisID=R(n.rAxisID,bi(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&&fn(this._data,this),e._stacked&&Ci(e)}_dataCheck(){let e=this.getDataset(),t=e.data||=[],n=this._data;if(F(t)){let e=this._cachedMeta;this._data=pi(t,e)}else if(n!==t){if(n){fn(n,this);let e=this._cachedMeta;Ci(e),e._parsed=[]}t&&Object.isExtensible(t)&&dn(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=mi(t.vScale,t),t.stack!==n.stack&&(r=!0,Ci(t),t.stack=n.stack),this._resyncElements(e),(r||i!==t._stacked)&&(yi(this,t._parsed),t._stacked=mi(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=P(r[e])?this.parseArrayData(n,r,e,t):F(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&&yi(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(Mt(f,o),d),y:a.parse(Mt(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 fi({keys:di(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=fi(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=Ei(t,n,this.chart),c={min:1/0,max:-1/0},{min:l,max:u}=gi(o),d,f;function p(){f=r[d];let t=f[o.axis];return!I(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],I(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=ui(R(this.options.clip,li(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||=Si(this.getContext(),e,t),i.parsed=this.getParsed(e),i.raw=r.data[e],i.index=i.dataIndex=e}else i=this.$context||=xi(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&&Pt(n);if(o)return Ti(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(q.elements[e]),p=c.resolveNamedOptions(d,f,()=>this.getContext(n,r,t),u);return p.$shared&&(p.$shared=s,i[a]=Object.freeze(Ti(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 ai(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||wi(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){wi(r)?Object.assign(e,n):this._resolveAnimations(t,r).update(e,n)}updateSharedOptions(e,t,n){e&&!wi(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&&Ci(n,r)}n.data.splice(e,t)}_sync(e){if(this._parsing)this._syncList.push(e);else{let[t,n,r]=e;this[t](n,r)}this.chart._dataChanges.push([this.index,...e])}_onDataPush(){let e=arguments.length;this._sync([`_insertElements`,this.getDataset().data.length-e,e])}_onDataPop(){this._sync([`_removeElements`,this._cachedMeta.data.length-1,1])}_onDataShift(){this._sync([`_removeElements`,0,1])}_onDataSplice(e,t){t&&this._sync([`_removeElements`,e,t]);let n=arguments.length-2;n&&this._sync([`_insertElements`,e,n])}_onDataUnshift(){this._sync([`_insertElements`,0,arguments.length])}};function Oi(e,t){if(!e._cache.$bar){let n=e.getMatchingVisibleMetas(t),r=[];for(let t=0,i=n.length;t<i;t++)r=r.concat(n[t].controller.getAllParsedValues(e));e._cache.$bar=pn(r.sort((e,t)=>e-t))}return e._cache.$bar}function ki(e){let t=e.iScale,n=Oi(t,e.type),r=t._length,i,a,o,s,c=()=>{o!==32767&&o!==-32768&&(Pt(s)&&(r=Math.min(r,Math.abs(o-s)||r)),s=o)};for(i=0,a=n.length;i<a;++i)o=t.getPixelForValue(n[i]),c();for(s=void 0,i=0,a=t.ticks.length;i<a;++i)o=t.getPixelForTick(i),c();return r}function Ai(e,t,n,r){let i=n.barThickness,a,o;return N(i)?(a=t.min*n.categoryPercentage,o=n.barPercentage):(a=i*r,o=1),{chunk:a/r,ratio:o,start:t.pixels[e]-a/2}}function ji(e,t,n,r){let i=t.pixels,a=i[e],o=e>0?i[e-1]:null,s=e<i.length-1?i[e+1]:null,c=n.categoryPercentage;o===null&&(o=a-(s===null?t.end-t.start:s-a)),s===null&&(s=a+a-o);let l=a-(a-Math.min(o,s))/2*c;return{chunk:Math.abs(s-o)/2*c/r,ratio:n.barPercentage,start:l}}function Mi(e,t,n,r){let i=n.parse(e[0],r),a=n.parse(e[1],r),o=Math.min(i,a),s=Math.max(i,a),c=o,l=s;Math.abs(o)>Math.abs(s)&&(c=s,l=o),t[n.axis]=l,t._custom={barStart:c,barEnd:l,start:i,end:a,min:o,max:s}}function Ni(e,t,n,r){return P(e)?Mi(e,t,n,r):t[n.axis]=n.parse(e,r),t}function Pi(e,t,n,r){let i=e.iScale,a=e.vScale,o=i.getLabels(),s=i===a,c=[],l,u,d,f;for(l=n,u=n+r;l<u;++l)f=t[l],d={},d[i.axis]=s||i.parse(o[l],l),c.push(Ni(f,d,a,l));return c}function Fi(e){return e&&e.barStart!==void 0&&e.barEnd!==void 0}function Ii(e,t,n){return e===0?(t.isHorizontal()?1:-1)*(t.min>=n?1:-1):Ut(e)}function Li(e){let t,n,r,i,a;return e.horizontal?(t=e.base>e.x,n=`left`,r=`right`):(t=e.base<e.y,n=`bottom`,r=`top`),t?(i=`end`,a=`start`):(i=`start`,a=`end`),{start:n,end:r,reverse:t,top:i,bottom:a}}function Ri(e,t,n,r){let i=t.borderSkipped,a={};if(!i){e.borderSkipped=a;return}if(i===!0){e.borderSkipped={top:!0,right:!0,bottom:!0,left:!0};return}let{start:o,end:s,reverse:c,top:l,bottom:u}=Li(e);i===`middle`&&n&&(e.enableBorderRadius=!0,(n._top||0)===r?i=l:(n._bottom||0)===r?i=u:(a[zi(u,o,s,c)]=!0,i=l)),a[zi(i,o,s,c)]=!0,e.borderSkipped=a}function zi(e,t,n,r){return r?(e=Bi(e,t,n),e=Vi(e,n,t)):e=Vi(e,t,n),e}function Bi(e,t,n){return e===t?n:e===n?t:e}function Vi(e,t,n){return e===`start`?t:e===`end`?n:e}function Hi(e,{inflateAmount:t},n){e.inflateAmount=t===`auto`?n===1?.33:0:t}var Ui=class extends Di{static id=`bar`;static defaults={datasetElementType:!1,dataElementType:`bar`,categoryPercentage:.8,barPercentage:.9,grouped:!0,animations:{numbers:{type:`number`,properties:[`x`,`y`,`base`,`width`,`height`]}}};static overrides={scales:{_index_:{type:`category`,offset:!0,grid:{offset:!0}},_value_:{type:`linear`,beginAtZero:!0}}};parsePrimitiveData(e,t,n,r){return Pi(e,t,n,r)}parseArrayData(e,t,n,r){return Pi(e,t,n,r)}parseObjectData(e,t,n,r){let{iScale:i,vScale:a}=e,{xAxisKey:o=`x`,yAxisKey:s=`y`}=this._parsing,c=i.axis===`x`?o:s,l=a.axis===`x`?o:s,u=[],d,f,p,m;for(d=n,f=n+r;d<f;++d)m=t[d],p={},p[i.axis]=i.parse(Mt(m,c),d),u.push(Ni(Mt(m,l),p,a,d));return u}updateRangeFromParsed(e,t,n,r){super.updateRangeFromParsed(e,t,n,r);let i=n._custom;i&&t===this._cachedMeta.vScale&&(e.min=Math.min(e.min,i.min),e.max=Math.max(e.max,i.max))}getMaxOverflow(){return 0}getLabelAndValue(e){let{iScale:t,vScale:n}=this._cachedMeta,r=this.getParsed(e),i=r._custom,a=Fi(i)?`[`+i.start+`, `+i.end+`]`:``+n.getLabelForValue(r[n.axis]);return{label:``+t.getLabelForValue(r[t.axis]),value:a}}initialize(){this.enableOptionSharing=!0,super.initialize();let e=this._cachedMeta;e.stack=this.getDataset().stack}update(e){let t=this._cachedMeta;this.updateElements(t.data,0,t.data.length,e)}updateElements(e,t,n,r){let i=r===`reset`,{index:a,_cachedMeta:{vScale:o}}=this,s=o.getBasePixel(),c=o.isHorizontal(),l=this._getRuler(),{sharedOptions:u,includeOptions:d}=this._getSharedOptions(t,r);for(let f=t;f<t+n;f++){let t=this.getParsed(f),n=i||N(t[o.axis])?{base:s,head:s}:this._calculateBarValuePixels(f),p=this._calculateBarIndexPixels(f,l),m=(t._stacks||{})[o.axis],h={horizontal:c,base:n.base,enableBorderRadius:!m||Fi(t._custom)||a===m._top||a===m._bottom,x:c?n.head:p.center,y:c?p.center:n.head,height:c?p.size:Math.abs(n.size),width:c?Math.abs(n.size):p.size};d&&(h.options=u||this.resolveDataElementOptions(f,e[f].active?`active`:r));let g=h.options||e[f].options;Ri(h,g,m,a),Hi(h,g,l.ratio),this.updateElement(e[f],f,h,r)}}_getStacks(e,t){let{iScale:n}=this._cachedMeta,r=n.getMatchingVisibleMetas(this._type).filter(e=>e.controller.options.grouped),i=n.options.stacked,a=[],o=this._cachedMeta.controller.getParsed(t),s=o&&o[n.axis],c=e=>{let t=e._parsed.find(e=>e[n.axis]===s),r=t&&t[e.vScale.axis];if(N(r)||isNaN(r))return!0};for(let n of r)if(!(t!==void 0&&c(n))&&((i===!1||a.indexOf(n.stack)===-1||i===void 0&&n.stack===void 0)&&a.push(n.stack),n.index===e))break;return a.length||a.push(void 0),a}_getStackCount(e){return this._getStacks(void 0,e).length}_getAxisCount(){return this._getAxis().length}getFirstScaleIdForIndexAxis(){let e=this.chart.scales,t=this.chart.options.indexAxis;return Object.keys(e).filter(n=>e[n].axis===t).shift()}_getAxis(){let e={},t=this.getFirstScaleIdForIndexAxis();for(let n of this.chart.data.datasets)e[R(this.chart.options.indexAxis===`x`?n.xAxisID:n.yAxisID,t)]=!0;return Object.keys(e)}_getStackIndex(e,t,n){let r=this._getStacks(e,n),i=t===void 0?-1:r.indexOf(t);return i===-1?r.length-1:i}_getRuler(){let e=this.options,t=this._cachedMeta,n=t.iScale,r=[],i,a;for(i=0,a=t.data.length;i<a;++i)r.push(n.getPixelForValue(this.getParsed(i)[n.axis],i));let o=e.barThickness;return{min:o||ki(t),pixels:r,start:n._startPixel,end:n._endPixel,stackCount:this._getStackCount(),scale:n,grouped:e.grouped,ratio:o?1:e.categoryPercentage*e.barPercentage}}_calculateBarValuePixels(e){let{_cachedMeta:{vScale:t,_stacked:n,index:r},options:{base:i,minBarLength:a}}=this,o=i||0,s=this.getParsed(e),c=s._custom,l=Fi(c),u=s[t.axis],d=0,f=n?this.applyStack(t,s,n):u,p,m;f!==u&&(d=f-u,f=u),l&&(u=c.barStart,f=c.barEnd-c.barStart,u!==0&&Ut(u)!==Ut(c.barEnd)&&(d=0),d+=u);let h=!N(i)&&!l?i:d,g=t.getPixelForValue(h);if(p=this.chart.getDataVisibility(e)?t.getPixelForValue(d+f):g,m=p-g,Math.abs(m)<a){m=Ii(m,t,o)*a,u===o&&(g-=m/2);let e=t.getPixelForDecimal(0),i=t.getPixelForDecimal(1);g=Math.max(Math.min(g,Math.max(e,i)),Math.min(e,i)),p=g+m,n&&!l&&(s._stacks[t.axis]._visualValues[r]=t.getValueForPixel(p)-t.getValueForPixel(g))}if(g===t.getPixelForValue(o)){let e=Ut(m)*t.getLineWidthForValue(o)/2;g+=e,m-=e}return{size:m,base:g,head:p,center:p+m/2}}_calculateBarIndexPixels(e,t){let n=t.scale,r=this.options,i=r.skipNull,a=R(r.maxBarThickness,1/0),o,s,c=this._getAxisCount();if(t.grouped){let n=i?this._getStackCount(e):t.stackCount,l=r.barThickness===`flex`?ji(e,t,r,n*c):Ai(e,t,r,n*c),u=this.chart.options.indexAxis===`x`?this.getDataset().xAxisID:this.getDataset().yAxisID,d=this._getAxis().indexOf(R(u,this.getFirstScaleIdForIndexAxis())),f=this._getStackIndex(this.index,this._cachedMeta.stack,i?e:void 0)+d;o=l.start+l.chunk*f+l.chunk/2,s=Math.min(a,l.chunk*l.ratio)}else o=n.getPixelForValue(this.getParsed(e)[n.axis],e),s=Math.min(a,t.min*t.ratio);return{base:o-s/2,head:o+s/2,center:o,size:s}}draw(){let e=this._cachedMeta,t=e.vScale,n=e.data,r=n.length,i=0;for(;i<r;++i)this.getParsed(i)[t.axis]!==null&&!n[i].hidden&&n[i].draw(this._ctx)}};function Wi(){throw Error(`This method is not implemented: Check that a complete date adapter is provided.`)}var Gi={_date:class e{static override(t){Object.assign(e.prototype,t)}options;constructor(e){this.options=e||{}}init(){}formats(){return Wi()}parse(){return Wi()}format(){return Wi()}add(){return Wi()}diff(){return Wi()}startOf(){return Wi()}endOf(){return Wi()}}};function Ki(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?cn:sn;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=>!N(e[t.axis]));r.lo-=Math.max(0,a);let o=n.slice(r.hi).findIndex(e=>!N(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 qi(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}=Ki(a[e],t,o,i);for(let e=c;e<=l;++e){let t=s[e];t.skip||r(t,n,e)}}}function Ji(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 Yi(e,t,n,r,i){let a=[];return!i&&!e.isPointInArea(t)||qi(e,n,t,function(n,o,s){!i&&!Jn(n,e.chartArea,0)||n.inRange(t.x,t.y,r)&&a.push({element:n,datasetIndex:o,index:s})},!0),a}function Xi(e,t,n,r){let i=[];function a(e,n,a){let{startAngle:o,endAngle:s}=e.getProps([`startAngle`,`endAngle`],r),{angle:c}=en(e,{x:t.x,y:t.y});nn(c,o,s)&&i.push({element:e,datasetIndex:n,index:a})}return qi(e,n,t,a),i}function Zi(e,t,n,r,i,a){let o=[],s=Ji(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 qi(e,n,t,l),o}function Qi(e,t,n,r,i,a){return!a&&!e.isPointInArea(t)?[]:n===`r`&&!r?Xi(e,t,n,i):Zi(e,t,n,r,i,a)}function $i(e,t,n,r,i){let a=[],o=n===`x`?`inXRange`:`inYRange`,s=!1;return qi(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 ea={evaluateInteractionItems:qi,modes:{index(e,t,n,r){let i=Br(t,e),a=n.axis||`x`,o=n.includeInvisible||!1,s=n.intersect?Yi(e,i,a,r,o):Qi(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?Yi(e,i,a,r,o):Qi(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 Yi(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 Qi(e,i,a,n.intersect,r,o)},x(e,t,n,r){return $i(e,Br(t,e),`x`,n.intersect,r)},y(e,t,n,r){return $i(e,Br(t,e),`y`,n.intersect,r)}}},ta=[`left`,`top`,`right`,`bottom`];function na(e,t){return e.filter(e=>e.pos===t)}function ra(e,t){return e.filter(e=>ta.indexOf(e.pos)===-1&&e.box.axis===t)}function ia(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 aa(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 oa(e){let t={};for(let n of e){let{stack:e,pos:r,stackWeight:i}=n;if(!e||!ta.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 sa(e,t){let n=oa(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 ca(e){let t=aa(e),n=ia(t.filter(e=>e.box.fullSize),!0),r=ia(na(t,`left`),!0),i=ia(na(t,`right`)),a=ia(na(t,`top`),!0),o=ia(na(t,`bottom`)),s=ra(t,`x`),c=ra(t,`y`);return{fullSize:n,leftAndTop:r.concat(a),rightAndBottom:i.concat(c).concat(o).concat(s),chartArea:na(t,`chartArea`),vertical:r.concat(i).concat(c),horizontal:a.concat(o).concat(s)}}function la(e,t,n,r){return Math.max(e[n],t[n])+Math.max(e[r],t[r])}function ua(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 da(e,t,n,r){let{pos:i,box:a}=n,o=e.maxPadding;if(!F(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&&ua(o,a.getPadding());let s=Math.max(0,t.outerWidth-la(o,e,`left`,`right`)),c=Math.max(0,t.outerHeight-la(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 fa(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 pa(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 ma(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,pa(s.horizontal,t));let{same:o,other:d}=da(t,n,s,r);l|=o&&i.length,u||=d,c.fullSize||i.push(s)}return l&&ma(i,t,n,r)||u}function ha(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 ga(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;Pt(c.start)&&(o=c.start),e.fullSize?ha(e,i.left,o,n.outerWidth-i.right-i.left,a):ha(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;Pt(c.start)&&(a=c.start),e.fullSize?ha(e,a,i.top,o,n.outerHeight-i.bottom-i.top):ha(e,a,t.top+c.placed,o,r),c.start=a,c.placed+=r,a=e.right}}t.x=a,t.y=o}var _a={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=J(e.options.layout.padding),a=Math.max(t-i.width,0),o=Math.max(n-i.height,0),s=ca(e.boxes),c=s.vertical,l=s.horizontal;B(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);ua(f,J(r));let p=Object.assign({maxPadding:f,w:a,h:o,x:i.left,y:i.top},i),m=sa(c.concat(l),d);ma(s.fullSize,p,d,m),ma(c,p,d,m),ma(l,p,d,m)&&ma(c,p,d,m),fa(p),ga(s.leftAndTop,p,d,m),p.x+=p.w,p.y+=p.h,ga(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},B(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})})}},va=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){}},ya=class extends va{acquireContext(e){return e&&e.getContext&&e.getContext(`2d`)||null}updateConfig(e){e.options.animation=!1}},ba=`$chartjs`,xa={touchstart:`mousedown`,touchmove:`mousemove`,touchend:`mouseup`,pointerenter:`mouseenter`,pointerdown:`mousedown`,pointermove:`mousemove`,pointerup:`mouseup`,pointerleave:`mouseout`,pointerout:`mouseout`},Sa=e=>e===null||e===``;function Ca(e,t){let n=e.style,r=e.getAttribute(`height`),i=e.getAttribute(`width`);if(e[ba]={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`,Sa(i)){let t=Kr(e,`width`);t!==void 0&&(e.width=t)}if(Sa(r)){if(e.style.height===``)e.height=e.width/(t||2);else{let t=Kr(e,`height`);t!==void 0&&(e.height=t)}}return e}var wa=Gr?{passive:!0}:!1;function Ta(e,t,n){e&&e.addEventListener(t,n,wa)}function Ea(e,t,n){e&&e.canvas&&e.canvas.removeEventListener(t,n,wa)}function Da(e,t){let n=xa[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 Oa(e,t){for(let n of e)if(n===t||n.contains(t))return!0}function ka(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=Oa(n.addedNodes,r),t&&=!Oa(n.removedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}function Aa(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=Oa(n.removedNodes,r),t&&=!Oa(n.addedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}var ja=new Map,Ma=0;function Na(){let e=window.devicePixelRatio;e!==Ma&&(Ma=e,ja.forEach((t,n)=>{n.currentDevicePixelRatio!==e&&t()}))}function Pa(e,t){ja.size||window.addEventListener(`resize`,Na),ja.set(e,t)}function Fa(e){ja.delete(e),ja.size||window.removeEventListener(`resize`,Na)}function Ia(e,t,n){let r=e.canvas,i=r&&Mr(r);if(!i)return;let a=hn((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 La(e,t,n){n&&n.disconnect(),t===`resize`&&Fa(e)}function Ra(e,t,n){let r=e.canvas,i=hn(t=>{e.ctx!==null&&n(Da(t,e))},e);return Ta(r,t,i),i}var za=class extends va{acquireContext(e,t){let n=e&&e.getContext&&e.getContext(`2d`);return n&&n.canvas===e?(Ca(e,t),n):null}releaseContext(e){let t=e.canvas;if(!t[ba])return!1;let n=t[ba].initial;[`height`,`width`].forEach(e=>{let r=n[e];N(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[ba],!0}addEventListener(e,t,n){this.removeEventListener(e,t);let r=e.$proxies||={};r[t]=({attach:ka,detach:Aa,resize:Ia}[t]||Ra)(e,t,n)}removeEventListener(e,t){let n=e.$proxies||={},r=n[t];r&&(({attach:La,detach:La,resize:La}[t]||Ea)(e,t,r),n[t]=void 0)}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(e,t,n,r){return Ur(e,t,n,r)}isAttached(e){let t=e&&Mr(e);return!!(t&&t.isConnected)}};function Ba(e){return!jr()||typeof OffscreenCanvas<`u`&&e instanceof OffscreenCanvas?ya:za}var Va=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 Jt(this.x)&&Jt(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 Ha(e,t){let n=e.options.ticks,r=Ua(e),i=Math.min(n.maxTicksLimit||r,r),a=n.major.enabled?Ga(t):[],o=a.length,s=a[0],c=a[o-1],l=[];if(o>i)return Ka(t,l,a,o/i),l;let u=Wa(a,t,i);if(o>0){let e,n,r=o>1?Math.round((c-s)/(o-1)):null;for(qa(t,l,u,N(r)?0:s-r,s),e=0,n=o-1;e<n;e++)qa(t,l,u,a[e],a[e+1]);return qa(t,l,u,c,N(r)?t.length:c+r),l}return qa(t,l,u),l}function Ua(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 Wa(e,t,n){let r=Ja(e),i=t.length/n;if(!r)return Math.max(i,1);let a=Kt(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 Ga(e){let t=[],n,r;for(n=0,r=e.length;n<r;n++)e[n].major&&t.push(n);return t}function Ka(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 qa(e,t,n,r,i){let a=R(r,0),o=Math.min(R(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 Ja(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 Ya=e=>e===`left`?`right`:e===`right`?`left`:e,Xa=(e,t,n)=>t===`top`||t===`left`?e[t]+n:e[t]-n,Za=(e,t)=>Math.min(t||e,e);function Qa(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 $a(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 eo(e,t){B(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 to(e){return e.drawTicks?e.tickLength:0}function no(e,t){if(!e.display)return 0;let n=Y(e.font,t),r=J(e.padding);return(P(e.text)?e.text.length:1)*n.lineHeight+r.height}function ro(e,t){return dr(e,{scale:t,type:`scale`})}function io(e,t,n){return dr(e,{tick:n,index:t,type:`tick`})}function ao(e,t,n){let r=_n(e);return(n&&t!==`right`||!n&&t===`right`)&&(r=Ya(r)),r}function oo(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=K(r,a,s),F(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:Xa(e,n,t);f=s-a}else{if(F(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:Xa(e,n,t);m=K(r,o,i),d=n===`left`?-U:U}return{titleX:p,titleY:m,maxWidth:f,rotation:d}}var so=class e extends Va{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=L(e,1/0),t=L(t,-1/0),n=L(n,1/0),r=L(r,-1/0),{min:L(e,n),max:L(t,r),minDefined:I(e),maxDefined:I(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:L(t,L(n,t)),max:L(n,L(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(){z(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=ur(this,i,r),!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();let s=o<this.ticks.length;this._convertTicksToLabels(s?Qa(this.ticks,o):this.ticks),this.configure(),this.beforeCalculateLabelRotation(),this.calculateLabelRotation(),this.afterCalculateLabelRotation(),a.display&&(a.autoSkip||a.source===`auto`)&&(this.ticks=Ha(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(){z(this.options.afterUpdate,[this])}beforeSetDimensions(){z(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(){z(this.options.afterSetDimensions,[this])}_callHooks(e){this.chart.notifyPlugins(e,this.getContext()),z(this.options[e],[this])}beforeDataLimits(){this._callHooks(`beforeDataLimits`)}determineDataLimits(){}afterDataLimits(){this._callHooks(`afterDataLimits`)}beforeBuildTicks(){this._callHooks(`beforeBuildTicks`)}buildTicks(){return[]}afterBuildTicks(){this._callHooks(`afterBuildTicks`)}beforeTickToLabelConversion(){z(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=z(t.callback,[i.value,n,e],this)}afterTickToLabelConversion(){z(this.options.afterTickToLabelConversion,[this])}beforeCalculateLabelRotation(){z(this.options.beforeCalculateLabelRotation,[this])}calculateLabelRotation(){let e=this.options,t=e.ticks,n=Za(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=G(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-to(e.grid)-t.padding-no(e.title,this.chart.options.font),c=Math.sqrt(u*u+d*d),a=Qt(Math.min(Math.asin(G((l.highest.height+6)/o,-1,1)),Math.asin(G(s/c,-1,1))-Math.asin(G(d/c,-1,1)))),a=Math.max(r,Math.min(i,a))),this.labelRotation=a}afterCalculateLabelRotation(){z(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){z(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=no(r,t.options.font);if(o?(e.width=this.maxWidth,e.height=to(i)+a):(e.height=this.maxHeight,e.width=to(i)+a),n.display&&this.ticks.length){let{first:t,last:r,widest:i,highest:a}=this._getLabelSizes(),s=n.padding*2,c=Zt(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(){z(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++)N(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=Qa(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/Za(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,!N(p)&&!P(p))v=Hn(r,g.data,g.gc,v,p),y=_;else if(P(p))for(d=0,f=p.length;d<f;++d)b=p[d],!N(b)&&!P(b)&&(v=Hn(r,g.data,g.gc,v,b),y+=_);a.push(v),o.push(y),c=Math.max(v,c),l=Math.max(y,l)}eo(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 rn(this._alignToPixels?Wn(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||=io(this.getContext(),e,n)}return this.$context||=ro(this.chart.getContext(),this)}_tickSize(){let e=this.options.ticks,t=Zt(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=to(i),d=[],f=o.setContext(this.getContext()),p=f.display?f.width:0,m=p/2,h=function(e){return Wn(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(F(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(F(a)){let e=Object.keys(a)[0],t=a[e];g=h(this.chart.scales[e].getPixelForValue(t))}b=g-m,S=b-u,w=e.left,E=e.right}let O=R(r.ticks.maxTicksLimit,l),ee=Math.max(1,Math.ceil(l/O));for(_=0;_<l;_+=ee){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=$a(this,_,s),v!==void 0&&(y=Wn(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=to(n.grid),f=d+l,p=u?-l:f,m=-Zt(this.labelRotation),h=[],g,_,v,y,b,x,S,C,w,T,E,D,O=`middle`;if(r===`top`)x=this.bottom-p,S=this._getXAxisLabelAlignment();else if(r===`bottom`)x=this.top+p,S=this._getXAxisLabelAlignment();else if(r===`left`){let e=this._getYAxisLabelAlignment(d);S=e.textAlign,b=e.x}else if(r===`right`){let e=this._getYAxisLabelAlignment(d);S=e.textAlign,b=e.x}else if(t===`x`){if(r===`center`)x=(e.top+e.bottom)/2+f;else if(F(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(F(r)){let e=Object.keys(r)[0],t=r[e];b=this.chart.scales[e].getPixelForValue(t)}S=this._getYAxisLabelAlignment(d).textAlign}t===`y`&&(s===`start`?O=`top`:s===`end`&&(O=`bottom`));let ee=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=P(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`?-ee.highest.height/2-t*T+T:-ee.highest.height+T/2:c===`near`||m!==0?T/2:c===`center`?ee.highest.height/2-t*T:ee.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=J(e.backdropPadding),n=ee.heights[g],r=ee.widths[g],i=D-t.top,a=0-t.left;switch(O){case`middle`:i-=n/2;break;case`bottom`:i-=n}switch(S){case`center`:a-=r/2;break;case`right`:a-=r;break;case`inner`:g===_-1?a-=r:g>0&&(a-=r/2)}f={left:a,top:i,width:r+t.width,height:n+t.height,color:e.backdropColor}}h.push({label:y,font:w,textOffset:D,options:{rotation:m,color:n,strokeColor:s,strokeWidth:l,textAlign:d,textBaseline:O,translation:[b,x],backdrop:f}})}return h}_getXAxisLabelAlignment(){let{position:e,ticks:t}=this.options;if(-Zt(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=Wn(e,this.left,a)-a/2,l=Wn(e,this.right,o)+o/2,u=d=s):(u=Wn(e,this.top,a)-a/2,d=Wn(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&&Yn(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;er(t,i,0,a,r,n)}n&&Xn(t)}drawTitle(){let{ctx:e,options:{position:t,title:n,reverse:r}}=this;if(!n.display)return;let i=Y(n.font),a=J(n.padding),o=n.align,s=i.lineHeight/2;t===`bottom`||t===`center`||F(t)?(s+=a.bottom,P(n.text)&&(s+=i.lineHeight*(n.text.length-1))):s+=a.top;let{titleX:c,titleY:l,maxWidth:u,rotation:d}=oo(this,s,t,o);er(e,n.text,0,0,i,{color:n.color,maxWidth:u,rotation:d,textAlign:ao(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=R(t.grid&&t.grid.z,-1),i=R(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 Y(this.options.ticks.setContext(this.getContext(e)).font)}_maxDigits(){let e=this._resolveTickFontOptions(0).lineHeight;return(this.isHorizontal()?this.width:this.height)/e}},co=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;fo(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,lo(e,a,n),this.override&&q.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 q[r]&&(delete q[r][n],this.override&&delete Ln[n])}};function lo(e,t,n){let r=Et(Object.create(null),[n?q.get(n):{},q.get(t),e.defaults]);q.set(t,r),e.defaultRoutes&&uo(t,e.defaultRoutes),e.descriptors&&q.describe(t,e.descriptors)}function uo(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(`.`);q.route(a,i,c,s)})}function fo(e){return`id`in e&&`defaults`in e}var X=new class{constructor(){this.controllers=new co(Di,`datasets`,!0),this.elements=new co(Va,`elements`),this.plugins=new co(Object,`plugins`),this.scales=new co(so,`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):B(t,t=>{let r=n||this._getRegistryForType(t);this._exec(e,r,t)})})}_exec(e,t,n){let r=Nt(e);z(n[`before`+r],[],n),t[e](n),z(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}},po=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(z(a,[t,r,i.options],e)===!1&&r.cancelable)return!1}return!0}invalidate(){N(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=R(n.options&&n.options.plugins,{}),i=mo(n);return r===!1&&!t?[]:go(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 mo(e){let t={},n=[],r=Object.keys(X.plugins.items);for(let e=0;e<r.length;e++)n.push(X.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 ho(e,t){return!t&&e===!1?null:e===!0?{}:e}function go(e,{plugins:t,localIds:n},r,i){let a=[],o=e.getContext();for(let s of t){let t=s.id,c=ho(r[t],i);c!==null&&a.push({plugin:s,options:_o(e.config,{plugin:s,local:n[t]},c,o)})}return a}function _o(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 vo(e,t){let n=q.datasets[e]||{};return((t.datasets||{})[e]||{}).indexAxis||t.indexAxis||n.indexAxis||`x`}function yo(e,t){let n=e;return e===`_index_`?n=t:e===`_value_`&&(n=t===`x`?`y`:`x`),n}function bo(e,t){return e===t?`_index_`:`_value_`}function xo(e){if(e===`x`||e===`y`||e===`r`)return e}function So(e){if(e===`top`||e===`bottom`)return`x`;if(e===`left`||e===`right`)return`y`}function Co(e,...t){if(xo(e))return e;for(let n of t){let t=n.axis||So(n.position)||e.length>1&&xo(e[0].toLowerCase());if(t)return t}throw Error(`Cannot determine type of '${e}' axis. Please provide 'axis' or 'position' option.`)}function wo(e,t,n){if(n[t+`AxisID`]===e)return{axis:t}}function To(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 wo(e,`x`,n[0])||wo(e,`y`,n[0])}return{}}function Eo(e,t){let n=Ln[e.type]||{scales:{}},r=t.scales||{},i=vo(e.type,t),a=Object.create(null);return Object.keys(r).forEach(t=>{let o=r[t];if(!F(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=Co(t,o,To(t,e),q.scales[o.type]),c=bo(s,i),l=n.scales||{};a[t]=Dt(Object.create(null),[{axis:s},o,l[s],l[c]])}),e.data.datasets.forEach(n=>{let i=n.type||e.type,o=n.indexAxis||vo(i,t),s=(Ln[i]||{}).scales||{};Object.keys(s).forEach(e=>{let t=yo(e,o),i=n[t+`AxisID`]||t;a[i]=a[i]||Object.create(null),Dt(a[i],[{axis:t},r[i],s[e]])})}),Object.keys(a).forEach(e=>{let t=a[e];Dt(t,[q.scales[t.type],q.scale])}),a}function Do(e){let t=e.options||={};t.plugins=R(t.plugins,{}),t.scales=Eo(e,t)}function Oo(e){return e||={},e.datasets=e.datasets||[],e.labels=e.labels||[],e}function ko(e){return e||={},e.data=Oo(e.data),Do(e),e}var Ao=new Map,jo=new Set;function Mo(e,t){let n=Ao.get(e);return n||(n=t(),Ao.set(e,n),jo.add(n)),n}var No=(e,t,n)=>{let r=Mt(t,n);r!==void 0&&e.add(r)},Po=class{constructor(e){this._config=ko(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(),Do(e)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(e){return Mo(e,()=>[[`datasets.${e}`,``]])}datasetAnimationScopeKeys(e,t){return Mo(`${e}.transition.${t}`,()=>[[`datasets.${e}.transitions.${t}`,`transitions.${t}`],[`datasets.${e}`,``]])}datasetElementScopeKeys(e,t){return Mo(`${e}-${t}`,()=>[[`datasets.${e}.elements.${t}`,`datasets.${e}`,`elements.${t}`,``]])}pluginScopeKeys(e){let t=e.id,n=this.type;return Mo(`${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=>No(s,e,t))),t.forEach(e=>No(s,r,e)),t.forEach(e=>No(s,Ln[i]||{},e)),t.forEach(e=>No(s,q,e)),t.forEach(e=>No(s,Rn,e))});let c=Array.from(s);return c.length===0&&c.push(Object.create(null)),jo.has(t)&&a.set(t,c),c}chartOptionScopes(){let{options:e,type:t}=this;return[e,Ln[t]||{},q.datasets[t]||{},{type:t},q,Rn]}resolveNamedOptions(e,t,n,r=[``]){let i={$shared:!0},{resolver:a,subPrefixes:o}=Fo(this._resolverCache,e,r),s=a;if(Lo(a,t)){i.$shared=!1,n=Ft(n)?n():n;let t=this.createResolver(e,n,o);s=pr(a,n,t)}for(let e of t)i[e]=s[e];return i}createResolver(e,t,n=[``],r){let{resolver:i}=Fo(this._resolverCache,e,n);return F(t)?pr(i,t,void 0,r):i}};function Fo(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:fr(t,n),subPrefixes:n.filter(e=>!e.toLowerCase().includes(`hover`))},r.set(i,a)),a}var Io=e=>F(e)&&Object.getOwnPropertyNames(e).some(t=>Ft(e[t]));function Lo(e,t){let{isScriptable:n,isIndexable:r}=mr(e);for(let i of t){let t=n(i),a=r(i),o=(a||t)&&e[i];if(t&&(Ft(o)||Io(o))||a&&P(o))return!0}return!1}var Ro=`4.5.1`,zo=[`top`,`bottom`,`left`,`right`,`chartArea`];function Bo(e,t){return e===`top`||e===`bottom`||zo.indexOf(e)===-1&&t===`x`}function Vo(e,t){return function(n,r){return n[e]===r[e]?n[t]-r[t]:n[e]-r[e]}}function Ho(e){let t=e.chart,n=t.options.animation;t.notifyPlugins(`afterRender`),z(n&&n.onComplete,[e],t)}function Uo(e){let t=e.chart,n=t.options.animation;z(n&&n.onProgress,[e],t)}function Wo(e){return jr()&&typeof e==`string`?e=document.getElementById(e):e&&e.length&&(e=e[0]),e&&e.canvas&&(e=e.canvas),e}var Go={},Ko=e=>{let t=Wo(e);return Object.values(Go).filter(e=>e.canvas===t).pop()};function qo(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 Jo(e,t,n,r){return!n||e.type===`mouseout`?null:r?t:e}var Yo=class{static defaults=q;static instances=Go;static overrides=Ln;static registry=X;static version=Ro;static getChart=Ko;static register(...e){X.add(...e),Xo()}static unregister(...e){X.remove(...e),Xo()}constructor(e,t){let n=this.config=new Po(t),r=Wo(e),i=Ko(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||(Ba(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=bt(),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 po,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=gn(e=>this.update(e),a.resizeDelay||0),this._dataChanges=[],Go[this.id]=this,!o||!s){console.error(`Failed to create chart: can't acquire context from the given item`);return}ti.listen(this,`complete`,Ho),ti.listen(this,`progress`,Uo),this._initialize(),this.attached&&this.update()}get aspectRatio(){let{options:{aspectRatio:e,maintainAspectRatio:t},width:n,height:r,_aspectRatio:i}=this;return N(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 X}_initialize(){return this.notifyPlugins(`beforeInit`),this.options.responsive?this.resize():Wr(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins(`afterInit`),this}clear(){return Gn(this.canvas,this.ctx),this}stop(){return ti.stop(this),this}resize(e,t){ti.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}),z(n.onResize,[this,a],this),this.attached&&this._doResize(s)&&this.render())}ensureScalesHaveIDs(){B(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=Co(e,n),i=r===`r`,a=r===`x`;return{options:n,dposition:i?`chartArea`:a?`bottom`:`left`,dtype:i?`radialLinear`:a?`category`:`linear`}}))),B(i,t=>{let i=t.options,a=i.id,o=Co(a,i),s=R(i.type,t.dtype);(i.position===void 0||Bo(i.position,o)!==Bo(t.dposition))&&(i.position=t.dposition),r[a]=!0;let c=null;a in n&&n[a].type===s?c=n[a]:(c=new(X.getScale(s))({id:a,type:s,ctx:this.ctx,chart:this}),n[c.id]=c),c.init(i,e)}),B(r,(e,t)=>{e||delete n[t]}),B(n,e=>{_a.configure(this,e,e.options),_a.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(Vo(`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||vo(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=X.getController(a),{datasetElementType:r,dataElementType:o}=q.datasets[a];Object.assign(t,{dataElementType:X.getElement(o),datasetElementType:r&&X.getElement(r)}),i.controller=new t(this,n),e.push(i.controller)}}return this._updateMetasets(),e}_resetElements(){B(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||B(i,e=>{e.reset()}),this._updateDatasets(e),this.notifyPlugins(`afterUpdate`,{mode:e}),this._layers.sort(Vo(`z`,`_idx`));let{_active:o,_lastEvent:s}=this;s?this._eventHandler(s,!0):o.length&&this._updateHoverStyles(o,o,!0),this.render()}_updateScales(){B(this.scales,e=>{_a.removeBox(this,e)}),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){let e=this.options;(!It(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)qo(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(!It(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;_a.update(this,this.width,this.height,e);let t=this.chartArea,n=t.width<=0||t.height<=0;this._layers=[],B(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,Ft(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&&(ti.has(this)?this.attached&&!ti.running(this)&&ti.start(this):(this.draw(),Ho({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=ei(this,e);this.notifyPlugins(`beforeDatasetDraw`,n)!==!1&&(r&&Yn(t,r),e.controller.draw(),r&&Xn(t),n.cancelable=!1,this.notifyPlugins(`afterDatasetDraw`,n))}isPointInArea(e){return Jn(e,this.chartArea,this._minPadding)}getElementsAtEventForMode(e,t,n,r){let i=ea.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||=dr(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);Pt(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(),ti.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(),Gn(e,t),this.platform.releaseContext(t),this.canvas=null,this.ctx=null),delete Go[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)};B(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(){B(this._listeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._listeners={},B(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}});St(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=Lt(e),c=Jo(e,this._lastEvent,n,s);n&&(this._lastEvent=null,z(i.onHover,[e,o,this],this),s&&z(i.onClick,[e,o,this],this));let l=!St(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 Xo(){return B(Yo.instances,e=>e._plugins.invalidate())}function Zo(e,t){let{x:n,y:r,base:i,width:a,height:o}=e.getProps([`x`,`y`,`base`,`width`,`height`],t),s,c,l,u,d;return e.horizontal?(d=o/2,s=Math.min(n,i),c=Math.max(n,i),l=r-d,u=r+d):(d=a/2,s=n-d,c=n+d,l=Math.min(r,i),u=Math.max(r,i)),{left:s,top:l,right:c,bottom:u}}function Qo(e,t,n,r){return e?0:G(t,n,r)}function $o(e,t,n){let r=e.options.borderWidth,i=e.borderSkipped,a=sr(r);return{t:Qo(i.top,a.top,0,n),r:Qo(i.right,a.right,0,t),b:Qo(i.bottom,a.bottom,0,n),l:Qo(i.left,a.left,0,t)}}function es(e,t,n){let{enableBorderRadius:r}=e.getProps([`enableBorderRadius`]),i=e.options.borderRadius,a=cr(i),o=Math.min(t,n),s=e.borderSkipped,c=r||F(i);return{topLeft:Qo(!c||s.top||s.left,a.topLeft,0,o),topRight:Qo(!c||s.top||s.right,a.topRight,0,o),bottomLeft:Qo(!c||s.bottom||s.left,a.bottomLeft,0,o),bottomRight:Qo(!c||s.bottom||s.right,a.bottomRight,0,o)}}function ts(e){let t=Zo(e),n=t.right-t.left,r=t.bottom-t.top,i=$o(e,n/2,r/2),a=es(e,n/2,r/2);return{outer:{x:t.left,y:t.top,w:n,h:r,radius:a},inner:{x:t.left+i.l,y:t.top+i.t,w:n-i.l-i.r,h:r-i.t-i.b,radius:{topLeft:Math.max(0,a.topLeft-Math.max(i.t,i.l)),topRight:Math.max(0,a.topRight-Math.max(i.t,i.r)),bottomLeft:Math.max(0,a.bottomLeft-Math.max(i.b,i.l)),bottomRight:Math.max(0,a.bottomRight-Math.max(i.b,i.r))}}}}function ns(e,t,n,r){let i=t===null,a=n===null,o=e&&!(i&&a)&&Zo(e,r);return o&&(i||an(t,o.left,o.right))&&(a||an(n,o.top,o.bottom))}function rs(e){return e.topLeft||e.topRight||e.bottomLeft||e.bottomRight}function is(e,t){e.rect(t.x,t.y,t.w,t.h)}function as(e,t,n={}){let r=e.x===n.x?0:-t,i=e.y===n.y?0:-t,a=(e.x+e.w===n.x+n.w?0:t)-r,o=(e.y+e.h===n.y+n.h?0:t)-i;return{x:e.x+r,y:e.y+i,w:e.w+a,h:e.h+o,radius:e.radius}}var os=class extends Va{static id=`bar`;static defaults={borderSkipped:`start`,borderWidth:0,borderRadius:0,inflateAmount:`auto`,pointStyle:void 0};static defaultRoutes={backgroundColor:`backgroundColor`,borderColor:`borderColor`};constructor(e){super(),this.options=void 0,this.horizontal=void 0,this.base=void 0,this.width=void 0,this.height=void 0,this.inflateAmount=void 0,e&&Object.assign(this,e)}draw(e){let{inflateAmount:t,options:{borderColor:n,backgroundColor:r}}=this,{inner:i,outer:a}=ts(this),o=rs(a.radius)?tr:is;e.save(),(a.w!==i.w||a.h!==i.h)&&(e.beginPath(),o(e,as(a,t,i)),e.clip(),o(e,as(i,-t,a)),e.fillStyle=n,e.fill(`evenodd`)),e.beginPath(),o(e,as(i,t)),e.fillStyle=r,e.fill(),e.restore()}inRange(e,t,n){return ns(this,e,t,n)}inXRange(e,t){return ns(this,e,null,t)}inYRange(e,t){return ns(this,null,e,t)}getCenterPoint(e){let{x:t,y:n,base:r,horizontal:i}=this.getProps([`x`,`y`,`base`,`horizontal`],e);return{x:i?(t+r)/2:t,y:i?n:(n+r)/2}}getRange(e){return e===`x`?this.width/2:this.height/2}},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,ls=class extends Va{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=z(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=Y(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}=us(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=Yr(i,this.left,this.width);if(this.isHorizontal()){let i=0,o=K(n,this.left+r,this.right-this.lineWidths[i]);for(let s of t)i!==s.row&&(i=s.row,o=K(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=K(n,this.top+e+r,this.bottom-this.columnSizes[i].height);for(let s of t)s.col!==i&&(i=s.col,o=K(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;Yn(e,this),this._draw(),Xn(e)}}_draw(){let{options:e,columnSizes:t,lineWidths:n,ctx:r}=this,{align:i,labels:a}=e,o=q.color,s=Yr(e.rtl,this.left,this.width),c=Y(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=R(n.lineWidth,1);if(r.fillStyle=R(n.fillStyle,o),r.lineCap=R(n.lineCap,`butt`),r.lineDashOffset=R(n.lineDashOffset,0),r.lineJoin=R(n.lineJoin,`miter`),r.lineWidth=i,r.strokeStyle=R(n.strokeStyle,o),r.setLineDash(R(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;qn(r,o,c,l,a.pointStyleWidth&&p)}else{let a=t+Math.max((u-m)/2,0),o=s.leftForLtr(e,p),c=cr(n.borderRadius);r.beginPath(),Object.values(c).some(e=>e!==0)?tr(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){er(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:K(i,this.left+l,this.right-n[0]),y:this.top+l+y,line:0}:{x:this.left+l,y:K(i,this.top+y+l,this.bottom-t[0].height),line:0},Xr(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=K(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=K(i,this.top+y+l,this.bottom-t[f.line].height));let w=s.x(S);if(g(w,C,o),S=vn(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+=ps(o,e)+l}else f.y+=b}),Zr(this.ctx,e.textDirection)}drawTitle(){let e=this.options,t=e.title,n=Y(t.font),r=J(t.padding);if(!t.display)return;let i=Yr(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=K(e.align,u,this.right-d);else{let t=this.columnSizes.reduce((e,t)=>Math.max(e,t.height),0);l=c+K(e.align,this.top,this.bottom-t-e.labels.padding-this._computeTitleHeight())}let f=K(o,u,u+d);a.textAlign=i.textAlign(_n(o)),a.textBaseline=`middle`,a.strokeStyle=t.color,a.fillStyle=t.color,a.font=n.string,er(a,t.text,f,l,n)}_computeTitleHeight(){let e=this.options.title,t=Y(e.font),n=J(e.padding);return e.display?t.lineHeight+n.height:0}_getLegendItemAt(e,t){let n,r,i;if(an(e,this.left,this.right)&&an(t,this.top,this.bottom)){for(i=this.legendHitBoxes,n=0;n<i.length;++n)if(r=i[n],an(e,r.left,r.left+r.width)&&an(t,r.top,r.top+r.height))return this.legendItems[n]}return null}handleEvent(e){let t=this.options;if(!ms(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&&z(t.onLeave,[e,r,this],this),this._hoveredItem=n,n&&!i&&z(t.onHover,[e,n,this],this)}else n&&z(t.onClick,[e,n,this],this)}};function us(e,t,n,r,i){return{itemWidth:ds(r,e,t,n),itemHeight:fs(i,r,t.lineHeight)}}function ds(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 fs(e,t,n){let r=e;return typeof t.text!=`string`&&(r=ps(t,n)),r}function ps(e,t){return t*(e.text?e.text.length:0)}function ms(e,t){return!!((e===`mousemove`||e===`mouseout`)&&(t.onHover||t.onLeave)||t.onClick&&(e===`click`||e===`mouseup`))}var hs={id:`legend`,_element:ls,start(e,t,n){let r=e.legend=new ls({ctx:e.ctx,options:n,chart:e});_a.configure(e,r,n),_a.addBox(e,r)},stop(e){_a.removeBox(e,e.legend),delete e.legend},beforeUpdate(e,t,n){let r=e.legend;_a.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=J(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)}}},gs={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=tn(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 Z(e,t){return t&&(P(t)?Array.prototype.push.apply(e,t):e.push(t)),e}function _s(e){return(typeof e==`string`||e instanceof String)&&e.indexOf(`
`)>-1?e.split(`
`):e}function vs(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 ys(e,t){let n=e.chart.ctx,{body:r,footer:i,title:a}=e,{boxWidth:o,boxHeight:s}=t,c=Y(t.bodyFont),l=Y(t.titleFont),u=Y(t.footerFont),d=a.length,f=i.length,p=r.length,m=J(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,B(e.title,y),n.font=c.string,B(e.beforeBody.concat(e.afterBody),y),v=t.displayColors?o+2+t.boxPadding:0,B(r,e=>{B(e.before,y),B(e.lines,y),B(e.after,y)}),v=0,n.font=u.string,B(e.footer,y),n.restore(),g+=m.width,{width:g,height:h}}function bs(e,t){let{y:n,height:r}=t;return n<r/2?`top`:n>e.height-r/2?`bottom`:`center`}function xs(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 Ss(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`),xs(l,e,t,n)&&(l=`center`),l}function Cs(e,t,n){let r=n.yAlign||t.yAlign||bs(e,n);return{xAlign:n.xAlign||t.xAlign||Ss(e,t,n,r),yAlign:r}}function ws(e,t){let{x:n,width:r}=e;return t===`right`?n-=r:t===`center`&&(n-=r/2),n}function Ts(e,t,n){let{y:r,height:i}=e;return t===`top`?r+=n:r-=t===`bottom`?i+n:i/2,r}function Es(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}=cr(o),m=ws(t,s),h=Ts(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:G(m,0,r.width-t.width),y:G(h,0,r.height-t.height)}}function Ds(e,t,n){let r=J(n.padding);return t===`center`?e.x+e.width/2:t===`right`?e.x+e.width-r.right:e.x+r.left}function Os(e){return Z([],_s(e))}function ks(e,t,n){return dr(e,{tooltip:t,tooltipItems:n,type:`tooltip`})}function As(e,t){let n=t&&t.dataset&&t.dataset.tooltip&&t.dataset.tooltip.callbacks;return n?e.override(n):e}var js={beforeTitle:M,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:M,beforeBody:M,beforeLabel:M,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 N(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:M,afterBody:M,beforeFooter:M,footer:M,afterFooter:M};function Q(e,t,n,r){let i=e[t].call(n,r);return i===void 0?js[t].call(n,r):i}var Ms=class extends Va{static positioners=gs;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 ai(this.chart,r);return r._cacheable&&(this._cachedAnimations=Object.freeze(i)),i}getContext(){return this.$context||=ks(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=Z(o,_s(r)),o=Z(o,_s(i)),o=Z(o,_s(a)),o}getBeforeBody(e,t){return Os(Q(t.callbacks,`beforeBody`,this,e))}getBody(e,t){let{callbacks:n}=t,r=[];return B(e,e=>{let t={before:[],lines:[],after:[]},i=As(n,e);Z(t.before,_s(Q(i,`beforeLabel`,this,e))),Z(t.lines,Q(i,`label`,this,e)),Z(t.after,_s(Q(i,`afterLabel`,this,e))),r.push(t)}),r}getAfterBody(e,t){return Os(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=Z(o,_s(r)),o=Z(o,_s(i)),o=Z(o,_s(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(vs(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))),B(o,t=>{let n=As(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=gs[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=ys(this,n),o=Object.assign({},e,t),s=Cs(this.chart,n,o),c=Es(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}=cr(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=Yr(n.rtl,this.x,this.width);for(e.x=Ds(this,n.titleAlign,n),t.textAlign=c.textAlign(n.titleAlign),t.textBaseline=`middle`,a=Y(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=Y(i.bodyFont),u=Ds(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,Kn(e,t,n,l),e.strokeStyle=a.borderColor,e.fillStyle=a.backgroundColor,Kn(e,t,n,l)}else{e.lineWidth=F(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=cr(a.borderRadius);Object.values(o).some(e=>e!==0)?(e.beginPath(),e.fillStyle=i.multiKeyBackground,tr(e,{x:t,y:p,w:c,h:s,radius:o}),e.fill(),e.stroke(),e.fillStyle=a.backgroundColor,e.beginPath(),tr(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=Y(n.bodyFont),d=u.lineHeight,f=0,p=Yr(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=Ds(this,h,n),t.fillStyle=n.bodyColor,B(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=_,B(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;B(g.after,m)}f=0,d=u.lineHeight,B(this.afterBody,m),e.y-=i}drawFooter(e,t,n){let r=this.footer,i=r.length,a,o;if(i){let s=Yr(n.rtl,this.x,this.width);for(e.x=Ds(this,n.footerAlign,n),e.y+=n.footerMarginTop,t.textAlign=s.textAlign(n.footerAlign),t.textBaseline=`middle`,a=Y(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}=cr(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=gs[e.position].call(this,this._active,this._eventPosition);if(!n)return;let a=this._size=ys(this,e),o=Object.assign({},n,this._size),s=Cs(t,e,o),c=Es(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=J(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),Xr(e,t.textDirection),i.y+=a.top,this.drawTitle(i,e,t),this.drawBody(i,e,t),this.drawFooter(i,e,t),Zr(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=!St(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||!St(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=gs[i.position].call(this,e,t);return a!==!1&&(n!==a.x||r!==a.y)}},Ns={id:`tooltip`,_element:Ms,positioners:gs,afterInit(e,t,n){n&&(e.tooltip=new Ms({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:js},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`]},Ps=(e,t,n,r)=>(typeof t==`string`?(n=e.push(t)-1,r.unshift({index:n,label:t})):isNaN(t)&&(n=null),n);function Fs(e,t,n,r){let i=e.indexOf(t);return i===-1?Ps(e,t,n,r):i===e.lastIndexOf(t)?i:n}var Is=(e,t)=>e===null?null:G(Math.round(e),0,t);function Ls(e){let t=this.getLabels();return e>=0&&e<t.length?t[e]:e}var Rs=class extends so{static id=`category`;static defaults={ticks:{callback:Ls}};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(N(e))return null;let n=this.getLabels();return t=isFinite(t)&&n[t]===e?t:Fs(n,e,R(t,e),this._addedLabels),Is(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 Ls.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 zs(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=!N(a),_=!N(o),v=!N(c),y=(h-m)/(u+1),b=Gt((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=Gt(w*b/p/f)*f),N(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&&Yt((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=Wt(w,Math.round(w),b/1e3)?Math.round(w):Math.ceil(w));let T=Math.max($t(b),$t(S));x=10**(N(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++,Wt(Math.round((S+E*b)*x)/x,a,Bs(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&&Wt(n[n.length-1].value,o,Bs(o,y,e))?n[n.length-1].value=o:n.push({value:o}):(!_||C===o)&&n.push({value:C}),n}function Bs(e,t,{horizontal:n,minRotation:r}){let i=Zt(r),a=(n?Math.sin(i):Math.cos(i))||.001,o=.75*t*(``+e).length;return Math.min(t/a,o)}var Vs=class extends so{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 N(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=Ut(r),t=Ut(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=zs({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`&&Xt(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 Mn(e,this.chart.options.locale,this.options.ticks.format)}},Hs=class extends Vs{static id=`linear`;static defaults={ticks:{callback:Fn.formatters.numeric}};determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=I(e)?e:0,this.max=I(t)?t:1,this.handleTickRangeOptions()}computeTickLimit(){let e=this.isHorizontal(),t=e?this.width:this.height,n=Zt(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}},Us=e=>Math.floor(Ht(e)),Ws=(e,t)=>10**(Us(e)+t);function Gs(e){return e/10**Us(e)==1}function Ks(e,t,n){let r=10**n,i=Math.floor(e/r);return Math.ceil(t/r)-i}function qs(e,t){let n=Us(t-e);for(;Ks(e,t,n)>10;)n++;for(;Ks(e,t,n)<10;)n--;return Math.min(n,Us(e))}function Js(e,{min:t,max:n}){t=L(e.min,t);let r=[],i=Us(t),a=qs(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=L(e.min,Math.round((c+u+d*10**a)*o)/o);for(;f<n;)r.push({value:f,major:Gs(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=L(e.max,f);return r.push({value:p,major:Gs(p),significand:d}),r}(class extends so{static id=`logarithmic`;static defaults={ticks:{callback:Fn.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=Vs.prototype.parse.apply(this,[e,t]);if(n===0){this._zero=!0;return}return I(n)&&n>0?n:null}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=I(e)?Math.max(0,e):null,this.max=I(t)?Math.max(0,t):null,this.options.beginAtZero&&(this._zero=!0),this._zero&&this.min!==this._suggestedMin&&!I(this._userMin)&&(this.min=e===Ws(this.min,0)?Ws(this.min,-1):Ws(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(Ws(n,-1)),a(Ws(r,1)))),n<=0&&i(Ws(r,-1)),r<=0&&a(Ws(n,1)),this.min=n,this.max=r}buildTicks(){let e=this.options,t=Js({min:this._userMin,max:this._userMax},this);return e.bounds===`ticks`&&Xt(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`:Mn(e,this.chart.options.locale,this.options.ticks.format)}configure(){let e=this.min;super.configure(),this._startValue=Ht(e),this._valueRange=Ht(this.max)-Ht(e)}getPixelForValue(e){return(e===void 0||e===0)&&(e=this.min),e===null||isNaN(e)?NaN:this.getPixelForDecimal(e===this.min?0:(Ht(e)-this._startValue)/this._valueRange)}getValueForPixel(e){let t=this.getDecimalForPixel(e);return 10**(this._startValue+t*this._valueRange)}});function Ys(e){let t=e.ticks;if(t.display&&e.display){let e=J(t.backdropPadding);return R(t.font&&t.font.size,q.font.size)+e.height}return 0}function Xs(e,t,n){return n=P(n)?n:[n],{w:Un(e,t.string,n),h:n.length*t.lineHeight}}function Zs(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 Qs(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?V/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=Y(a.font),d=Xs(e.ctx,u,e._pointLabels[c]);r[c]=d;let f=W(e.getIndexAngle(c)+s),p=Math.round(Qt(f));$s(n,t,f,Zs(p,l.x,d.w,0,180),Zs(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=nc(e,r,i)}function $s(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 ec(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(Qt(W(c.angle+U))),u=ac(c.y,s.h,l),d=rc(l),f=ic(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 tc(e,t){if(!t)return!0;let{left:n,top:r,right:i,bottom:a}=e;return!(Jn({x:n,y:r},t)||Jn({x:n,y:a},t)||Jn({x:i,y:r},t)||Jn({x:i,y:a},t))}function nc(e,t,n){let r=[],i=e._pointLabels.length,a=e.options,{centerPointLabels:o,display:s}=a.pointLabels,c={extra:Ys(a)/2,additionalAngle:o?V/i:0},l;for(let a=0;a<i;a++){c.padding=n[a],c.size=t[a];let i=ec(e,a,c);r.push(i),s===`auto`&&(i.visible=tc(i,l),i.visible&&(l=i))}return r}function rc(e){return e===0||e===180?`center`:e<180?`left`:`right`}function ic(e,t,n){return n===`right`?e-=t:n===`center`&&(e-=t/2),e}function ac(e,t,n){return n===90||n===270?e-=t/2:(n>270||n<90)&&(e-=t),e}function oc(e,t,n){let{left:r,top:i,right:a,bottom:o}=n,{backdropColor:s}=t;if(!N(s)){let n=cr(t.borderRadius),c=J(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(),tr(e,{x:l,y:u,w:d,h:f,radius:n}),e.fill()):e.fillRect(l,u,d,f)}}function sc(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));oc(n,a,t);let o=Y(a.font),{x:s,y:c,textAlign:l}=t;er(n,e._pointLabels[i],s,c+o.lineHeight/2,o,{color:a.color,textAlign:l,textBaseline:`middle`})}}function cc(e,t,n,r){let{ctx:i}=e;if(n)i.arc(e.xCenter,e.yCenter,t,0,H);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 lc(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(),cc(e,n,o,r),a.closePath(),a.stroke(),a.restore())}function uc(e,t,n){return dr(e,{label:n,index:t,type:`pointLabel`})}(class extends Vs{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:Fn.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=J(Ys(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=I(e)&&!isNaN(e)?e:0,this.max=I(t)&&!isNaN(t)?t:0,this.handleTickRangeOptions()}computeTickLimit(){return Math.ceil(this.drawingArea/Ys(this.options))}generateTickLabels(e){Vs.prototype.generateTickLabels.call(this,e),this._pointLabels=this.getLabels().map((e,t)=>{let n=z(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?Qs(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=H/(this._pointLabels.length||1),n=this.options.startAngle||0;return W(e*t+Zt(n))}getDistanceFromCenterForValue(e){if(N(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(N(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 uc(this.getContext(),e,n)}}getPointPosition(e,t,n=0){let r=this.getIndexAngle(e)-U+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(),cc(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&&sc(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);lc(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=Y(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=J(s.backdropPadding);e.fillRect(-a/2-t.left,-i-c.size/2-t.top,a+t.width,c.size+t.height)}er(e,r.label,0,-i,c,{color:s.color,strokeColor:s.textStrokeColor,strokeWidth:s.textStrokeWidth})}),e.restore()}drawTitle(){}});var dc={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(dc);function fc(e,t){return e-t}function pc(e,t){if(N(t))return null;let n=e._adapter,{parser:r,round:i,isoWeekday:a}=e._parseOpts,o=t;return typeof r==`function`&&(o=r(o)),I(o)||(o=typeof r==`string`?n.parse(o,r):n.parse(o)),o===null?null:(i&&(o=i===`week`&&(Jt(a)||a===!0)?n.startOf(o,`isoWeek`,a):n.startOf(o,i)),+o)}function mc(e,t,n,r){let i=$.length;for(let a=$.indexOf(e);a<i-1;++a){let e=dc[$[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 hc(e,t,n,r,i){for(let a=$.length-1;a>=$.indexOf(n);a--){let n=$[a];if(dc[n].common&&e._adapter.diff(i,r,n)>=t-1)return n}return $[n?$.indexOf(n):0]}function gc(e){for(let t=$.indexOf(e)+1,n=$.length;t<n;++t)if(dc[$[t]].common)return $[t]}function _c(e,t,n){if(!n)e[t]=!0;else if(n.length){let{lo:r,hi:i}=on(n,t),a=n[r]>=t?n[r]:n[i];e[a]=!0}}function vc(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 yc(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:vc(e,r,i,n)}var bc=class extends so{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 Gi._date(e.adapters.date);r.init(t),Dt(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:pc(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=I(r)&&!isNaN(r)?r:+t.startOf(Date.now(),n),i=I(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=ln(r,i,a);return this._unit=t.unit||(n.autoSkip?mc(t.minUnit,this.min,this.max,this._getLabelCapacity(i)):hc(this,o.length,t.minUnit,this.min,this.max)),this._majorUnit=!n.major.enabled||this._unit===`year`?void 0:gc(this._unit),this.initOffsets(r),e.reverse&&o.reverse(),yc(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=G(t,0,a),n=G(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||mc(i.minUnit,t,n,this._getLabelCapacity(t)),o=R(r.ticks.stepSize,1),s=a===`week`&&i.isoWeekday,c=Jt(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++)_c(l,d,p);return(d===n||r.bounds===`ticks`||f===1)&&_c(l,d,p),Object.keys(l).sort(fc).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 z(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=Zt(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,yc(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(pc(this,r[t]));return this._cache.labels=this._normalized?e:this.normalize(e)}normalize(e){return pn(e.sort(fc))}};function xc(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}=sn(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}=sn(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 bc{static id=`timeseries`;static defaults=bc.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=xc(t,this.min),this._tableRange=xc(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(xc(this._table,e)-this._minPos)/this._tableRange}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return xc(this._table,n*this._tableRange+this._minPos,!0)}});var Sc={data:{type:Object,required:!0},options:{type:Object,default:()=>({})},plugins:{type:Array,default:()=>[]},datasetIdKey:{type:String,default:`label`},updateMode:{type:String,default:void 0}},Cc={ariaLabel:{type:String},ariaDescribedby:{type:String}},wc={type:{type:String,required:!0},destroyDelay:{type:Number,default:0},...Sc,...Cc},Tc=(e,t)=>Object.assign(e,t);function Ec(e){return Ce(e)?O(e):e}function Dc(e){let t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:e;return Ce(t)?new Proxy(e,{}):e}function Oc(e,t){let n=e.options;n&&t&&Object.assign(n,t)}function kc(e,t){e.labels=t}function Ac(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 jc(e,t){let n={labels:[],datasets:[]};return kc(n,e.labels),Ac(n,e.datasets,t),n}var Mc=b({props:wc,setup(t,n){let{expose:r,slots:i}=n,a=ye(null),o=ce(null);r({chart:o});let c=()=>{if(!a.value)return;let{type:e,data:n,options:r,plugins:i,datasetIdKey:s}=t,c=Dc(jc(n,s),n);o.value=new Yo(a.value,{type:e,data:c,options:{...r},plugins:i})},l=()=>{let e=O(o.value);e&&(t.destroyDelay>0?setTimeout(()=>{e.destroy(),o.value=null},t.destroyDelay):(e.destroy(),o.value=null))},d=e=>{e.update(t.updateMode)};return _e(c),u(l),e([()=>t.options,()=>t.data],(e,n)=>{let[r,i]=e,[a,c]=n,l=O(o.value);if(!l)return;let u=!1;if(r){let e=Ec(r),t=Ec(a);e&&e!==t&&(Oc(l,e),u=!0)}if(i){let e=Ec(i.labels),n=Ec(c.labels),r=Ec(i.datasets),a=Ec(c.datasets);e!==n&&(kc(l.config.data,e),u=!0),r&&r!==a&&(Ac(l.config.data,r,t.datasetIdKey),u=!0)}u&&s(()=>{d(l)})},{deep:!0}),()=>S(`canvas`,{role:`img`,"aria-label":t.ariaLabel,"aria-describedby":t.ariaDescribedby,ref:a},[S(`p`,{},[i.default?i.default():``])])}});function Nc(t,n){return Yo.register(n),b({props:Sc,setup(n,r){let{expose:i}=r,a=ce(null),o=ce(null);e(()=>o.value?.chart??null,e=>{a.value=e},{flush:`sync`}),i({chart:a});let s=e=>{o.value=e};return()=>S(Mc,Tc({ref:s},{type:t,...n}))}})}var Pc=Nc(`bar`,Ui);Yo.register(Ui,os,Rs,Hs,hs,Ns);function Fc(){let e=ye(``),t=ye(``),n=ye(``);function r(){let r=getComputedStyle(document.documentElement);e.value=r.getPropertyValue(`--foreground`).trim(),t.value=r.getPropertyValue(`--muted-foreground`).trim(),n.value=r.getPropertyValue(`--border`).trim()}let i;return _e(()=>{r(),i=window.matchMedia(`(prefers-color-scheme: dark)`),i.addEventListener(`change`,r)}),d(()=>{i?.removeEventListener(`change`,r)}),{foreground:e,mutedForeground:t,border:n}}var Ic={key:0,class:`py-8 text-center text-sm text-muted-foreground`},Lc=b({__name:`ModelUsageChart`,props:{metric:{},models:{}},setup(e){let t=e,{foreground:r,mutedForeground:i,border:a}=Fc(),o={req:`--chart-requests`,tokin:`--chart-tokens-in`,tokout:`--chart-tokens-out`,cost:`--chart-cost`};function s(e,t){return e===`cost`?t/1e6:t}function u(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let d=l(()=>(r.value,{labels:t.models.map(e=>e.id),datasets:[{label:we[t.metric],backgroundColor:u(o[t.metric]),data:t.models.map(e=>s(t.metric,e.value))}]})),f=l(()=>`${Math.max(180,t.models.length*28+60)}px`),p=l(()=>({indexAxis:`y`,responsive:!0,maintainAspectRatio:!1,animation:!1,scales:{x:{beginAtZero:!0,grid:{color:a.value},ticks:{color:i.value,callback:e=>t.metric===`cost`?E(Number(e)*1e6):ae(Number(e))}},y:{grid:{display:!1},ticks:{color:i.value,autoSkip:!1}}},plugins:{legend:{display:!1},tooltip:{callbacks:{label:e=>{let n=e.parsed.x??0;return t.metric===`cost`?`${we[t.metric]}: $${n.toFixed(4)}`:`${we[t.metric]}: ${ae(n)} (${Te(n)})`}}}}}));return(t,r)=>e.models.length===0?(w(),n(`p`,Ic,` No model recorded any usage in this window. `)):(w(),n(`div`,{key:1,class:`w-full`,style:xe({height:f.value})},[c(A(Pc),{data:d.value,options:p.value},null,8,[`data`,`options`])],4))}}),Rc={class:`h-72 w-full`},zc=b({__name:`UsageChart`,props:{tab:{},window:{},seriesByMetric:{}},setup(e){let t=e,{foreground:r,mutedForeground:i,border:a}=Fc(),o={requests:[{metric:`req`,label:`Requests`,color:`--chart-requests`}],tokens:[{metric:`tokin`,label:`Tokens in`,color:`--chart-tokens-in`},{metric:`tokout`,label:`Tokens out`,color:`--chart-tokens-out`}],cost:[{metric:`cost`,label:`Cost (USD)`,color:`--chart-cost`}]};function s(e,t){return e===`cost`?t/1e6:t}let u=l(()=>{let e=o[t.tab],n=new Set;for(let r of e)for(let e of t.seriesByMetric[r.metric]??[])n.add(e.bucket);return Array.from(n).sort()}),d=l(()=>u.value.map(e=>oe(e,t.window)));function f(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let p=l(()=>{r.value;let e=u.value;return{labels:d.value,datasets:o[t.tab].map(n=>{let r=new Map((t.seriesByMetric[n.metric]??[]).map(e=>[e.bucket,e.value]));return{label:n.label,backgroundColor:f(n.color),data:e.map(e=>s(n.metric,r.get(e)??0))}})}}),m=l(()=>o[t.tab].length>1),h=l(()=>({responsive:!0,maintainAspectRatio:!1,animation:!1,scales:{x:{stacked:m.value,grid:{color:a.value,display:!1},ticks:{color:i.value}},y:{stacked:m.value,beginAtZero:!0,grid:{color:a.value},ticks:{color:i.value,callback:e=>t.tab===`cost`?E(Number(e)*1e6):ae(Number(e))}}},plugins:{legend:{display:m.value,labels:{color:r.value}},tooltip:{callbacks:{label:e=>{let n=e.parsed.y??0;return t.tab===`cost`?`${e.dataset.label}: $${n.toFixed(4)}`:`${e.dataset.label}: ${ae(n)} (${Te(n)})`}}}}}));return(e,t)=>(w(),n(`div`,Rc,[c(A(Pc),{data:p.value,options:h.value},null,8,[`data`,`options`])]))}});function Bc(e,t){return t?e.filter(e=>e.id.startsWith(t)):e}function Vc(){return{id:`model`,header:`Model`,accessorFn:e=>e.id,cell:({row:e})=>S(`span`,{class:`inline-flex flex-wrap items-center gap-1.5`},[S(fe,{id:e.original.id}),S(de,{label:e.original.id,scope:`model:${e.original.id}`})])}}function Hc(e,t,n){return{id:e,header:t,accessorFn:e=>n(e)??0,meta:{align:`right`},cell:({row:e})=>S(te,{value:n(e.original)??0})}}function Uc(){return{id:`cost`,header:`Cost`,accessorFn:e=>e.costMicroUsd??0,meta:{align:`right`},cell:({row:e})=>{let t=e.original;return t.free&&(t.costMicroUsd??0)===0?S(Oe,{as:`span`,variant:`secondary`,class:`font-normal`,title:`priced at $0 per token`},()=>`free`):E(t.costMicroUsd??0)}}}function Wc(){return[Vc(),Hc(`requests`,`Requests`,e=>e.requests),Hc(`tokensIn`,`Tokens in`,e=>e.tokensIn),Hc(`tokensOut`,`Tokens out`,e=>e.tokensOut),Uc()]}var Gc={class:`flex flex-wrap items-center gap-3`},Kc={key:0,class:`text-sm text-destructive`},qc={key:1,class:`text-sm text-muted-foreground`},Jc={class:`text-sm text-muted-foreground`},Yc={key:0,class:`flex items-center gap-1.5 text-sm`},Xc={class:`font-mono text-xs`},Zc={key:1,class:`text-xs text-muted-foreground`},Qc={class:`flex justify-end`},$c=b({__name:`ChartsView`,setup(s){let d=h(),b=ge(),{query:S,normalized:E,hasQuery:O}=ee(),te=l(()=>{let e=d.usage?.users??[],t=d.usage?.groups??[],n=e.filter(e=>!O.value||pe(e,E.value)||`user:${e.id}`===b.scope).map(e=>({value:`user:${e.id}`,label:e.id})),r=t.filter(t=>!O.value||Se(t,e,E.value)||`group:${t.id}`===b.scope).map(e=>({value:`group:${e.id}`,label:e.id})),i=(b.modelOptions??[]).filter(e=>!O.value||e.id.toLowerCase().includes(E.value)||`model:${e.id}`===b.scope).map(e=>({value:`model:${e.id}`,label:e.id}));return b.scope.startsWith(`model:`)&&!i.some(e=>e.value===b.scope)&&i.push({value:b.scope,label:b.scope.slice(6)}),[{value:`total`,label:`Total (all traffic)`},...r,...n,...i]}),ae=[`hour`,`day`,`month`],oe=[`cost`,`req`,`tokin`,`tokout`],ce=Wc(),de=l(()=>Bc(b.modelRanking,b.modelFilter));function fe(){return ve(de.value,re[b.window],ie[b.window])}function ye(){b.setModelFilter(``)}let xe=l(()=>b.tab===`models`?`requests`:b.tab);function Ce(e){b.setTab(e)}function Te(e){typeof e==`string`&&b.setScope(e)}function Oe(e){typeof e==`string`&&b.setModelMetric(e)}return _e(()=>{b.fetchModelOptions(),b.startAutoRefresh()}),u(()=>{b.stopAutoRefresh()}),e(te,e=>{e.some(e=>e.value===b.scope)||b.setScope(`total`)}),(e,s)=>{let l=T(`FontAwesomeIcon`);return w(),_(A(p),null,{default:k(()=>[c(A(t),{class:`flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between`},{default:k(()=>[c(A(ue),null,{default:k(()=>[...s[2]||=[x(`Usage charts`,-1)]]),_:1}),f(`div`,Gc,[A(b).tab===`models`?ke(``,!0):(w(),_(a,{key:0,modelValue:A(S),"onUpdate:modelValue":s[0]||=e=>me(S)?S.value=e:null,placeholder:`Filter users, groups or models`,class:`w-56`},null,8,[`modelValue`])),A(b).tab===`models`?(w(),_(A(y),{key:1,"model-value":A(b).modelMetric,"onUpdate:modelValue":Oe},{default:k(()=>[c(A(v),{class:`w-40`,"aria-label":`Rank models by`},{default:k(()=>[c(A(De),{placeholder:`Rank by`})]),_:1}),c(A(Ee),null,{default:k(()=>[(w(),n(o,null,C(oe,e=>c(A(r),{key:e,value:e},{default:k(()=>[x(ne(A(we)[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`])):(w(),_(A(y),{key:2,"model-value":A(b).scope,"onUpdate:modelValue":Te},{default:k(()=>[c(A(v),{class:`w-56`},{default:k(()=>[c(A(De),{placeholder:`Scope`})]),_:1}),c(A(Ee),null,{default:k(()=>[(w(!0),n(o,null,C(te.value,e=>(w(),_(A(r),{key:e.value,value:e.value},{default:k(()=>[x(ne(e.label),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])),c(A(be),{"model-value":A(b).window,"onUpdate:modelValue":s[1]||=e=>A(b).setWindow(e)},{default:k(()=>[c(A(he),null,{default:k(()=>[(w(),n(o,null,C(ae,e=>c(A(D),{key:e,value:e},{default:k(()=>[x(ne(A(re)[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`])])]),_:1}),c(A(le),{class:`flex flex-col gap-4`},{default:k(()=>[c(A(be),{"model-value":A(b).tab,"onUpdate:modelValue":Ce},{default:k(()=>[c(A(he),null,{default:k(()=>[c(A(D),{value:`requests`},{default:k(()=>[...s[3]||=[x(`Requests`,-1)]]),_:1}),c(A(D),{value:`tokens`},{default:k(()=>[...s[4]||=[x(`Tokens`,-1)]]),_:1}),c(A(D),{value:`cost`},{default:k(()=>[...s[5]||=[x(`Cost`,-1)]]),_:1}),c(A(D),{value:`models`},{default:k(()=>[...s[6]||=[x(`Models`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`]),A(b).error?(w(),n(`p`,Kc,ne(A(b).error),1)):A(b).loading&&!A(b).loaded?(w(),n(`p`,qc,`Loading…`)):ke(``,!0),A(b).tab===`models`?(w(),n(o,{key:2},[f(`p`,Jc,` Models with usage over the last `+ne(A(re)[A(b).window])+`, ranked by `+ne(A(we)[A(b).modelMetric].toLowerCase())+`. Each row is the provider that served the traffic, so a model reached through more than one provider appears once per provider. `,1),A(b).modelFilter?(w(),n(`p`,Yc,[s[7]||=f(`span`,{class:`text-muted-foreground`},`Filtered to`,-1),f(`span`,Xc,ne(A(b).modelFilter),1),c(A(m),{variant:`ghost`,size:`icon-xs`,"aria-label":`Clear model filter`,onClick:ye},{default:k(()=>[c(l,{icon:A(g),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`])]),_:1})])):ke(``,!0),A(b).modelRanking.length===A(20)?(w(),n(`p`,Zc,` Top `+ne(A(20))+` models `,1)):ke(``,!0),c(Lc,{metric:A(b).modelMetric,models:de.value},null,8,[`metric`,`models`]),de.value.length?(w(),_(i,{key:2,columns:A(ce),data:de.value,"empty-message":`No model recorded any usage in this window.`},null,8,[`columns`,`data`])):ke(``,!0),f(`div`,Qc,[c(se,{filename:`usage-models-${A(b).window}.csv`,build:fe},null,8,[`filename`])])],64)):(w(),_(zc,{key:3,tab:xe.value,window:A(b).window,"series-by-metric":A(b).seriesByMetric},null,8,[`tab`,`window`,`series-by-metric`]))]),_:1})]),_:1})}}});export{$c as default};",
+			"import{$r as e,A as t,At as n,B as r,Br as i,Cn as a,Ct as o,Et as s,F as c,Fn as l,Gr as u,Hr as d,Ir as f,Jr as p,Jt as m,Kr as h,L as g,Lt as _,M as v,Nr as y,Nt as ee,On as te,Or as ne,Ot as re,Qn as b,Qr as x,R as ie,Rn as ae,Rr as S,Sn as oe,Ur as C,Vr as w,Wr as se,Xr as ce,Xt as le,Yn as ue,Yr as de,Zr as fe,ai as T,ci as pe,dn as me,dt as he,ei as E,ft as ge,gt as _e,hn as ve,ii as D,jn as O,jr as ye,jt as be,k,ni as A,oi as xe,pi as Se,qr as Ce,qt as j,ri as we,rr as Te,si as M,ti as Ee,vn as De,vt as Oe,w as ke,wn as N,z as P,zr as Ae,zt as F}from"./nav-Dzb0OTN_.js";var je=void 0,Me=typeof window<`u`&&window.trustedTypes;if(Me)try{je=Me.createPolicy(`vue`,{createHTML:e=>e})}catch{}var Ne=je?e=>je.createHTML(e):e=>e,Pe=`http://www.w3.org/2000/svg`,Fe=`http://www.w3.org/1998/Math/MathML`,I=typeof document<`u`?document:null,Ie=I&&I.createElement(`template`),Le={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`?I.createElementNS(Pe,e):t===`mathml`?I.createElementNS(Fe,e):n?I.createElement(e,{is:n}):I.createElement(e);return e===`select`&&r&&r.multiple!=null&&i.setAttribute(`multiple`,r.multiple),i},createText:e=>I.createTextNode(e),createComment:e=>I.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>I.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{Ie.innerHTML=Ne(r===`svg`?`<svg>${e}</svg>`:r===`mathml`?`<math>${e}</math>`:e);let i=Ie.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]}},L=`transition`,R=`animation`,z=Symbol(`_vtc`),Re={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},ze=C({},ge,Re),Be=(e=>(e.displayName=`Transition`,e.props=ze,e))((e,{slots:t})=>le(he,He(e),t)),B=(e,t=[])=>{p(e)?e.forEach(e=>e(...t)):e&&e(...t)},Ve=e=>e?p(e)?e.some(e=>e.length>1):e.length>1:!1;function He(e){let t={};for(let n in e)n in Re||(t[n]=e[n]);if(e.css===!1)return t;let{name:n=`v`,type:r,duration:i,enterFromClass:a=`${n}-enter-from`,enterActiveClass:o=`${n}-enter-active`,enterToClass:s=`${n}-enter-to`,appearFromClass:c=a,appearActiveClass:l=o,appearToClass:u=s,leaveFromClass:d=`${n}-leave-from`,leaveActiveClass:f=`${n}-leave-active`,leaveToClass:p=`${n}-leave-to`}=e,m=Ue(i),h=m&&m[0],g=m&&m[1],{onBeforeEnter:_,onEnter:v,onEnterCancelled:y,onLeave:ee,onLeaveCancelled:te,onBeforeAppear:ne=_,onAppear:re=v,onAppearCancelled:b=y}=t,x=(e,t,n,r)=>{e._enterCancelled=r,H(e,t?u:s),H(e,t?l:o),n&&n()},ie=(e,t)=>{e._isLeaving=!1,H(e,d),H(e,p),H(e,f),t&&t()},ae=e=>(t,n)=>{let i=e?re:v,o=()=>x(t,e,n);B(i,[t,o]),Ge(()=>{H(t,e?c:a),V(t,e?u:s),Ve(i)||qe(t,r,h,o)})};return C(t,{onBeforeEnter(e){B(_,[e]),V(e,a),V(e,o)},onBeforeAppear(e){B(ne,[e]),V(e,c),V(e,l)},onEnter:ae(!1),onAppear:ae(!0),onLeave(e,t){e._isLeaving=!0;let n=()=>ie(e,t);V(e,d),e._enterCancelled?(V(e,f),Ze(e)):(Ze(e),V(e,f)),Ge(()=>{e._isLeaving&&(H(e,d),V(e,p),Ve(ee)||qe(e,r,g,n))}),B(ee,[e,n])},onEnterCancelled(e){x(e,!1,void 0,!0),B(y,[e])},onAppearCancelled(e){x(e,!0,void 0,!0),B(b,[e])},onLeaveCancelled(e){ie(e),B(te,[e])}})}function Ue(e){if(e==null)return null;if(fe(e))return[We(e.enter),We(e.leave)];{let t=We(e);return[t,t]}}function We(e){return Se(e)}function V(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.add(t)),(e[z]||(e[z]=new Set)).add(t)}function H(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.remove(t));let n=e[z];n&&(n.delete(t),n.size||(e[z]=void 0))}function Ge(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}var Ke=0;function qe(e,t,n,r){let i=e._endId=++Ke,a=()=>{i===e._endId&&r()};if(n!=null)return setTimeout(a,n);let{type:o,timeout:s,propCount:c}=Je(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 Je(e,t){let n=window.getComputedStyle(e),r=e=>(n[e]||``).split(`, `),i=r(`${L}Delay`),a=r(`${L}Duration`),o=Ye(i,a),s=r(`${R}Delay`),c=r(`${R}Duration`),l=Ye(s,c),u=null,d=0,f=0;t===L?o>0&&(u=L,d=o,f=a.length):t===R?l>0&&(u=R,d=l,f=c.length):(d=Math.max(o,l),u=d>0?o>l?L:R:null,f=u?u===L?a.length:c.length:0);let p=u===L&&/\b(?:transform|all)(?:,|$)/.test(r(`${L}Property`).toString());return{type:u,timeout:d,propCount:f,hasTransform:p}}function Ye(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max(...t.map((t,n)=>Xe(t)+Xe(e[n])))}function Xe(e){return e===`auto`?0:Number(e.slice(0,-1).replace(`,`,`.`))*1e3}function Ze(e){return(e?e.ownerDocument:document).body.offsetHeight}function Qe(e,t,n){let r=e[z];r&&(t=(t?[t,...r]:[...r]).join(` `)),t==null?e.removeAttribute(`class`):n?e.setAttribute(`class`,t):e.className=t}var U=Symbol(`_vod`),$e=Symbol(`_vsh`),et={name:`show`,beforeMount(e,{value:t},{transition:n}){e[U]=e.style.display===`none`?``:e.style.display,n&&t?n.beforeEnter(e):W(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),W(e,!0),r.enter(e)):r.leave(e,()=>{W(e,!1)}):W(e,t))},beforeUnmount(e,{value:t}){W(e,t)}};function W(e,t){e.style.display=t?e[U]:`none`,e[$e]=!t}function tt(){et.getSSRProps=({value:e})=>{if(!e)return{style:{display:`none`}}}}var nt=Symbol(``);function rt(e){let t=j();if(!t)return;let n=t.ut=(n=e(t.proxy))=>{Array.from(document.querySelectorAll(`[data-v-owner="${t.uid}"]`)).forEach(e=>G(e,n))},r=()=>{let r=e(t.proxy);t.ce?G(t.ce,r):it(t.subTree,r),n(r)};ve(()=>{te(r)}),De(()=>{b(r,i,{flush:`post`});let e=new MutationObserver(r);e.observe(t.subTree.el.parentNode,{childList:!0}),oe(()=>e.disconnect())})}function it(e,t){if(e.shapeFlag&128){let n=e.suspense;e=n.activeBranch,n.pendingBranch&&!n.isHydrating&&n.effects.push(()=>{it(n.activeBranch,t)})}for(;e.component;)e=e.component.subTree;if(e.shapeFlag&1&&e.el)G(e.el,t);else if(e.type===_e)e.children.forEach(e=>it(e,t));else if(e.type===Oe){let{el:n,anchor:r}=e;for(;n&&(G(n,t),n!==r);)n=n.nextSibling}}function G(e,t){if(e.nodeType===1){let n=e.style,r=``;for(let e in t){let i=pe(t[e]);n.setProperty(`--${e}`,i),r+=`--${e}: ${i};`}n[nt]=r}}var at=/(?:^|;)\s*display\s*:/;function ot(e,t,n){let r=e.style,i=A(n),a=!1;if(n&&!i){if(t){if(A(t))for(let e of t.split(`;`)){let t=e.slice(0,e.indexOf(`:`)).trim();n[t]??K(r,t,``)}else for(let e in t)n[e]??K(r,e,``)}for(let i in n){i===`display`&&(a=!0);let o=n[i];o==null?K(r,i,``):dt(e,i,!A(t)&&t?t[i]:void 0,o)||K(r,i,o)}}else if(i){if(t!==n){let e=r[nt];e&&(n+=`;`+e),r.cssText=n,a=at.test(n)}}else t&&e.removeAttribute(`style`);U in e&&(e[U]=a?r.display:``,e[$e]&&(r.display=`none`))}var st=/\s*!important$/;function K(e,t,n){if(p(n))n.forEach(n=>K(e,t,n));else if(n??=``,t.startsWith(`--`))e.setProperty(t,n);else{let r=ut(e,t);st.test(n)?e.setProperty(u(r),n.replace(st,``),`important`):e[r]=n}}var ct=[`Webkit`,`Moz`,`ms`],lt={};function ut(e,t){let n=lt[t];if(n)return n;let r=w(t);if(r!==`filter`&&r in e)return lt[t]=r;r=d(r);for(let n=0;n<ct.length;n++){let i=ct[n]+r;if(i in e)return lt[t]=i}return t}function dt(e,t,n,r){return e.tagName===`TEXTAREA`&&(t===`width`||t===`height`)&&A(r)&&n===r}var ft=`http://www.w3.org/1999/xlink`;function pt(e,t,n,r,i,a=Ee(t)){r&&t.startsWith(`xlink:`)?n==null?e.removeAttributeNS(ft,t.slice(6,t.length)):e.setAttributeNS(ft,t,n):n==null||a&&!h(n)?e.removeAttribute(t):e.setAttribute(t,a?``:we(n)?String(n):n)}function mt(e,t,n,r,i){if(t===`innerHTML`||t===`textContent`){n!=null&&(e[t]=t===`innerHTML`?Ne(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=h(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 q(e,t,n,r){e.addEventListener(t,n,r)}function ht(e,t,n,r){e.removeEventListener(t,n,r)}var gt=Symbol(`_vei`);function _t(e,t,n,r,i=null){let a=e[gt]||(e[gt]={}),o=a[t];if(r&&o)o.value=r;else{let[n,s]=bt(t);r?q(e,n,a[t]=wt(r,i),s):o&&(ht(e,n,o,s),a[t]=void 0)}}var vt=/(Once|Passive|Capture)$/,yt=/^on:?(?:Once|Passive|Capture)$/;function bt(e){let t,n;for(;(n=e.match(vt))&&!yt.test(e);)t||={},e=e.slice(0,e.length-n[1].length),t[n[1].toLowerCase()]=!0;return[e[2]===`:`?e.slice(3):u(e.slice(2)),t]}var xt=0,St=Promise.resolve(),Ct=()=>xt||=(St.then(()=>xt=0),Date.now());function wt(e,t){let n=e=>{if(!e._vts)e._vts=Date.now();else if(e._vts<=n.attached)return;let r=n.value;if(p(r)){let n=e.stopImmediatePropagation;e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0};let i=r.slice(),a=[e];for(let n=0;n<i.length&&!e._stopped;n++){let e=i[n];e&&o(e,t,5,a)}}else o(r,t,5,[e])};return n.value=e,n.attached=Ct(),n}var Tt=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,Et=(e,t,n,r,i,a)=>{let o=i===`svg`;t===`class`?Qe(e,r,o):t===`style`?ot(e,n,r):x(t)?ce(t)||_t(e,t,n,r,a):(t[0]===`.`?(t=t.slice(1),!0):t[0]===`^`?(t=t.slice(1),!1):Dt(e,t,r,o))?(mt(e,t,r),!e.tagName.includes(`-`)&&(t===`value`||t===`checked`||t===`selected`)&&pt(e,t,r,o,a,t!==`value`)):e._isVueCE&&(Ot(e,t)||e._def.__asyncLoader&&(/[A-Z]/.test(t)||!A(r)))?mt(e,w(t),r,a,t):(t===`true-value`?e._trueValue=r:t===`false-value`&&(e._falseValue=r),pt(e,t,r,o))};function Dt(e,t,n,r){if(r)return!!(t===`innerHTML`||t===`textContent`||t in e&&Tt(t)&&de(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 Tt(t)&&A(n)?!1:t in e}function Ot(e,t){let n=e._def.props;if(!n)return!1;let r=w(t);return Array.isArray(n)?n.some(e=>w(e)===r):Object.keys(n).some(e=>w(e)===r)}var kt={};function At(t,n,r){let i=F(t,n);e(i)&&(i=C({},i,n));class a extends Nt{constructor(e){super(i,e,r)}}return a.def=i,a}var jt=((e,t)=>At(e,t,yn)),Mt=typeof HTMLElement<`u`?HTMLElement:class{},Nt=class t extends Mt{constructor(e,t={},n=vn){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!==vn?this._root=this.shadowRoot:e.shadowRoot===!1?this._root=this:(this.attachShadow(C({},e.shadowRootOptions,{mode:`open`})),this._root=this.shadowRoot)}connectedCallback(){if(!this.isConnected)return;!this.shadowRoot&&!this._resolved&&this._parseSlots(),this._connected=!0;let e=this;for(;e&&=e.assignedSlot||e.parentNode||e.host;)if(e instanceof t){this._parent=e;break}this._instance||(this._resolved?this._mount(this._def):e&&e._pendingResolve?this._pendingResolve=e._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,me(()=>{this._connected||(this._ob&&=(this._ob.disconnect(),null),this._app&&this._app.unmount(),this._instance&&(this._instance.ce=void 0),this._app=this._instance=null,this._teleportTargets&&=(this._teleportTargets.clear(),void 0))})}_processMutations(e){for(let t of e)this._setAttr(t.attributeName)}_resolveDef(){if(this._pendingResolve)return this._pendingResolve;for(let e=0;e<this.attributes.length;e++)this._setAttr(this.attributes[e].name);this._ob=new MutationObserver(this._processMutations.bind(this)),this._ob.observe(this,{attributes:!0});let e=(e,t=!1)=>{this._resolved=!0,this._pendingResolve=void 0;let{props:n,styles:r}=e,i;if(n&&!p(n))for(let e in n){let t=n[e];(t===Number||t&&t.type===Number)&&(e in this._props&&(this._props[e]=Se(this._props[e])),(i||=Object.create(null))[w(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)se(this,e)||Object.defineProperty(this,e,{get:()=>S(t[e])})}_resolveProps(e){let{props:t}=e,n=p(t)?t:Object.keys(t||{});for(let e of Object.keys(this))e[0]!==`_`&&n.includes(e)&&this._setProp(e,this[e]);for(let e of n.map(w))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):kt,r=w(e);t&&this._numberProps&&this._numberProps[r]&&(n=Se(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===kt?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(u(e),``):typeof t==`string`||typeof t==`number`?this.setAttribute(u(e),t+``):t||this.removeAttribute(u(e)),n&&n.observe(this,{attributes:!0})}}_update(){let e=this._createVNode();this._app&&(e.appContext=this._app._context),gn(e,this._root)}_createVNode(){let t={};this.shadowRoot||(t.onVnodeMounted=t.onVnodeUpdated=this._renderSlots.bind(this));let n=_(this._def,C(t,this._props));return this._instance||(n.ce=t=>{this._instance=t,t.ce=this,t.isCE=!0;let n=(t,n)=>{this.dispatchEvent(new CustomEvent(t,e(n[0])?C({detail:n},n[0]):{detail:n}))};t.emit=(e,...t)=>{n(e,t),u(e)!==e&&n(u(e),t)},this._setParent()}),n}_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 Pt(e){let t=j();return t&&t.ce||null}function Ft(){let e=Pt();return e&&e.shadowRoot}function It(e=`$style`){{let t=j();if(!t)return Ae;let n=t.type.__cssModules;return n&&n[e]||Ae}}var Lt=new WeakMap,Rt=new WeakMap,J=Symbol(`_moveCb`),zt=Symbol(`_enterCb`),Bt=(e=>(delete e.props.mode,e))({name:`TransitionGroup`,props:C({},ze,{tag:String,moveClass:String}),setup(e,{slots:t}){let n=j(),r=ue(),i,o;return a(()=>{if(!i.length)return;let t=e.moveClass||`${e.name||`v`}-move`;if(!Gt(i[0].el,n.vnode.el,t)){i=[];return}i.forEach(Vt),i.forEach(Ht);let r=i.filter(Ut);Ze(n.vnode.el),r.forEach(e=>{let n=e.el,r=n.style;V(n,t),r.transform=r.webkitTransform=r.transitionDuration=``;let i=n[J]=e=>{e&&e.target!==n||(!e||e.propertyName.endsWith(`transform`))&&(n.removeEventListener(`transitionend`,i),n[J]=null,H(n,t))};n.addEventListener(`transitionend`,i)}),i=[]}),()=>{let a=y(e),s=He(a),c=a.tag||_e;if(i=[],o)for(let e=0;e<o.length;e++){let t=o[e];t.el&&t.el instanceof Element&&!t.el[$e]&&(i.push(t),ae(t,l(t,s,r,n)),Lt.set(t,Wt(t.el)))}o=t.default?m(t.default()):[];for(let e=0;e<o.length;e++){let t=o[e];t.key!=null&&ae(t,l(t,s,r,n))}return _(c,null,o)}}});function Vt(e){let t=e.el;t[J]&&t[J](),t[zt]&&t[zt]()}function Ht(e){Rt.set(e,Wt(e.el))}function Ut(e){let t=Lt.get(e),n=Rt.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 Wt(e){let t=e.getBoundingClientRect();return{left:t.left,top:t.top}}function Gt(e,t,n){let r=e.cloneNode(),i=e[z];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}=Je(r);return a.removeChild(r),o}var Y=e=>{let t=e.props[`onUpdate:modelValue`]||!1;return p(t)?e=>Ce(t,e):t};function Kt(e){e.target.composing=!0}function qt(e){let t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event(`input`)))}var X=Symbol(`_assign`),Z=Symbol(`_initialValue`);function Jt(e,t,n){return t&&(e=e.trim()),n&&(e=xe(e)),e}var Q={created(e,{modifiers:{lazy:t,trim:n,number:r}},i){e.parentNode&&(e.type===`text`?e[Z]=e.defaultValue.replace(/[\r\n]/g,``):e.type===`textarea`&&(e[Z]=e.defaultValue.replace(/\r\n?/g,`
`))),e[X]=Y(i);let a=r||i.props&&i.props.type===`number`;q(e,t?`change`:`input`,t=>{t.target.composing||e[X](Jt(e.value,n,a))}),(n||a)&&q(e,`change`,()=>{e.value=Jt(e.value,n,a)}),t||(q(e,`compositionstart`,Kt),q(e,`compositionend`,qt),q(e,`change`,qt))},mounted(e,{value:t,modifiers:{trim:n,number:r}}){let i=t??``,a=e[Z];delete e[Z],a!==void 0&&(e.type===`text`||e.type===`textarea`)&&e.value!==a?e[X](Jt(e.value,n,r)):e.value=i},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:r,trim:i,number:a}},o){if(e[X]=Y(o),e.composing)return;let s=(a||e.type===`number`)&&!/^0\d/.test(e.value)?xe(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)}},Yt={deep:!0,created(e,t,n){e[X]=Y(n),q(e,`change`,()=>{let t=e._modelValue,n=$(e),r=e.checked,i=e[X];if(p(t)){let e=T(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(E(t)){let e=new Set(t);r?e.add(n):e.delete(n),i(e)}else i(en(e,r))})},mounted:Xt,beforeUpdate(e,t,n){e[X]=Y(n),Xt(e,t,n)}};function Xt(e,{value:t,oldValue:n},r){e._modelValue=t;let i;if(p(t))i=T(t,r.props.value)>-1;else if(E(t))i=t.has(r.props.value);else{if(t===n)return;i=D(t,en(e,!0))}e.checked!==i&&(e.checked=i)}var Zt={created(e,{value:t},n){e.checked=D(t,n.props.value),e[X]=Y(n),q(e,`change`,()=>{e[X]($(e))})},beforeUpdate(e,{value:t,oldValue:n},r){e[X]=Y(r),t!==n&&(e.checked=D(t,r.props.value))}},Qt={deep:!0,created(e,{value:t,modifiers:{number:n}},r){e._modelValue=t,q(e,`change`,()=>{let t=Array.prototype.filter.call(e.options,e=>e.selected).map(e=>n?xe($(e)):$(e));e[X](e.multiple?E(e._modelValue)?new Set(t):t:t[0]),e._assigning=!0,me(()=>{e._assigning=!1})}),e[X]=Y(r)},mounted(e,{value:t}){$t(e,t)},beforeUpdate(e,{value:t},n){e._modelValue=t,e[X]=Y(n)},updated(e,{value:t}){e._assigning||$t(e,t)}};function $t(e,t){let n=e.multiple,r=p(t);if(!(n&&!r&&!E(t))){for(let i=0,a=e.options.length;i<a;i++){let a=e.options[i],o=$(a);if(n){if(r){let e=typeof o;a.selected=e===`string`||e===`number`?t.some(e=>String(e)===String(o)):T(t,o)>-1}else a.selected=t.has(o)}else if(D($(a),t)){e.selectedIndex!==i&&(e.selectedIndex=i);return}}!n&&e.selectedIndex!==-1&&(e.selectedIndex=-1)}}function $(e){return`_value`in e?e._value:e.value}function en(e,t){let n=t?`_trueValue`:`_falseValue`;return n in e?e[n]:t}var tn={created(e,t,n){rn(e,t,n,null,`created`)},mounted(e,t,n){rn(e,t,n,null,`mounted`)},beforeUpdate(e,t,n,r){rn(e,t,n,r,`beforeUpdate`)},updated(e,t,n,r){rn(e,t,n,r,`updated`)}};function nn(e,t){switch(e){case`SELECT`:return Qt;case`TEXTAREA`:return Q;default:switch(t){case`checkbox`:return Yt;case`radio`:return Zt;default:return Q}}}function rn(e,t,n,r,i){let a=nn(e.tagName,n.props&&n.props.type)[i];a&&a(e,t,n,r)}function an(){Q.getSSRProps=({value:e})=>({value:e}),Zt.getSSRProps=({value:e},t)=>{if(t.props&&D(t.props.value,e))return{checked:!0}},Yt.getSSRProps=({value:e},t)=>{if(p(e)){if(t.props&&T(e,t.props.value)>-1)return{checked:!0}}else if(E(e)){if(t.props&&e.has(t.props.value))return{checked:!0}}else if(e)return{checked:!0}},tn.getSSRProps=(e,t)=>{if(typeof t.type!=`string`)return;let n=nn(t.type.toUpperCase(),t.props&&t.props.type);if(n.getSSRProps)return n.getSSRProps(e,t)}}var on=[`ctrl`,`shift`,`alt`,`meta`],sn={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)=>on.some(n=>e[`${n}Key`]&&!t.includes(n))},cn=(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=sn[t[e]];if(r&&r(n,t))return}return e(n,...r)}))},ln={esc:`escape`,space:` `,up:`arrow-up`,left:`arrow-left`,right:`arrow-right`,down:`arrow-down`,delete:`backspace`},un=(e,t)=>{let n=e._withKeys||={},r=t.join(`.`);return n[r]||(n[r]=(n=>{if(!(`key`in n))return;let r=u(n.key);if(t.some(e=>e===r||ln[e]===r))return e(n)}))},dn=C({patchProp:Et},Le),fn,pn=!1;function mn(){return fn||=ee(dn)}function hn(){return fn=pn?fn:be(dn),pn=!0,fn}var gn=((...e)=>{mn().render(...e)}),_n=((...e)=>{hn().hydrate(...e)}),vn=((...e)=>{let t=mn().createApp(...e),{mount:n}=t;return t.mount=e=>{let r=xn(e);if(!r)return;let i=t._component;!de(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent=``);let a=n(r,!1,bn(r));return r instanceof Element&&(r.removeAttribute(`v-cloak`),r.setAttribute(`data-v-app`,``)),a},t}),yn=((...e)=>{let t=hn().createApp(...e),{mount:n}=t;return t.mount=e=>{let t=xn(e);if(t)return n(t,!0,bn(t))},t});function bn(e){if(e instanceof SVGElement)return`svg`;if(typeof MathMLElement==`function`&&e instanceof MathMLElement)return`mathml`}function xn(e){return A(e)?document.querySelector(e):e}var Sn=!1,Cn=()=>{Sn||(Sn=!0,an(),tt())},wn=F({__name:`Alert`,props:{class:{type:[Boolean,null,String,Object,Array]},variant:{}},setup(e){let t=e;return(r,i)=>(N(),n(`div`,{"data-slot":`alert`,class:M(S(P)(S(En)({variant:e.variant}),t.class)),role:`alert`},[O(r.$slots,`default`)],2))}}),Tn=F({__name:`AlertDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,r)=>(N(),n(`div`,{"data-slot":`alert-description`,class:M(S(P)(`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))},[O(e.$slots,`default`)],2))}}),En=r(`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`}}),Dn=k?window:void 0;k&&window.document,k&&window.navigator,k&&window.location;function On(e){let t=f(e);return t?.$el??t}function kn(...e){let t=(e,t,n,r)=>(e.addEventListener(t,n,r),()=>e.removeEventListener(t,n,r)),n=s(()=>{let t=c(f(e[0])).filter(e=>e!=null);return t.every(e=>typeof e!=`string`)?t:void 0});return ie(()=>[n.value?.map(e=>On(e))??[Dn].filter(e=>e!=null),c(f(n.value?e[1]:e[0])),c(S(n.value?e[2]:e[1])),f(n.value?e[3]:e[2])],([e,n,r,i],a,o)=>{if(!e?.length||!n?.length||!r?.length)return;let s=v(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 An(){let e=ye(!1),t=j();return t&&De(()=>{e.value=!0},t),e}function jn(e){let t=An();return s(()=>(t.value,!!e()))}function Mn(e){return typeof e==`function`?e:typeof e==`string`?t=>t.key===e:Array.isArray(e)?t=>e.includes(t.key):()=>!0}function Nn(...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=Dn,eventName:a=`keydown`,passive:o=!1,dedupe:s=!1}=r,c=Mn(t);return kn(i,a,e=>{e.repeat&&f(s)||c(e)&&n(e)},o)}function Pn(e){return JSON.parse(JSON.stringify(e))}function Fn(e,t,n={}){let{window:r=Dn,...i}=n,a,o=jn(()=>r&&`ResizeObserver`in r),c=()=>{a&&=(a.disconnect(),void 0)},l=b(s(()=>{let t=f(e);return Array.isArray(t)?t.map(e=>On(e)):[On(t)]}),e=>{if(c(),o.value&&r){a=new ResizeObserver(t);for(let t of e)t&&a.observe(t,i)}},{immediate:!0,flush:`post`}),u=()=>{c(),l()};return g(u),{isSupported:o,stop:u}}function In(e,n,r,i={}){var a,o;let{clone:c=!1,passive:l=!1,eventName:u,deep:d=!1,defaultValue:f,shouldEmit:p}=i,m=j(),h=r||m?.emit||(m==null||(a=m.$emit)==null?void 0:a.bind(m))||(m==null||(o=m.proxy)==null||(o=o.$emit)==null?void 0:o.bind(m?.proxy)),g=u;n||=`modelValue`,g||=`update:${n.toString()}`;let _=e=>c?typeof c==`function`?c(e):Pn(e):e,v=()=>t(e[n])?_(e[n]):f,y=e=>{p?p(e)&&h(g,e):h(g,e)};if(l){let t=ne(v()),r=!1;return b(()=>e[n],e=>{r||(r=!0,t.value=_(e),me(()=>r=!1))}),b(t,t=>{!r&&(t!==e[n]||d)&&y(t)},{deep:d}),t}return s({get(){return v()},set(e){y(e)}})}var Ln=F({__name:`Button`,props:{variant:{},size:{},class:{type:[Boolean,null,String,Object,Array]},asChild:{type:Boolean},as:{default:`button`}},setup(e){let t=e;return(n,r)=>(N(),re(S(ke),{"data-slot":`button`,"data-variant":e.variant,"data-size":e.size,as:e.as,"as-child":e.asChild,class:M(S(P)(S(Rn)({variant:e.variant,size:e.size}),t.class))},{default:Te(()=>[O(n.$slots,`default`)]),_:3},8,[`data-variant`,`data-size`,`as`,`as-child`,`class`]))}}),Rn=r(`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`}}),zn=F({__name:`CardDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,r)=>(N(),n(`div`,{"data-slot":`card-description`,class:M(S(P)(`text-muted-foreground text-sm`,t.class))},[O(e.$slots,`default`)],2))}});export{Zt as A,gn as C,Ft as D,Pt as E,cn as F,Q as M,et as N,Yt as O,un as P,Et as S,rt as T,At as _,On as a,Cn as b,Fn as c,wn as d,Be as f,yn as g,vn as h,Nn as i,Qt as j,tn as k,In as l,Nt as m,Ln as n,kn as o,Bt as p,Dn as r,An as s,zn as t,Tn as u,jt as v,It as w,Le as x,_n as y};",
 		),
 	},
-	"index-2hRLhoKL.js": {
+	"ClampedRangeNotice-Bvhm1e-B.js": {
 		contentType: "text/javascript; charset=utf-8",
 		body: decodeAdminAsset(
-			"var e=Object.defineProperty,t=(t,n)=>{let r={};for(var i in t)e(r,i,{get:t[i],enumerable:!0});return n||e(r,Symbol.toStringTag,{value:`Module`}),r};function n(e){let t=Object.create(null);for(let n of e.split(`,`))t[n]=1;return e=>e in t}var r={},i=[],a=()=>{},o=()=>!1,s=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&(e.charCodeAt(2)>122||e.charCodeAt(2)<97),c=e=>e.startsWith(`onUpdate:`),l=Object.assign,u=(e,t)=>{let n=e.indexOf(t);n>-1&&e.splice(n,1)},d=Object.prototype.hasOwnProperty,f=(e,t)=>d.call(e,t),p=Array.isArray,m=e=>w(e)===`[object Map]`,h=e=>w(e)===`[object Set]`,g=e=>w(e)===`[object Date]`,_=e=>w(e)===`[object RegExp]`,v=e=>typeof e==`function`,y=e=>typeof e==`string`,b=e=>typeof e==`symbol`,x=e=>typeof e==`object`&&!!e,S=e=>(x(e)||v(e))&&v(e.then)&&v(e.catch),C=Object.prototype.toString,w=e=>C.call(e),ee=e=>w(e).slice(8,-1),te=e=>w(e)===`[object Object]`,T=e=>y(e)&&e!==`NaN`&&e[0]!==`-`&&``+parseInt(e,10)===e,ne=n(`,key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted`),re=e=>{let t=Object.create(null);return(n=>t[n]||(t[n]=e(n)))},ie=/-\w/g,E=re(e=>e.replace(ie,e=>e.slice(1).toUpperCase())),ae=/\B([A-Z])/g,oe=re(e=>e.replace(ae,`-$1`).toLowerCase()),se=re(e=>e.charAt(0).toUpperCase()+e.slice(1)),ce=re(e=>e?`on${se(e)}`:``),D=(e,t)=>!Object.is(e,t),le=(e,...t)=>{for(let n=0;n<e.length;n++)e[n](...t)},ue=(e,t,n,r=!1)=>{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:r,value:n})},de=e=>{let t=parseFloat(e);return isNaN(t)?e:t},fe=e=>{let t=y(e)?Number(e):NaN;return isNaN(t)?e:t},pe,me=()=>pe||=typeof globalThis<`u`?globalThis:typeof self<`u`?self:typeof window<`u`?window:typeof global<`u`?global:{},he=n(`Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol`);function ge(e){if(p(e)){let t={};for(let n=0;n<e.length;n++){let r=e[n],i=y(r)?be(r):ge(r);if(i)for(let e in i)t[e]=i[e]}return t}if(y(e)||x(e))return e}var _e=/;(?![^(]*\))/g,ve=/:([^]+)/,ye=/\/\*[^]*?\*\//g;function be(e){let t={};return e.replace(ye,``).split(_e).forEach(e=>{if(e){let n=e.split(ve);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}function O(e){let t=``;if(y(e))t=e;else if(p(e))for(let n=0;n<e.length;n++){let r=O(e[n]);r&&(t+=r+` `)}else if(x(e))for(let n in e)e[n]&&(t+=n+` `);return t.trim()}function xe(e){if(!e)return null;let{class:t,style:n}=e;return t&&!y(t)&&(e.class=O(t)),n&&(e.style=ge(n)),e}var Se=`itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`,Ce=n(Se);Se+``;function we(e){return!!e||e===``}function Te(e,t){if(e.length!==t.length)return!1;let n=!0;for(let r=0;n&&r<e.length;r++)n=Ee(e[r],t[r]);return n}function Ee(e,t){if(e===t)return!0;let n=g(e),r=g(t);if(n||r)return n&&r?e.getTime()===t.getTime():!1;if(n=b(e),r=b(t),n||r)return e===t;if(n=p(e),r=p(t),n||r)return n&&r?Te(e,t):!1;if(n=x(e),r=x(t),n||r){if(!n||!r||Object.keys(e).length!==Object.keys(t).length)return!1;for(let n in e){let r=e.hasOwnProperty(n),i=t.hasOwnProperty(n);if(r&&!i||!r&&i||!Ee(e[n],t[n]))return!1}}return String(e)===String(t)}function De(e,t){return e.findIndex(e=>Ee(e,t))}var Oe=e=>!!(e&&e.__v_isRef===!0),k=e=>y(e)?e:e==null?``:p(e)||x(e)&&(e.toString===C||!v(e.toString))?Oe(e)?k(e.value):JSON.stringify(e,ke,2):String(e),ke=(e,t)=>Oe(t)?ke(e,t.value):m(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((e,[t,n],r)=>(e[Ae(t,r)+` =>`]=n,e),{})}:h(t)?{[`Set(${t.size})`]:[...t.values()].map(e=>Ae(e))}:b(t)?Ae(t):x(t)&&!p(t)&&!te(t)?String(t):t,Ae=(e,t=``)=>b(e)?`Symbol(${e.description??t})`:e;function je(e){return e==null?`initial`:typeof e==`string`?e===``?` `:e:String(e)}var Me,Ne=class{constructor(e=!1){this.detached=e,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this._warnOnRun=!0,this.__v_skip=!0,!e&&Me&&(Me.active?(this.parent=Me,this.index=(Me.scopes||(Me.scopes=[])).push(this)-1):(this._active=!1,this._warnOnRun=!1))}get active(){return this._active}pause(){if(this._active){this._isPaused=!0;let e,t;if(this.scopes){let n=this.scopes.slice();for(e=0,t=n.length;e<t;e++)n[e].pause()}for(e=0,t=this.effects.length;e<t;e++)this.effects[e].pause()}}resume(){if(this._active&&this._isPaused){this._isPaused=!1;let e,t;if(this.scopes){let n=this.scopes.slice();for(e=0,t=n.length;e<t;e++)n[e].resume()}let n=this.effects.slice();for(e=0,t=n.length;e<t;e++)n[e].resume()}}run(e){if(this._active){let t=Me;try{return Me=this,e()}finally{Me=t}}}on(){++this._on===1&&(this.prevScope=Me,Me=this)}off(){if(this._on>0&&--this._on===0){if(Me===this)Me=this.prevScope;else{let e=Me;for(;e;){if(e.prevScope===this){e.prevScope=this.prevScope;break}e=e.prevScope}}this.prevScope=void 0}}stop(e){if(this._active){this._active=!1;let t,n;for(t=0,n=this.effects.length;t<n;t++)this.effects[t].stop();for(this.effects.length=0,t=0,n=this.cleanups.length;t<n;t++)this.cleanups[t]();if(this.cleanups.length=0,this.scopes){let e=this.scopes.slice();for(t=0,n=e.length;t<n;t++)e[t].stop(!0);this.scopes.length=0}if(!this.detached&&this.parent&&!e){let e=this.parent.scopes.pop();e&&e!==this&&(this.parent.scopes[this.index]=e,e.index=this.index)}this.parent=void 0}}};function Pe(e){return new Ne(e)}function Fe(){return Me}function Ie(e,t=!1){Me&&Me.cleanups.push(e)}var Le,Re=new WeakSet,ze=class{constructor(e){this.fn=e,this.deps=void 0,this.depsTail=void 0,this.flags=5,this.next=void 0,this.cleanup=void 0,this.scheduler=void 0,Me&&(Me.active?Me.effects.push(this):this.flags&=-2)}pause(){this.flags|=64}resume(){this.flags&64&&(this.flags&=-65,Re.has(this)&&(Re.delete(this),this.trigger()))}notify(){this.flags&2&&!(this.flags&32)||this.flags&8||Ue(this)}run(){if(!(this.flags&1))return this.fn();this.flags|=2,it(this),Ke(this);let e=Le,t=et;Le=this,et=!0;try{return this.fn()}finally{qe(this),Le=e,et=t,this.flags&=-3}}stop(){if(this.flags&1){for(let e=this.deps;e;e=e.nextDep)Xe(e);this.deps=this.depsTail=void 0,it(this),this.onStop&&this.onStop(),this.flags&=-2}}trigger(){this.flags&64?Re.add(this):this.scheduler?this.scheduler():this.runIfDirty()}runIfDirty(){Je(this)&&this.run()}get dirty(){return Je(this)}},Be=0,Ve,He;function Ue(e,t=!1){if(e.flags|=8,t){e.next=He,He=e;return}e.next=Ve,Ve=e}function We(){Be++}function Ge(){if(--Be>0)return;if(He){let e=He;for(He=void 0;e;){let t=e.next;e.next=void 0,e.flags&=-9,e=t}}let e;for(;Ve;){let t=Ve;for(Ve=void 0;t;){let n=t.next;if(t.next=void 0,t.flags&=-9,t.flags&1)try{t.trigger()}catch(t){e||=t}t=n}}if(e)throw e}function Ke(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function qe(e){let t,n=e.depsTail,r=n;for(;r;){let e=r.prevDep;r.version===-1?(r===n&&(n=e),Xe(r),Ze(r)):t=r,r.dep.activeLink=r.prevActiveLink,r.prevActiveLink=void 0,r=e}e.deps=t,e.depsTail=n}function Je(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(Ye(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function Ye(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===at)||(e.globalVersion=at,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!Je(e))))return;e.flags|=2;let t=e.dep,n=Le,r=et;Le=e,et=!0;try{Ke(e);let n=e.fn(e._value);(t.version===0||D(n,e._value))&&(e.flags|=128,e._value=n,t.version++)}catch(e){throw t.version++,e}finally{Le=n,et=r,qe(e),e.flags&=-3}}function Xe(e,t=!1){let{dep:n,prevSub:r,nextSub:i}=e;if(r&&(r.nextSub=i,e.prevSub=void 0),i&&(i.prevSub=r,e.nextSub=void 0),n.subs===e&&(n.subs=r,!r&&n.computed)){n.computed.flags&=-5;for(let e=n.computed.deps;e;e=e.nextDep)Xe(e,!0)}!t&&!--n.sc&&n.map&&n.map.delete(n.key)}function Ze(e){let{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}function Qe(e,t){e.effect instanceof ze&&(e=e.effect.fn);let n=new ze(e);t&&l(n,t);try{n.run()}catch(e){throw n.stop(),e}let r=n.run.bind(n);return r.effect=n,r}function $e(e){e.effect.stop()}var et=!0,tt=[];function nt(){tt.push(et),et=!1}function rt(){let e=tt.pop();et=e===void 0||e}function it(e){let{cleanup:t}=e;if(e.cleanup=void 0,t){let e=Le;Le=void 0;try{t()}finally{Le=e}}}var at=0,ot=class{constructor(e,t){this.sub=e,this.dep=t,this.version=t.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}},st=class{constructor(e){this.computed=e,this.version=0,this.activeLink=void 0,this.subs=void 0,this.map=void 0,this.key=void 0,this.sc=0,this.__v_skip=!0}track(e){if(!Le||!et||Le===this.computed)return;let t=this.activeLink;if(t===void 0||t.sub!==Le)t=this.activeLink=new ot(Le,this),Le.deps?(t.prevDep=Le.depsTail,Le.depsTail.nextDep=t,Le.depsTail=t):Le.deps=Le.depsTail=t,ct(t);else if(t.version===-1&&(t.version=this.version,t.nextDep)){let e=t.nextDep;e.prevDep=t.prevDep,t.prevDep&&(t.prevDep.nextDep=e),t.prevDep=Le.depsTail,t.nextDep=void 0,Le.depsTail.nextDep=t,Le.depsTail=t,Le.deps===t&&(Le.deps=e)}return t}trigger(e){this.version++,at++,this.notify(e)}notify(e){We();try{for(let e=this.subs;e;e=e.prevSub)e.sub.notify()&&e.sub.dep.notify()}finally{Ge()}}};function ct(e){if(e.dep.sc++,e.sub.flags&4){let t=e.dep.computed;if(t&&!e.dep.subs){t.flags|=20;for(let e=t.deps;e;e=e.nextDep)ct(e)}let n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}var lt=new WeakMap,ut=Symbol(``),dt=Symbol(``),ft=Symbol(``);function pt(e,t,n){if(et&&Le){let t=lt.get(e);t||lt.set(e,t=new Map);let r=t.get(n);r||(t.set(n,r=new st),r.map=t,r.key=n),r.track()}}function mt(e,t,n,r,i,a){let o=lt.get(e);if(!o){at++;return}let s=e=>{e&&e.trigger()};if(We(),t===`clear`)o.forEach(s);else{let i=p(e),a=i&&T(n);if(i&&n===`length`){let e=Number(r);o.forEach((t,n)=>{(n===`length`||n===ft||!b(n)&&n>=e)&&s(t)})}else switch((n!==void 0||o.has(void 0))&&s(o.get(n)),a&&s(o.get(ft)),t){case`add`:i?a&&s(o.get(`length`)):(s(o.get(ut)),m(e)&&s(o.get(dt)));break;case`delete`:i||(s(o.get(ut)),m(e)&&s(o.get(dt)));break;case`set`:m(e)&&s(o.get(ut))}}Ge()}function ht(e,t){let n=lt.get(e);return n&&n.get(t)}function gt(e){let t=A(e);return t===e?t:(pt(t,`iterate`,ft),an(e)?t:t.map(cn))}function _t(e){return pt(e=A(e),`iterate`,ft),e}function vt(e,t){return rn(e)?ln(nn(e)?cn(t):t):cn(t)}var yt={__proto__:null,[Symbol.iterator](){return bt(this,Symbol.iterator,e=>vt(this,e))},concat(...e){return gt(this).concat(...e.map(e=>p(e)?gt(e):e))},entries(){return bt(this,`entries`,e=>(e[1]=vt(this,e[1]),e))},every(e,t){return St(this,`every`,e,t,void 0,arguments)},filter(e,t){return St(this,`filter`,e,t,e=>e.map(e=>vt(this,e)),arguments)},find(e,t){return St(this,`find`,e,t,e=>vt(this,e),arguments)},findIndex(e,t){return St(this,`findIndex`,e,t,void 0,arguments)},findLast(e,t){return St(this,`findLast`,e,t,e=>vt(this,e),arguments)},findLastIndex(e,t){return St(this,`findLastIndex`,e,t,void 0,arguments)},forEach(e,t){return St(this,`forEach`,e,t,void 0,arguments)},includes(...e){return wt(this,`includes`,e)},indexOf(...e){return wt(this,`indexOf`,e)},join(e){return gt(this).join(e)},lastIndexOf(...e){return wt(this,`lastIndexOf`,e)},map(e,t){return St(this,`map`,e,t,void 0,arguments)},pop(){return Tt(this,`pop`)},push(...e){return Tt(this,`push`,e)},reduce(e,...t){return Ct(this,`reduce`,e,t)},reduceRight(e,...t){return Ct(this,`reduceRight`,e,t)},shift(){return Tt(this,`shift`)},some(e,t){return St(this,`some`,e,t,void 0,arguments)},splice(...e){return Tt(this,`splice`,e)},toReversed(){return gt(this).toReversed()},toSorted(e){return gt(this).toSorted(e)},toSpliced(...e){return gt(this).toSpliced(...e)},unshift(...e){return Tt(this,`unshift`,e)},values(){return bt(this,`values`,e=>vt(this,e))}};function bt(e,t,n){let r=_t(e),i=r[t]();return r!==e&&!an(e)&&(i._next=i.next,i.next=()=>{let e=i._next();return e.done||(e.value=n(e.value)),e}),i}var xt=Array.prototype;function St(e,t,n,r,i,a){let o=_t(e),s=o!==e&&!an(e),c=o[t];if(c!==xt[t]){let t=c.apply(e,a);return s?cn(t):t}let l=n;o!==e&&(s?l=function(t,r){return n.call(this,vt(e,t),r,e)}:n.length>2&&(l=function(t,r){return n.call(this,t,r,e)}));let u=c.call(o,l,r);return s&&i?i(u):u}function Ct(e,t,n,r){let i=_t(e),a=i!==e&&!an(e),o=n,s=!1;i!==e&&(a?(s=r.length===0,o=function(t,r,i){return s&&(s=!1,t=vt(e,t)),n.call(this,t,vt(e,r),i,e)}):n.length>3&&(o=function(t,r,i){return n.call(this,t,r,i,e)}));let c=i[t](o,...r);return s?vt(e,c):c}function wt(e,t,n){let r=A(e);pt(r,`iterate`,ft);let i=r[t](...n);return(i===-1||i===!1)&&on(n[0])?(n[0]=A(n[0]),r[t](...n)):i}function Tt(e,t,n=[]){nt(),We();let r=A(e)[t].apply(e,n);return Ge(),rt(),r}var Et=n(`__proto__,__v_isRef,__isVue`),Dt=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!==`arguments`&&e!==`caller`).map(e=>Symbol[e]).filter(b));function Ot(e){b(e)||(e=String(e));let t=A(this);return pt(t,`has`,e),t.hasOwnProperty(e)}var kt=class{constructor(e=!1,t=!1){this._isReadonly=e,this._isShallow=t}get(e,t,n){if(t===`__v_skip`)return e.__v_skip;let r=this._isReadonly,i=this._isShallow;if(t===`__v_isReactive`)return!r;if(t===`__v_isReadonly`)return r;if(t===`__v_isShallow`)return i;if(t===`__v_raw`)return n===(r?i?Yt:Jt:i?qt:Kt).get(e)||Object.getPrototypeOf(e)===Object.getPrototypeOf(n)?e:void 0;let a=p(e);if(!r){let e;if(a&&(e=yt[t]))return e;if(t===`hasOwnProperty`)return Ot}let o=Reflect.get(e,t,un(e)?e:n);if((b(t)?Dt.has(t):Et(t))||(r||pt(e,`get`,t),i))return o;if(un(o)){let e=a&&T(t)?o:o.value;return r&&x(e)?$t(e):e}return x(o)?r?$t(o):Zt(o):o}},At=class extends kt{constructor(e=!1){super(!1,e)}set(e,t,n,r){let i=e[t],a=p(e)&&T(t);if(!this._isShallow){let e=rn(i);if(!an(n)&&!rn(n)&&(i=A(i),n=A(n)),!a&&un(i)&&!un(n))return e||(i.value=n),!0}let o=a?Number(t)<e.length:f(e,t),s=Reflect.set(e,t,n,un(e)?e:r);return e===A(r)&&s&&(o?D(n,i)&&mt(e,`set`,t,n,i):mt(e,`add`,t,n)),s}deleteProperty(e,t){let n=f(e,t),r=e[t],i=Reflect.deleteProperty(e,t);return i&&n&&mt(e,`delete`,t,void 0,r),i}has(e,t){let n=Reflect.has(e,t);return(!b(t)||!Dt.has(t))&&pt(e,`has`,t),n}ownKeys(e){return pt(e,`iterate`,p(e)?`length`:ut),Reflect.ownKeys(e)}},jt=class extends kt{constructor(e=!1){super(!0,e)}set(e,t){return!0}deleteProperty(e,t){return!0}},Mt=new At,Nt=new jt,Pt=new At(!0),Ft=new jt(!0),It=e=>e,Lt=e=>Reflect.getPrototypeOf(e);function Rt(e,t,n){return function(...r){let i=this.__v_raw,a=A(i),o=m(a),s=e===`entries`||e===Symbol.iterator&&o,c=e===`keys`&&o,u=i[e](...r),d=n?It:t?ln:cn;return!t&&pt(a,`iterate`,c?dt:ut),l(Object.create(u),{next(){let{value:e,done:t}=u.next();return t?{value:e,done:t}:{value:s?[d(e[0]),d(e[1])]:d(e),done:t}}})}}function zt(e){return function(...t){return e===`delete`?!1:e===`clear`?void 0:this}}function Bt(e,t){let n={get(n){let r=this.__v_raw,i=A(r),a=A(n);e||(D(n,a)&&pt(i,`get`,n),pt(i,`get`,a));let{has:o}=Lt(i),s=t?It:e?ln:cn;if(o.call(i,n))return s(r.get(n));if(o.call(i,a))return s(r.get(a));r!==i&&r.get(n)},get size(){let t=this.__v_raw;return!e&&pt(A(t),`iterate`,ut),t.size},has(t){let n=this.__v_raw,r=A(n),i=A(t);return e||(D(t,i)&&pt(r,`has`,t),pt(r,`has`,i)),t===i?n.has(t):n.has(t)||n.has(i)},forEach(n,r){let i=this,a=i.__v_raw,o=A(a),s=t?It:e?ln:cn;return!e&&pt(o,`iterate`,ut),a.forEach((e,t)=>n.call(r,s(e),s(t),i))}};return l(n,e?{add:zt(`add`),set:zt(`set`),delete:zt(`delete`),clear:zt(`clear`)}:{add(e){let n=A(this),r=Lt(n),i=A(e),a=!t&&!an(e)&&!rn(e)?i:e;return r.has.call(n,a)||D(e,a)&&r.has.call(n,e)||D(i,a)&&r.has.call(n,i)||(n.add(a),mt(n,`add`,a,a)),this},set(e,n){!t&&!an(n)&&!rn(n)&&(n=A(n));let r=A(this),{has:i,get:a}=Lt(r),o=i.call(r,e);o||=(e=A(e),i.call(r,e));let s=a.call(r,e);return r.set(e,n),o?D(n,s)&&mt(r,`set`,e,n,s):mt(r,`add`,e,n),this},delete(e){let t=A(this),{has:n,get:r}=Lt(t),i=n.call(t,e);i||=(e=A(e),n.call(t,e));let a=r?r.call(t,e):void 0,o=t.delete(e);return i&&mt(t,`delete`,e,void 0,a),o},clear(){let e=A(this),t=e.size!==0,n=e.clear();return t&&mt(e,`clear`,void 0,void 0,void 0),n}}),[`keys`,`values`,`entries`,Symbol.iterator].forEach(r=>{n[r]=Rt(r,e,t)}),n}function Vt(e,t){let n=Bt(e,t);return(t,r,i)=>r===`__v_isReactive`?!e:r===`__v_isReadonly`?e:r===`__v_raw`?t:Reflect.get(f(n,r)&&r in t?n:t,r,i)}var Ht={get:Vt(!1,!1)},Ut={get:Vt(!1,!0)},Wt={get:Vt(!0,!1)},Gt={get:Vt(!0,!0)},Kt=new WeakMap,qt=new WeakMap,Jt=new WeakMap,Yt=new WeakMap;function Xt(e){switch(e){case`Object`:case`Array`:return 1;case`Map`:case`Set`:case`WeakMap`:case`WeakSet`:return 2;default:return 0}}function Zt(e){return rn(e)?e:tn(e,!1,Mt,Ht,Kt)}function Qt(e){return tn(e,!1,Pt,Ut,qt)}function $t(e){return tn(e,!0,Nt,Wt,Jt)}function en(e){return tn(e,!0,Ft,Gt,Yt)}function tn(e,t,n,r,i){if(!x(e)||e.__v_raw&&!(t&&e.__v_isReactive)||e.__v_skip||!Object.isExtensible(e))return e;let a=i.get(e);if(a)return a;let o=Xt(ee(e));if(o===0)return e;let s=new Proxy(e,o===2?r:n);return i.set(e,s),s}function nn(e){return rn(e)?nn(e.__v_raw):!!(e&&e.__v_isReactive)}function rn(e){return!!(e&&e.__v_isReadonly)}function an(e){return!!(e&&e.__v_isShallow)}function on(e){return e?!!e.__v_raw:!1}function A(e){let t=e&&e.__v_raw;return t?A(t):e}function sn(e){return!f(e,`__v_skip`)&&Object.isExtensible(e)&&ue(e,`__v_skip`,!0),e}var cn=e=>x(e)?Zt(e):e,ln=e=>x(e)?$t(e):e;function un(e){return e?e.__v_isRef===!0:!1}function j(e){return fn(e,!1)}function dn(e){return fn(e,!0)}function fn(e,t){return un(e)?e:new pn(e,t)}var pn=class{constructor(e,t){this.dep=new st,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=t?e:A(e),this._value=t?e:cn(e),this.__v_isShallow=t}get value(){return this.dep.track(),this._value}set value(e){let t=this._rawValue,n=this.__v_isShallow||an(e)||rn(e);e=n?e:A(e),D(e,t)&&(this._rawValue=e,this._value=n?e:cn(e),this.dep.trigger())}};function mn(e){e.dep&&e.dep.trigger()}function M(e){return un(e)?e.value:e}function hn(e){return v(e)?e():M(e)}var gn={get:(e,t,n)=>t===`__v_raw`?e:M(Reflect.get(e,t,n)),set:(e,t,n,r)=>{let i=e[t];return un(i)&&!un(n)?(i.value=n,!0):Reflect.set(e,t,n,r)}};function _n(e){return nn(e)?e:new Proxy(e,gn)}var vn=class{constructor(e){this.__v_isRef=!0,this._value=void 0;let t=this.dep=new st,{get:n,set:r}=e(t.track.bind(t),t.trigger.bind(t));this._get=n,this._set=r}get value(){return this._value=this._get()}set value(e){this._set(e)}};function yn(e){return new vn(e)}function bn(e){let t=p(e)?Array(e.length):{};for(let n in e)t[n]=wn(e,n);return t}var xn=class{constructor(e,t,n){this._object=e,this._defaultValue=n,this.__v_isRef=!0,this._value=void 0,this._key=b(t)?t:String(t),this._raw=A(e);let r=!0,i=e;if(!p(e)||b(this._key)||!T(this._key))do r=!on(i)||an(i);while(r&&(i=i.__v_raw));this._shallow=r}get value(){let e=this._object[this._key];return this._shallow&&(e=M(e)),this._value=e===void 0?this._defaultValue:e}set value(e){if(this._shallow&&un(this._raw[this._key])){let t=this._object[this._key];if(un(t)){t.value=e;return}}this._object[this._key]=e}get dep(){return ht(this._raw,this._key)}},Sn=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 Cn(e,t,n){return un(e)?e:v(e)?new Sn(e):x(e)&&arguments.length>1?wn(e,t,n):j(e)}function wn(e,t,n){return new xn(e,t,n)}var Tn=class{constructor(e,t,n){this.fn=e,this.setter=t,this._value=void 0,this.dep=new st(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=at-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!t,this.isSSR=n}notify(){if(this.flags|=16,!(this.flags&8)&&Le!==this)return Ue(this,!0),!0}get value(){let e=this.dep.track();return Ye(this),e&&(e.version=this.dep.version),this._value}set value(e){this.setter&&this.setter(e)}};function En(e,t,n=!1){let r,i;return v(e)?r=e:(r=e.get,i=e.set),new Tn(r,i,n)}var Dn={GET:`get`,HAS:`has`,ITERATE:`iterate`},On={SET:`set`,ADD:`add`,DELETE:`delete`,CLEAR:`clear`},kn={},An=new WeakMap,jn=void 0;function Mn(){return jn}function Nn(e,t=!1,n=jn){if(n){let t=An.get(n);t||An.set(n,t=[]),t.push(e)}}function Pn(e,t,n=r){let{immediate:i,deep:o,once:s,scheduler:c,augmentJob:l,call:d}=n,f=e=>o?e:an(e)||o===!1||o===0?Fn(e,1):Fn(e),m,h,g,_,y=!1,b=!1;if(un(e)?(h=()=>e.value,y=an(e)):nn(e)?(h=()=>f(e),y=!0):p(e)?(b=!0,y=e.some(e=>nn(e)||an(e)),h=()=>e.map(e=>{if(un(e))return e.value;if(nn(e))return f(e);if(v(e))return d?d(e,2):e()})):h=v(e)?t?d?()=>d(e,2):e:()=>{if(g){nt();try{g()}finally{rt()}}let t=jn;jn=m;try{return d?d(e,3,[_]):e(_)}finally{jn=t}}:a,t&&o){let e=h,t=o===!0?1/0:o;h=()=>Fn(e(),t)}let x=Fe(),S=()=>{m.stop(),x&&x.active&&u(x.effects,m)};if(s&&t){let e=t;t=(...t)=>{let n=e(...t);return S(),n}}let C=b?Array(e.length).fill(kn):kn,w=e=>{if(!(!(m.flags&1)||!m.dirty&&!e)){if(t){let n=m.run();if(e||o||y||(b?n.some((e,t)=>D(e,C[t])):D(n,C))){g&&g();let e=jn;jn=m;try{let e=[n,C===kn?void 0:b&&C[0]===kn?[]:C,_];C=n,d?d(t,3,e):t(...e)}finally{jn=e}}}else m.run()}};return l&&l(w),m=new ze(h),m.scheduler=c?()=>c(w,!1):w,_=e=>Nn(e,!1,m),g=m.onStop=()=>{let e=An.get(m);if(e){if(d)d(e,4);else for(let t of e)t();An.delete(m)}},t?i?w(!0):C=m.run():c?c(w.bind(null,!0),!0):m.run(),S.pause=m.pause.bind(m),S.resume=m.resume.bind(m),S.stop=S,S}function Fn(e,t=1/0,n){if(t<=0||!x(e)||e.__v_skip||(n||=new Map,(n.get(e)||0)>=t))return e;if(n.set(e,t),t--,un(e))Fn(e.value,t,n);else if(p(e))for(let r=0;r<e.length;r++)Fn(e[r],t,n);else if(h(e)||m(e))e.forEach(e=>{Fn(e,t,n)});else if(te(e)){for(let r in e)Fn(e[r],t,n);for(let r of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,r)&&Fn(e[r],t,n)}return e}var In=[];function Ln(e){In.push(e)}function Rn(){In.pop()}function zn(e,t){}var Bn={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`},Vn={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 Hn(e,t,n,r){try{return r?e(...r):e()}catch(e){Wn(e,t,n)}}function Un(e,t,n,r){if(v(e)){let i=Hn(e,t,n,r);return i&&S(i)&&i.catch(e=>{Wn(e,t,n)}),i}if(p(e)){let i=[];for(let a=0;a<e.length;a++)i.push(Un(e[a],t,n,r));return i}}function Wn(e,t,n,i=!0){let a=t?t.vnode:null,{errorHandler:o,throwUnhandledErrorInProduction:s}=t&&t.appContext.config||r;if(t){let r=t.parent,i=t.proxy,a=`https://vuejs.org/error-reference/#runtime-${n}`;for(;r;){let t=r.ec;if(t){for(let n=0;n<t.length;n++)if(t[n](e,i,a)===!1)return}r=r.parent}if(o){nt(),Hn(o,null,10,[e,i,a]),rt();return}}Gn(e,n,a,i,s)}function Gn(e,t,n,r=!0,i=!1){if(i)throw e;console.error(e)}var Kn=[],qn=-1,Jn=[],Yn=null,Xn=0,Zn=Promise.resolve(),Qn=null;function $n(e){let t=Qn||Zn;return e?t.then(this?e.bind(this):e):t}function er(e){let t=qn+1,n=Kn.length;for(;t<n;){let r=t+n>>>1,i=Kn[r],a=or(i);a<e||a===e&&i.flags&2?t=r+1:n=r}return t}function tr(e){if(!(e.flags&1)){let t=or(e),n=Kn[Kn.length-1];!n||!(e.flags&2)&&t>=or(n)?Kn.push(e):Kn.splice(er(t),0,e),e.flags|=1,nr()}}function nr(){Qn||=Zn.then(sr)}function rr(e){if(!p(e))Yn&&e.id===-1?Yn.splice(Xn+1,0,e):e.flags&1||(Jn.push(e),e.flags|=1);else for(let t=0;t<e.length;t++)Jn.push(e[t]);nr()}function ir(e,t,n=qn+1){for(;n<Kn.length;n++){let t=Kn[n];if(t&&t.flags&2){if(e&&t.id!==e.uid)continue;Kn.splice(n,1),n--,t.flags&4&&(t.flags&=-2),t(),t.flags&4||(t.flags&=-2)}}}function ar(e){if(Jn.length){let e=[...new Set(Jn)].sort((e,t)=>or(e)-or(t));if(Jn.length=0,Yn){for(let t=0;t<e.length;t++)Yn.push(e[t]);return}for(Yn=e,Xn=0;Xn<Yn.length;Xn++){let e=Yn[Xn];e.flags&4&&(e.flags&=-2),e.flags&8||e(),e.flags&=-2}Yn=null,Xn=0}}var or=e=>e.id==null?e.flags&2?-1:1/0:e.id;function sr(e){try{for(qn=0;qn<Kn.length;qn++){let e=Kn[qn];e&&!(e.flags&8)&&(e.flags&4&&(e.flags&=-2),Hn(e,e.i,e.i?15:14),e.flags&4||(e.flags&=-2))}}finally{for(;qn<Kn.length;qn++){let e=Kn[qn];e&&(e.flags&=-2)}qn=-1,Kn.length=0,ar(e),Qn=null,(Kn.length||Jn.length)&&sr(e)}}var cr,lr=[];function ur(e,t){cr=e,cr?(cr.enabled=!0,lr.forEach(({event:e,args:t})=>cr.emit(e,...t)),lr=[]):typeof window<`u`&&window.HTMLElement&&!(window.navigator?.userAgent)?.includes(`jsdom`)?((t.__VUE_DEVTOOLS_HOOK_REPLAY__=t.__VUE_DEVTOOLS_HOOK_REPLAY__||[]).push(e=>{ur(e,t)}),setTimeout(()=>{cr||(t.__VUE_DEVTOOLS_HOOK_REPLAY__=null,lr=[])},3e3)):lr=[]}var dr=null,fr=null;function pr(e){let t=dr;return dr=e,fr=e&&e.type.__scopeId||null,t}function mr(e){fr=e}function hr(){fr=null}var gr=e=>N;function N(e,t=dr,n){if(!t||e._n)return e;let r=(...n)=>{r._d&&hs(-1);let i=pr(t),a=ds.length,o;try{o=e(...n)}finally{for(let e=ds.length;e>a;e--)ps();pr(i),r._d&&hs(1)}return o};return r._n=!0,r._c=!0,r._d=!0,r}function _r(e,t){if(dr===null)return e;let n=Qs(dr),i=e.dirs||=[];for(let e=0;e<t.length;e++){let[a,o,s,c=r]=t[e];a&&(v(a)&&(a={mounted:a,updated:a}),a.deep&&Fn(o),i.push({dir:a,instance:n,value:o,oldValue:void 0,arg:s,modifiers:c}))}return e}function vr(e,t,n,r){let i=e.dirs,a=t&&t.dirs;for(let o=0;o<i.length;o++){let s=i[o];a&&(s.oldValue=a[o].value);let c=s.dir[r];c&&(nt(),Un(c,n,8,[e.el,s,e,t]),rt())}}function yr(e,t){if(Ps){let n=Ps.provides,r=Ps.parent&&Ps.parent.provides;r===n&&(n=Ps.provides=Object.create(r)),n[e]=t}}function br(e,t,n=!1){let r=Fs();if(r||ro){let i=ro?ro._context.provides:r?r.parent==null||r.ce?r.vnode.appContext&&r.vnode.appContext.provides:r.parent.provides:void 0;if(i&&e in i)return i[e];if(arguments.length>1)return n&&v(t)?t.call(r&&r.proxy):t}}function xr(){return!!(Fs()||ro)}var Sr=Symbol.for(`v-scx`),Cr=()=>br(Sr);function wr(e,t){return Or(e,null,t)}function Tr(e,t){return Or(e,null,{flush:`post`})}function Er(e,t){return Or(e,null,{flush:`sync`})}function Dr(e,t,n){return Or(e,t,n)}function Or(e,t,n=r){let{immediate:i,deep:o,flush:s,once:c}=n,u=l({},n),d=t&&i||!t&&s!==`post`,f;if(Vs){if(s===`sync`){let e=Cr();f=e.__watcherHandles||=[]}else if(!d){let e=()=>{};return e.stop=a,e.resume=a,e.pause=a,e}}let p=Ps;u.call=(e,t,n)=>Un(e,p,t,n);let m=!1;s===`post`?u.scheduler=e=>{Lo(e,p&&p.suspense)}:s!==`sync`&&(m=!0,u.scheduler=(e,t)=>{t?e():tr(e)}),u.augmentJob=e=>{t&&(e.flags|=4),m&&(e.flags|=2,p&&(e.id=p.uid,e.i=p))};let h=Pn(e,t,u);return Vs&&(f?f.push(h):d&&h()),h}function kr(e,t,n){let r=this.proxy,i=y(e)?e.includes(`.`)?Ar(r,e):()=>r[e]:e.bind(r,r),a;v(t)?a=t:(a=t.handler,n=t);let o=Rs(this),s=Or(i,a.bind(r),n);return o(),s}function Ar(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 jr=new WeakMap,Mr=Symbol(`_vte`),Nr=e=>e.__isTeleport,Pr=e=>e&&(e.disabled||e.disabled===``),Fr=e=>e&&(e.defer||e.defer===``),Ir=e=>typeof SVGElement<`u`&&e instanceof SVGElement,Lr=e=>typeof MathMLElement==`function`&&e instanceof MathMLElement,Rr=(e,t)=>{let n=e&&e.to;return y(n)?t?t(n):null:n},zr={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=Pr(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=Pr(e.props),r=e.target=Rr(e.props,m),a=Wr(r,e,h,p);r&&(o!==`svg`&&Ir(r)?o=`svg`:o!==`mathml`&&Lr(r)&&(o=`mathml`),i&&i.isCE&&(i.ce._teleportTargets||(i.ce._teleportTargets=new Set)).add(r),n||(b(e,r,a),Ur(e,!1)))},S=e=>{let t=()=>{if(jr.get(e)===t){if(jr.delete(e),Pr(e.props)){let t=_(e.el)||n;b(e,t,e.anchor),Ur(e,!0)}x(e)}};jr.set(e,t),Lo(t,a)};if(e==null){let e=t.el=h(``),i=t.anchor=h(``);if(p(e,n,r),p(i,n,r),Fr(t.props)||a&&a.pendingBranch){S(t);return}v&&(b(t,n,i),Ur(t,!0)),x()}else{t.el=e.el;let r=t.anchor=e.anchor,u=jr.get(e);if(u){u.flags|=8,jr.delete(e),S(t);return}t.targetStart=e.targetStart;let p=t.target=e.target,h=t.targetAnchor=e.targetAnchor,g=Pr(e.props),_=g?n:p,b=g?r:h;if(o===`svg`||Ir(p)?o=`svg`:(o===`mathml`||Lr(p))&&(o=`mathml`),y?(f(e.dynamicChildren,y,_,i,a,o,s),Wo(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):Br(t,n,r,l,1);else if((t.props&&t.props.to)!==(e.props&&e.props.to)){let e=Rr(t.props,m);e&&(t.target=e,Br(t,e,null,l,0))}else g&&Br(t,p,h,l,1);Ur(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=Pr(f),m=a||!p,h=jr.get(e);if(h&&(h.flags|=8,jr.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:Br,hydrate:Vr};function Br(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),!jr.has(e)&&(!d||Pr(u))&&c&16)for(let e=0;e<l.length;e++)i(l[e],t,n,2);d&&r(s,t,n)}function Vr(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=Rr(t.props,c),h=Pr(t.props);if(m){let c=m._lpa||m.firstChild;t.shapeFlag&16&&(h?(p(e,t),f(m,c),t.targetAnchor||Wr(m,t,u,l,s(e)===m?e:null)):(t.anchor=o(e),f(m,c),t.targetAnchor||Wr(m,t,u,l),d(c&&o(c),t,m,n,r,i,a))),Ur(t,h)}else h&&t.shapeFlag&16&&(p(e,t),t.targetStart=e,t.targetAnchor=o(e));return t.anchor&&o(t.anchor)}var Hr=zr;function Ur(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 Wr(e,t,n,r,i=null){let a=t.targetStart=n(``),o=t.targetAnchor=n(``);return a[Mr]=o,e&&(r(a,e,i),r(o,e,i)),o}var Gr=Symbol(`_leaveCb`),Kr=Symbol(`_enterCb`);function qr(){let e={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return Qi(()=>{e.isMounted=!0}),ta(()=>{e.isUnmounting=!0}),e}var Jr=[Function,Array],Yr={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:Jr,onEnter:Jr,onAfterEnter:Jr,onEnterCancelled:Jr,onBeforeLeave:Jr,onLeave:Jr,onAfterLeave:Jr,onLeaveCancelled:Jr,onBeforeAppear:Jr,onAppear:Jr,onAfterAppear:Jr,onAppearCancelled:Jr},Xr=e=>{let t=e.subTree;return t.component?Xr(t.component):t},Zr={name:`BaseTransition`,props:Yr,setup(e,{slots:t}){let n=Fs(),r=qr();return()=>{let i=t.default&&ai(t.default(),!0),a=i&&i.length?Qr(i):n.subTree?U():void 0;if(!a)return;let o=A(e),{mode:s}=o;if(r.isLeaving)return ni(a);let c=ri(a);if(!c)return ni(a);let l=ti(c,o,r,n,e=>l=e);c.type!==ls&&ii(c,l);let u=n.subTree&&ri(n.subTree);if(u&&u.type!==ls&&!vs(u,c)&&Xr(n).type!==ls){let e=ti(u,o,r,n);if(ii(u,e),s===`out-in`&&c.type!==ls)return r.isLeaving=!0,e.afterLeave=()=>{r.isLeaving=!1,n.job.flags&8||n.update(),delete e.afterLeave,u=void 0},ni(a);s===`in-out`&&c.type!==ls?e.delayLeave=(e,t,n)=>{let i=ei(r,u);i[String(u.key)]=u,e[Gr]=()=>{t(),e[Gr]=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 Qr(e){let t=e[0];if(e.length>1){for(let n of e)if(n.type!==ls){t=n;break}}return t}var $r=Zr;function ei(e,t){let{leavingVNodes:n}=e,r=n.get(t.type);return r||(r=Object.create(null),n.set(t.type,r)),r}function ti(e,t,n,r,i){let{appear:a,mode:o,persisted:s=!1,onBeforeEnter:c,onEnter:l,onAfterEnter:u,onEnterCancelled:d,onBeforeLeave:f,onLeave:m,onAfterLeave:h,onLeaveCancelled:g,onBeforeAppear:_,onAppear:v,onAfterAppear:y,onAppearCancelled:b}=t,x=String(e.key),S=ei(n,e),C=(e,t)=>{e&&Un(e,r,9,t)},w=(e,t)=>{let n=t[1];C(e,t),p(e)?e.every(e=>e.length<=1)&&n():e.length<=1&&n()},ee={mode:o,persisted:s,beforeEnter(t){let r=c;if(!n.isMounted){if(a)r=_||c;else return}t[Gr]&&t[Gr](!0);let i=S[x];i&&vs(e,i)&&i.el[Gr]&&i.el[Gr](),C(r,[t])},enter(t){if(S[x]===e)return;let r=l,i=u,o=d;if(!n.isMounted){if(a)r=v||l,i=y||u,o=b||d;else return}let s=!1;t[Kr]=e=>{s||(s=!0,C(e?o:i,[t]),ee.delayedLeave&&ee.delayedLeave(),t[Kr]=void 0)};let c=t[Kr].bind(null,!1);r?w(r,[t,c]):c()},leave(t,r){let i=String(e.key);if(t[Kr]&&t[Kr](!0),n.isUnmounting)return r();C(f,[t]);let a=!1;t[Gr]=n=>{a||(a=!0,r(),C(n?g:h,[t]),t[Gr]=void 0,S[i]===e&&delete S[i])};let o=t[Gr].bind(null,!1);S[i]=e,m?w(m,[t,o]):o()},clone(e){let a=ti(e,t,n,r,i);return i&&i(a),a}};return ee}function ni(e){if(Bi(e))return e=ws(e),e.children=null,e}function ri(e){if(!Bi(e))return Nr(e.type)&&e.children?Qr(e.children):e;if(e.component)return e.component.subTree;let{shapeFlag:t,children:n}=e;if(n){if(t&16)return n[0];if(t&32&&v(n.default))return n.default()}}function ii(e,t){if(e.shapeFlag&6&&e.component){e.transition=t;let n=e.component.subTree;ii(Nr(n.type)&&ri(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 ai(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===I?(o.patchFlag&128&&i++,r=r.concat(ai(o.children,t,s))):(t||o.type!==ls)&&r.push(s==null?o:ws(o,{key:s}))}if(i>1)for(let e=0;e<r.length;e++)r[e].patchFlag=-2;return r}function P(e,t){return v(e)?l({name:e.name},t,{setup:e}):e}function oi(){let e=Fs();return e?(e.appContext.config.idPrefix||`v`)+`-`+e.ids[0]+e.ids[1]++:``}function si(e){e.ids=[e.ids[0]+e.ids[2]+++`-`,0,0]}function ci(e){let t=Fs(),n=dn(null);if(t){let i=t.refs===r?t.refs={}:t.refs;Object.defineProperty(i,e,{enumerable:!0,get:()=>n.value,set:e=>n.value=e})}return n}function li(e,t){let n;return!!((n=Object.getOwnPropertyDescriptor(e,t))&&!n.configurable)}var ui=new WeakMap;function di(e,t,n,i,a=!1){if(p(e)){e.forEach((e,r)=>di(e,t&&(p(t)?t[r]:t),n,i,a));return}if(Li(i)&&!a){i.shapeFlag&512&&i.type.__asyncResolved&&i.component.subTree.component&&di(e,t,n,i.component.subTree);return}let s=i.shapeFlag&4?Qs(i.component):i.el,c=a?null:s,{i:l,r:d}=e,m=t&&t.r,h=l.refs===r?l.refs={}:l.refs,g=l.setupState,_=A(g),b=g===r?o:e=>!li(h,e)&&f(_,e),x=(e,t)=>!(t&&li(h,t));if(m!=null&&m!==d){if(fi(t),y(m))h[m]=null,b(m)&&(g[m]=null);else if(un(m)){let e=t;x(m,e.k)&&(m.value=null),e.k&&(h[e.k]=null)}}if(v(d))Hn(d,l,12,[c,h]);else{let t=y(d),r=un(d);if(t||r){let i=()=>{if(e.f){let n=t?b(d)?g[d]:h[d]:x(d)||!e.k?d.value:h[e.k];if(a)p(n)&&u(n,s);else if(p(n))n.includes(s)||n.push(s);else if(t)h[d]=[s],b(d)&&(g[d]=h[d]);else{let t=[s];x(d,e.k)&&(d.value=t),e.k&&(h[e.k]=t)}}else t?(h[d]=c,b(d)&&(g[d]=c)):r&&(x(d,e.k)&&(d.value=c),e.k&&(h[e.k]=c))};if(c){let t=()=>{i(),ui.delete(e)};t.id=-1,ui.set(e,t),Lo(t,n)}else fi(e),i()}}}function fi(e){let t=ui.get(e);t&&(t.flags|=8,ui.delete(e))}var pi=!1,mi=()=>{pi||=(console.error(`Hydration completed but contains mismatches.`),!0)},hi=e=>e.namespaceURI.includes(`svg`)&&e.tagName!==`foreignObject`,gi=e=>e.namespaceURI.includes(`MathML`),_i=e=>{if(e.nodeType===1){if(hi(e))return`svg`;if(gi(e))return`mathml`}},vi=e=>e.nodeType===8;function yi(e){let{mt:t,p:n,o:{patchProp:r,createText:i,nextSibling:a,parentNode:o,remove:c,insert:l,createComment:u}}=e,d=(e,t)=>{if(!t.hasChildNodes()){n(null,e,t),ar(),t._vnode=e;return}f(t.firstChild,e,null,null,null),ar(),t._vnode=e},f=(n,r,s,c,u,d=!1)=>{d||=!!r.dynamicChildren;let b=vi(n)&&n.data===`[`,x=()=>g(n,r,s,c,u,b),{type:S,ref:C,shapeFlag:w,patchFlag:ee}=r,te=n.nodeType;r.el=n,ee===-2&&(d=!1,r.dynamicChildren=null);let T=null;switch(S){case cs:te===3?(n.data!==r.children&&(mi(),n.data=r.children),T=a(n)):r.children===``?(l(r.el=i(``),o(n),n),T=n):T=x();break;case ls:y(n)?(T=a(n),v(r.el=n.content.firstChild,n,s)):T=te!==8||b?x():a(n);break;case us:if(b&&(n=a(n),te=n.nodeType),te===1||te===3){T=n;let e=!r.children.length;for(let t=0;t<r.staticCount;t++)e&&(r.children+=T.nodeType===1?T.outerHTML:T.data),t===r.staticCount-1&&(r.anchor=T),T=a(T);return b?a(T):T}x();break;case I:T=b?h(n,r,s,c,u,d):x();break;default:if(w&1)T=(te!==1||r.type.toLowerCase()!==n.tagName.toLowerCase())&&!y(n)?x():p(n,r,s,c,u,d);else if(w&6){r.slotScopeIds=u;let e=o(n);if(T=b?_(n):vi(n)&&n.data===`teleport start`?_(n,n.data,`teleport end`):a(n),t(r,e,null,s,c,_i(e),d),Li(r)&&!r.type.__asyncResolved){let t;b?(t=V(I),t.anchor=T?T.previousSibling:e.lastChild):t=n.nodeType===3?H(``):V(`div`),t.el=n,r.component.subTree=t}}else w&64?T=te===8?r.type.hydrate(n,r,s,c,u,d,e,m):x():w&128&&(T=r.type.hydrate(n,r,s,c,_i(o(n)),u,d,e,f))}return C!=null&&di(C,null,c,r),T},p=(e,t,n,i,a,o)=>{o||=!!t.dynamicChildren;let{type:l,dynamicProps:u,props:d,patchFlag:f,shapeFlag:p,dirs:h,transition:g}=t,_=l===`input`||l===`option`,b=!!u;if(_||b||f!==-1){h&&vr(t,null,n,`created`);let l=!1;if(y(e)){l=Uo(null,g)&&n&&n.vnode.props&&n.vnode.props.appear;let r=e.content.firstChild;if(l){let e=r.getAttribute(`class`);e&&(r.$cls=e),g.beforeEnter(r)}v(r,e,n),t.el=e=r}if(p&16&&!(d&&(d.innerHTML||d.textContent))){let r=m(e.firstChild,t,e,n,i,a,o);for(r&&!wi(e,1)&&mi();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,`
`)&&(wi(e,0)||mi(),e.textContent=t.children)}if(d){if(_||b||!o||f&48){let t=e.tagName.includes(`-`),i=e.namespaceURI.includes(`svg`)?`svg`:e.namespaceURI.includes(`MathML`)?`mathml`:void 0;for(let a in d)if(_&&(a.endsWith(`value`)||a===`indeterminate`)||s(a)&&!ne(a)||a[0]===`.`||t&&!ne(a)||u&&u.includes(a)){if(xi(e,a,d[a]))continue;r(e,a,null,d[a],i,n)}}else if(d.onClick)r(e,`onClick`,null,d.onClick,void 0,n);else if(f&4&&nn(d.style))for(let e in d.style)d.style[e]}let x;(x=d&&d.onVnodeBeforeMount)&&As(x,n,t),h&&vr(t,null,n,`beforeMount`),((x=d&&d.onVnodeMounted)||h||l)&&as(()=>{x&&As(x,n,t),l&&g.enter(e),h&&vr(t,null,n,`mounted`)},i)}return e.nextSibling},m=(e,t,r,o,s,c,u)=>{u||=!!t.dynamicChildren;let d=t.children,p=d.length,m=!1;for(let t=0;t<p;t++){let h=u?d[t]:d[t]=Es(d[t]),g=h.type===cs;e?(g&&!u&&t+1<p&&Es(d[t+1]).type===cs&&(l(i(e.data.slice(h.children.length)),r,a(e)),e.data=h.children),e=f(e,h,o,s,c,u)):g&&!h.children?l(h.el=i(``),r):(m||(m=!0,wi(r,1)||mi()),n(null,h,r,null,o,s,_i(r),c))}return e},h=(e,t,n,r,i,s)=>{let{slotScopeIds:c}=t;c&&(i=i?i.concat(c):c);let d=o(e),f=m(a(e),t,d,n,r,i,s);return f&&vi(f)&&f.data===`]`?a(t.anchor=f):(mi(),l(t.anchor=u(`]`),d,f),f)},g=(e,t,r,i,s,l)=>{if(Ei(e,t)||mi(),t.el=null,l){let t=_(e);for(;;){let n=a(e);if(n&&n!==t)c(n);else break}}let u=a(e),d=o(e);return c(e),n(null,t,d,u,r,i,_i(d),s),r&&(r.vnode.el=t.el,vo(r,t.el)),u},_=(e,t=`[`,n=`]`)=>{let r=0;for(;e;)if(e=a(e),e&&vi(e)&&(e.data===t&&r++,e.data===n)){if(r===0)return a(e);r--}return e},v=(e,t,n)=>{let r=t.parentNode;r&&r.replaceChild(e,t);let i=n;for(;i;)i.vnode.el===t&&(i.vnode.el=i.subTree.el=e),i=i.parent},y=e=>e.nodeType===1&&e.tagName===`TEMPLATE`;return[d,f]}var bi=new Set([`src`,`srcset`,`href`,`poster`]);function xi(e,t,n){return bi.has(t)?e.getAttribute(t)===(n==null?null:`${n}`):!1}var Si=`data-allow-mismatch`,Ci={0:`text`,1:`children`,2:`class`,3:`style`,4:`attribute`};function wi(e,t){if(t===0||t===1)for(;e&&!e.hasAttribute(Si);)e=e.parentElement;return Ti(e&&e.getAttribute(Si),t)}function Ti(e,t){if(e==null)return!1;if(e===``)return!0;{let n=e.split(`,`);return t===0&&n.includes(`children`)?!0:n.includes(Ci[t])}}function Ei(e,t){return wi(e.parentElement,1)||Di(e)||Oi(t)}function Di(e){return e.nodeType===1&&Ti(e.getAttribute(Si),1)}function Oi({props:e}){let t=e&&e[Si];return typeof t==`string`&&Ti(t,1)}var ki=me().requestIdleCallback||(e=>setTimeout(e,1)),Ai=me().cancelIdleCallback||(e=>clearTimeout(e)),ji=(e=1e4)=>t=>{let n=ki(t,{timeout:e});return()=>Ai(n)};function Mi(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 Ni=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(Mi(e))return t(),r.disconnect(),!1;r.observe(e)}}),()=>r.disconnect()},Pi=e=>t=>{if(e){let n=matchMedia(e);if(n.matches)t();else return n.addEventListener(`change`,t,{once:!0}),()=>n.removeEventListener(`change`,t)}},Fi=(e=[])=>(t,n)=>{y(e)&&(e=[e]);let r=!1,i=e=>{r||(r=!0,a(),t(),e.target.dispatchEvent(new e.constructor(e.type,e)))},a=()=>{n(t=>{for(let n of e)t.removeEventListener(n,i)})};return n(t=>{for(let n of e)t.addEventListener(n,i,{once:!0})}),a};function Ii(e,t){if(vi(e)&&e.data===`[`){let n=1,r=e.nextSibling;for(;r;){if(r.nodeType===1){if(t(r)===!1)break}else if(vi(r)){if(r.data===`]`){if(--n===0)break}else r.data===`[`&&n++}r=r.nextSibling}}else t(e)}var Li=e=>!!e.type.__asyncLoader;function Ri(e){v(e)&&(e={loader:e});let{loader:t,loadingComponent:n,errorComponent:r,delay:i=200,hydrate:a,timeout:o,suspensible:s=!0,onError:c}=e,l=null,u,d=0,f=()=>(d++,l=null,p()),p=()=>{let e;return l||(e=l=t().catch(e=>{if(e=e instanceof Error?e:Error(String(e)),c)return new Promise((t,n)=>{c(e,()=>t(f()),()=>n(e),d+1)});throw e}).then(t=>e!==l&&l?l:(t&&(t.__esModule||t[Symbol.toStringTag]===`Module`)&&(t=t.default),u=t,t)))};return P({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=>Ii(e,t));n&&(t.bum||=[]).push(n)}:o;u?s():p().then(()=>!t.isUnmounted&&s())},get __asyncResolved(){return u},setup(){let e=Ps;if(si(e),u)return()=>zi(u,e);let t=t=>{l=null,Wn(t,e,13,!r)};if(s&&e.suspense||Vs)return p().then(t=>()=>zi(t,e)).catch(e=>(t(e),()=>r?V(r,{error:e}):null));let a=j(!1),c=j(),d=j(!!i),f,m;return na(()=>{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&&Bi(e.parent.vnode)&&e.parent.update())}).catch(n=>{if(e.isUnmounted){l=null;return}t(n),c.value=n}),()=>{if(a.value&&u)return zi(u,e);if(c.value&&r)return V(r,{error:c.value});if(n&&!d.value)return zi(n,e)}}})}function zi(e,t){let{ref:n,props:r,children:i,ce:a}=t.vnode,o=V(e,r,i);return o.ref=n,o.ce=a,delete t.vnode.ce,o}var Bi=e=>e.type.__isKeepAlive,Vi={name:`KeepAlive`,__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(e,{slots:t}){let n=Fs(),r=n.ctx;if(!r.renderer)return()=>{let e=t.default&&t.default();return e&&e.length===1?e[0]:e};let i=new Map,a=new Set,o=null,s=n.suspense,{renderer:{p:c,m:l,um:u,o:{createElement:d}}}=r,f=d(`div`);r.activate=(e,t,n,r,i)=>{let a=e.component;l(e,t,n,0,s),c(a.vnode,e,t,n,a,s,r,e.slotScopeIds,i),Lo(()=>{a.isDeactivated=!1,a.a&&le(a.a);let t=e.props&&e.props.onVnodeMounted;t&&As(t,a.parent,e)},s)},r.deactivate=e=>{let t=e.component;qo(t.m),qo(t.a),l(e,f,null,1,s),Lo(()=>{t.da&&le(t.da);let n=e.props&&e.props.onVnodeUnmounted;n&&As(n,t.parent,e),t.isDeactivated=!0},s)};function p(e){qi(e),u(e,n,s,!0)}function m(e){i.forEach((t,n)=>{let r=$s(Li(t)?t.type.__asyncResolved||{}:t.type);r&&!e(r)&&h(n)})}function h(e){let t=i.get(e);t&&(!o||!vs(t,o))?p(t):o&&qi(o),i.delete(e),a.delete(e)}Dr(()=>[e.include,e.exclude],([e,t])=>{e&&m(t=>Hi(e,t)),t&&m(e=>!Hi(t,e))},{flush:`post`,deep:!0});let g=null,_=()=>{g!=null&&(Yo(n.subTree.type)?Lo(()=>{i.set(g,Ji(n.subTree))},n.subTree.suspense):i.set(g,Ji(n.subTree)))};return Qi(_),ea(_),ta(()=>{i.forEach(e=>{let{subTree:t,suspense:r}=n,i=Ji(t);if(e.type===i.type&&e.key===i.key){qi(i);let e=i.component.da;e&&Lo(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(!_s(r)||!(r.shapeFlag&4)&&!(r.shapeFlag&128))return o=null,r;let s=Ji(r);if(s.type===ls)return o=null,s;let c=s.type,l=$s(Li(s)?s.type.__asyncResolved||{}:c),{include:u,exclude:d,max:f}=e;if(u&&(!l||!Hi(u,l))||d&&l&&Hi(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=ws(s),r.shapeFlag&128&&(r.ssContent=s)),g=p,m?(s.el=m.el,s.component=m.component,s.transition&&ii(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,Yo(r.type)?r:s}}};function Hi(e,t){return p(e)?e.some(e=>Hi(e,t)):y(e)?e.split(`,`).includes(t):_(e)?(e.lastIndex=0,e.test(t)):!1}function Ui(e,t){Gi(e,`a`,t)}function Wi(e,t){Gi(e,`da`,t)}function Gi(e,t,n=Ps){let r=e.__wdc||=()=>{let t=n;for(;t;){if(t.isDeactivated)return;t=t.parent}return e()};if(Yi(t,r,n),n){let e=n.parent;for(;e&&e.parent;)Bi(e.parent.vnode)&&Ki(r,t,n,e),e=e.parent}}function Ki(e,t,n,r){let i=Yi(t,e,r,!0);na(()=>{u(r[t],i)},n)}function qi(e){e.shapeFlag&=-257,e.shapeFlag&=-513}function Ji(e){return e.shapeFlag&128?e.ssContent:e}function Yi(e,t,n=Ps,r=!1){if(n){let i=n[e]||(n[e]=[]),a=t.__weh||=(...r)=>{nt();let i=Rs(n),a=Un(t,n,e,r);return i(),rt(),a};return r?i.unshift(a):i.push(a),a}}var Xi=e=>(t,n=Ps)=>{(!Vs||e===`sp`)&&Yi(e,(...e)=>t(...e),n)},Zi=Xi(`bm`),Qi=Xi(`m`),$i=Xi(`bu`),ea=Xi(`u`),ta=Xi(`bum`),na=Xi(`um`),ra=Xi(`sp`),ia=Xi(`rtg`),aa=Xi(`rtc`);function oa(e,t=Ps){Yi(`ec`,e,t)}var sa=`components`,ca=`directives`;function la(e,t){return pa(sa,e,!0,t)||e}var ua=Symbol.for(`v-ndc`);function da(e){return y(e)?pa(sa,e,!1)||e:e||ua}function fa(e){return pa(ca,e)}function pa(e,t,n=!0,r=!1){let i=dr||Ps;if(i){let n=i.type;if(e===sa){let e=$s(n,!1);if(e&&(e===t||e===E(t)||e===se(E(t))))return n}let a=ma(i[e]||n[e],t)||ma(i.appContext[e],t);return!a&&r?n:a}}function ma(e,t){return e&&(e[t]||e[E(t)]||e[se(E(t))])}function ha(e,t,n,r){let i,a=n&&n[r],o=p(e);if(o||y(e)){let n=o&&nn(e),r=!1,s=!1;n&&(r=!an(e),s=rn(e),e=_t(e)),i=Array(e.length);for(let n=0,o=e.length;n<o;n++)i[n]=t(r?s?ln(cn(e[n])):cn(e[n]):e[n],n,void 0,a&&a[n])}else if(typeof e==`number`){i=Array(e);for(let n=0;n<e;n++)i[n]=t(n+1,n,void 0,a&&a[n])}else if(x(e)){if(e[Symbol.iterator])i=Array.from(e,(e,n)=>t(e,n,void 0,a&&a[n]));else{let n=Object.keys(e);i=Array(n.length);for(let r=0,o=n.length;r<o;r++){let o=n[r];i[r]=t(e[o],o,r,a&&a[r])}}}else i=[];return n&&(n[r]=i),i}function ga(e,t){for(let n=0;n<t.length;n++){let r=t[n];if(p(r))for(let t=0;t<r.length;t++)e[r[t].name]=r[t].fn;else r&&(e[r.name]=r.key?(...e)=>{let t=r.fn(...e);return t&&(t.key=r.key),t}:r.fn)}return e}function F(e,t,n,r,i,a){if(n??={},dr.ce||dr.parent&&Li(dr.parent)&&dr.parent.ce){let e=a!=null&&n.key==null?l({},n,{key:a}):n,i=Object.keys(e).length>0;return t!=="default"&&(e.name=t),L(),z(I,null,[V(`slot`,e,r&&r())],i?-2:64)}let o=e[t];o&&o._c&&(o._d=!1);let s=ds.length;L();let c;try{let i=o&&_a(o(n)),s=n.key||a||i&&i.key;c=z(I,{key:(s&&!b(s)?s:`_${t}`)+(!i&&r?`_fb`:``)},i||(r?r():[]),i&&e._===1?64:-2)}catch(e){for(let e=ds.length;e>s;e--)ps();throw e}finally{o&&o._c&&(o._d=!0)}return!i&&c.scopeId&&(c.slotScopeIds=[c.scopeId+`-s`]),c}function _a(e){return e.some(e=>!_s(e)||!(e.type===ls||e.type===I&&!_a(e.children)))?e:null}function va(e,t){let n={};for(let r in e)n[t&&/[A-Z]/.test(r)?`on:${r}`:ce(r)]=e[r];return n}var ya=e=>e?Bs(e)?Qs(e):ya(e.parent):null,ba=l(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>e.props,$attrs:e=>e.attrs,$slots:e=>e.slots,$refs:e=>e.refs,$parent:e=>ya(e.parent),$root:e=>ya(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>Wa(e),$forceUpdate:e=>e.f||=()=>{tr(e.update)},$nextTick:e=>e.n||=$n.bind(e.proxy),$watch:e=>kr.bind(e)}),xa=(e,t)=>e!==r&&!e.__isScriptSetup&&f(e,t),Sa={get({_:e},t){if(t===`__v_skip`)return!0;let{ctx:n,setupState:i,data:a,props:o,accessCache:s,type:c,appContext:l}=e;if(t[0]!==`$`){let e=s[t];if(e!==void 0)switch(e){case 1:return i[t];case 2:return a[t];case 4:return n[t];case 3:return o[t]}else if(xa(i,t))return s[t]=1,i[t];else if(a!==r&&f(a,t))return s[t]=2,a[t];else if(f(o,t))return s[t]=3,o[t];else if(n!==r&&f(n,t))return s[t]=4,n[t];else za&&(s[t]=0)}let u=ba[t],d,p;if(u)return t===`$attrs`&&pt(e.attrs,`get`,``),u(e);if((d=c.__cssModules)&&(d=d[t]))return d;if(n!==r&&f(n,t))return s[t]=4,n[t];if(p=l.config.globalProperties,f(p,t))return p[t]},set({_:e},t,n){let{data:i,setupState:a,ctx:o}=e;return xa(a,t)?(a[t]=n,!0):i!==r&&f(i,t)?(i[t]=n,!0):f(e.props,t)||t[0]===`$`&&t.slice(1)in e?!1:(o[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:i,appContext:a,props:o,type:s}},c){let l;return!!(n[c]||e!==r&&c[0]!==`$`&&f(e,c)||xa(t,c)||f(o,c)||f(i,c)||f(ba,c)||f(a.config.globalProperties,c)||(l=s.__cssModules)&&l[c])},defineProperty(e,t,n){return n.get==null?f(n,`value`)&&this.set(e,t,n.value,null):e._.accessCache[t]=0,Reflect.defineProperty(e,t,n)}},Ca=l({},Sa,{get(e,t){if(t!==Symbol.unscopables)return Sa.get(e,t,e)},has(e,t){return t[0]!==`_`&&!he(t)}});function wa(){return null}function Ta(){return null}function Ea(e){}function Da(e){}function Oa(){return null}function ka(){}function Aa(e,t){return null}function ja(){return Na(`useSlots`).slots}function Ma(){return Na(`useAttrs`).attrs}function Na(e){let t=Fs();return t.setupContext||=Zs(t)}function Pa(e){return p(e)?e.reduce((e,t)=>(e[t]=null,e),{}):e}function Fa(e,t){let n=Pa(e);for(let e in t){if(e.startsWith(`__skip`))continue;let r=n[e];r?p(r)||v(r)?r=n[e]={type:r,default:t[e]}:r.default=t[e]:r===null&&(r=n[e]={default:t[e]}),r&&t[`__skip_${e}`]&&(r.skipFactory=!0)}return n}function Ia(e,t){return!e||!t?e||t:p(e)&&p(t)?e.concat(t):l({},Pa(e),Pa(t))}function La(e,t){let n={};for(let r in e)t.includes(r)||Object.defineProperty(n,r,{enumerable:!0,get:()=>e[r]});return n}function Ra(e){let t=Fs(),n=Vs,r=e();zs(),n&&Ls(!1);let i=()=>{Rs(t),n&&Ls(!0)},a=()=>{Fs()!==t&&t.scope.off(),zs(),n&&Ls(!1)};return S(r)&&(r=r.catch(e=>{throw i(),Promise.resolve().then(()=>Promise.resolve().then(a)),e})),[r,()=>{i(),Promise.resolve().then(a)}]}var za=!0;function Ba(e){let t=Wa(e),n=e.proxy,r=e.ctx;za=!1,t.beforeCreate&&Ha(t.beforeCreate,e,`bc`);let{data:i,computed:o,methods:s,watch:c,provide:l,inject:u,created:d,beforeMount:f,mounted:m,beforeUpdate:h,updated:g,activated:_,deactivated:y,beforeDestroy:b,beforeUnmount:S,destroyed:C,unmounted:w,render:ee,renderTracked:te,renderTriggered:T,errorCaptured:ne,serverPrefetch:re,expose:ie,inheritAttrs:E,components:ae,directives:oe,filters:se}=t;if(u&&Va(u,r,null),s)for(let e in s){let t=s[e];v(t)&&(r[e]=t.bind(n))}if(i){let t=i.call(n,n);x(t)&&(e.data=Zt(t))}if(za=!0,o)for(let e in o){let t=o[e],i=W({get:v(t)?t.bind(n,n):v(t.get)?t.get.bind(n,n):a,set:!v(t)&&v(t.set)?t.set.bind(n):a});Object.defineProperty(r,e,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e})}if(c)for(let e in c)Ua(c[e],r,n,e);if(l){let e=v(l)?l.call(n):l;Reflect.ownKeys(e).forEach(t=>{yr(t,e[t])})}d&&Ha(d,e,`c`);function ce(e,t){p(t)?t.forEach(t=>e(t.bind(n))):t&&e(t.bind(n))}if(ce(Zi,f),ce(Qi,m),ce($i,h),ce(ea,g),ce(Ui,_),ce(Wi,y),ce(oa,ne),ce(aa,te),ce(ia,T),ce(ta,S),ce(na,w),ce(ra,re),p(ie)){if(ie.length){let t=e.exposed||={};ie.forEach(e=>{Object.defineProperty(t,e,{get:()=>n[e],set:t=>n[e]=t,enumerable:!0})})}else e.exposed||={}}ee&&e.render===a&&(e.render=ee),E!=null&&(e.inheritAttrs=E),ae&&(e.components=ae),oe&&(e.directives=oe),re&&si(e)}function Va(e,t,n=a){p(e)&&(e=Ya(e));for(let n in e){let r=e[n],i;i=x(r)?`default`in r?br(r.from||n,r.default,!0):br(r.from||n):br(r),un(i)?Object.defineProperty(t,n,{enumerable:!0,configurable:!0,get:()=>i.value,set:e=>i.value=e}):t[n]=i}}function Ha(e,t,n){Un(p(e)?e.map(e=>e.bind(t.proxy)):e.bind(t.proxy),t,n)}function Ua(e,t,n,r){let i=r.includes(`.`)?Ar(n,r):()=>n[r];if(y(e)){let n=t[e];v(n)&&Dr(i,n)}else if(v(e))Dr(i,e.bind(n));else if(x(e)){if(p(e))e.forEach(e=>Ua(e,t,n,r));else{let r=v(e.handler)?e.handler.bind(n):t[e.handler];v(r)&&Dr(i,r,e)}}}function Wa(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=>Ga(c,e,o,!0)),Ga(c,t,o)),x(t)&&a.set(t,c),c}function Ga(e,t,n,r=!1){let{mixins:i,extends:a}=t;a&&Ga(e,a,n,!0),i&&i.forEach(t=>Ga(e,t,n,!0));for(let i in t)if(!(r&&i===`expose`)){let r=Ka[i]||n&&n[i];e[i]=r?r(e[i],t[i]):t[i]}return e}var Ka={data:qa,props:Qa,emits:Qa,methods:Za,computed:Za,beforeCreate:Xa,created:Xa,beforeMount:Xa,mounted:Xa,beforeUpdate:Xa,updated:Xa,beforeDestroy:Xa,beforeUnmount:Xa,destroyed:Xa,unmounted:Xa,activated:Xa,deactivated:Xa,errorCaptured:Xa,serverPrefetch:Xa,components:Za,directives:Za,watch:$a,provide:qa,inject:Ja};function qa(e,t){return t?e?function(){return l(v(e)?e.call(this,this):e,v(t)?t.call(this,this):t)}:t:e}function Ja(e,t){return Za(Ya(e),Ya(t))}function Ya(e){if(p(e)){let t={};for(let n=0;n<e.length;n++)t[e[n]]=e[n];return t}return e}function Xa(e,t){return e?[...new Set([].concat(e,t))]:t}function Za(e,t){return e?l(Object.create(null),e,t):t}function Qa(e,t){return e?p(e)&&p(t)?[...new Set([...e,...t])]:l(Object.create(null),Pa(e),Pa(t??{})):t}function $a(e,t){if(!e)return t;if(!t)return e;let n=l(Object.create(null),e);for(let r in t)n[r]=Xa(e[r],t[r]);return n}function eo(){return{app:null,config:{isNativeTag:o,performance:!1,globalProperties:{},optionMergeStrategies:{},errorHandler:void 0,warnHandler:void 0,compilerOptions:{}},mixins:[],components:{},directives:{},provides:Object.create(null),optionsCache:new WeakMap,propsCache:new WeakMap,emitsCache:new WeakMap}}var to=0;function no(e,t){return function(n,r=null){v(n)||(n=l({},n)),r!=null&&!x(r)&&(r=null);let i=eo(),a=new WeakSet,o=[],s=!1,c=i.app={_uid:to++,_component:n,_props:r,_container:null,_context:i,_instance:null,version:ic,get config(){return i.config},set config(e){},use(e,...t){return a.has(e)||(e&&v(e.install)?(a.add(e),e.install(c,...t)):v(e)&&(a.add(e),e(c,...t))),c},mixin(e){return i.mixins.includes(e)||i.mixins.push(e),c},component(e,t){return t?(i.components[e]=t,c):i.components[e]},directive(e,t){return t?(i.directives[e]=t,c):i.directives[e]},mount(a,o,l){if(!s){let u=c._ceVNode||V(n,r);return u.appContext=i,l===!0?l=`svg`:l===!1&&(l=void 0),o&&t?t(u,a):e(u,a,l),s=!0,c._container=a,a.__vue_app__=c,Qs(u.component)}},onUnmount(e){o.push(e)},unmount(){s&&(Un(o,c._instance,16),e(null,c._container),delete c._container.__vue_app__)},provide(e,t){return i.provides[e]=t,c},runWithContext(e){let t=ro;ro=c;try{return e()}finally{ro=t}}};return c}}var ro=null;function io(e,t,n=r){let i=Fs(),a=E(t),o=oe(t),s=ao(e,a),c=yn((s,c)=>{let l,u=r,d;return Er(()=>{let t=e[a];D(l,t)&&(l=t,c())}),{get(){return s(),n.get?n.get(l):l},set(e){let s=n.set?n.set(e):e;if(!D(s,l)&&!(u!==r&&D(e,u)))return;let f=i.vnode.props,p=!!(f&&(t in f||a in f||o in f)&&(`onUpdate:${t}`in f||`onUpdate:${a}`in f||`onUpdate:${o}`in f));p||(l=e,c()),i.emit(`update:${t}`,s),D(e,u)&&(D(e,s)&&!D(s,d)||p&&u!==r&&!D(s,l))&&c(),u=e,d=s}}});return c[Symbol.iterator]=()=>{let e=0;return{next(){return e<2?{value:e++?s||r:c,done:!1}:{done:!0}}}},c}var ao=(e,t)=>t===`modelValue`||t===`model-value`?e.modelModifiers:e[`${t}Modifiers`]||e[`${E(t)}Modifiers`]||e[`${oe(t)}Modifiers`];function oo(e,t,...n){if(e.isUnmounted)return;let i=e.vnode.props||r,a=n,o=t.startsWith(`update:`),s=o&&ao(i,t.slice(7));s&&(s.trim&&(a=n.map(e=>y(e)?e.trim():e)),s.number&&(a=n.map(de)));let c,l=i[c=ce(t)]||i[c=ce(E(t))];!l&&o&&(l=i[c=ce(oe(t))]),l&&Un(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,Un(u,e,6,a)}}var so=new WeakMap;function co(e,t,n=!1){let r=n?so:t.emitsCache,i=r.get(e);if(i!==void 0)return i;let a=e.emits,o={},s=!1;if(!v(e)){let r=e=>{let n=co(e,t,!0);n&&(s=!0,l(o,n))};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}return!a&&!s?(x(e)&&r.set(e,null),null):(p(a)?a.forEach(e=>o[e]=null):l(o,a),x(e)&&r.set(e,o),o)}function lo(e,t){return!e||!s(t)?!1:(t=t.slice(2),t=t===`Once`?t:t.replace(/Once$/,``),f(e,t[0].toLowerCase()+t.slice(1))||f(e,oe(t))||f(e,t))}function uo(e){let{type:t,vnode:n,proxy:r,withProxy:i,propsOptions:[a],slots:o,attrs:s,emit:l,render:u,renderCache:d,props:f,data:p,setupState:m,ctx:h,inheritAttrs:g}=e,_=pr(e),v,y;try{if(n.shapeFlag&4){let e=i||r,t=e;v=Es(u.call(t,e,d,f,m,p,h)),y=s}else{let e=t;v=Es(e.length>1?e(f,{attrs:s,slots:o,emit:l}):e(f,null)),y=t.props?s:po(s)}}catch(t){ds.length=0,Wn(t,e,1),v=V(ls)}let b=v;if(y&&g!==!1){let e=Object.keys(y),{shapeFlag:t}=b;e.length&&t&7&&(a&&e.some(c)&&(y=mo(y,a)),b=ws(b,y,!1,!0))}return n.dirs&&(b=ws(b,null,!1,!0),b.dirs=b.dirs?b.dirs.concat(n.dirs):n.dirs),n.transition&&ii(Nr(b.type)&&ri(b)||b,n.transition),v=b,pr(_),v}function fo(e,t=!0){let n;for(let t=0;t<e.length;t++){let r=e[t];if(_s(r)){if(r.type!==ls||r.children===`v-if`){if(n)return;n=r}}else return}return n}var po=e=>{let t;for(let n in e)(n===`class`||n===`style`||s(n))&&((t||={})[n]=e[n]);return t},mo=(e,t)=>{let n={};for(let r in e)(!c(r)||!(r.slice(9)in t))&&(n[r]=e[r]);return n};function ho(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?go(r,o,l):!!o;if(c&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let n=e[t];if(_o(o,r,n)&&!lo(l,n))return!0}}}else return(i||s)&&(!s||!s.$stable)?!0:r===o?!1:r?!o||go(r,o,l):!!o;return!1}function go(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(_o(t,e,a)&&!lo(n,a))return!0}return!1}function _o(e,t,n){let r=e[n],i=t[n];return n===`style`&&x(r)&&x(i)?!Ee(r,i):r!==i}function vo({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 yo={},bo=()=>Object.create(yo),xo=e=>Object.getPrototypeOf(e)===yo;function So(e,t,n,r=!1){let i={},a=bo();e.propsDefaults=Object.create(null),wo(e,t,i,a);for(let t in e.propsOptions[0])t in i||(i[t]=void 0);e.props=n?r?i:Qt(i):e.type.props?i:a,e.attrs=a}function Co(e,t,n,r){let{props:i,attrs:a,vnode:{patchFlag:o}}=e,s=A(i),[c]=e.propsOptions,l=!1;if((r||o>0)&&!(o&16)){if(o&8){let n=e.vnode.dynamicProps;for(let r=0;r<n.length;r++){let o=n[r];if(lo(e.emitsOptions,o))continue;let u=t[o];if(c){if(f(a,o))u!==a[o]&&(a[o]=u,l=!0);else{let t=E(o);i[t]=To(c,s,t,u,e,!1)}}else u!==a[o]&&(a[o]=u,l=!0)}}}else{wo(e,t,i,a)&&(l=!0);let r;for(let a in s)(!t||!f(t,a)&&((r=oe(a))===a||!f(t,r)))&&(c?n&&(n[a]!==void 0||n[r]!==void 0)&&(i[a]=To(c,s,a,void 0,e,!0)):delete i[a]);if(a!==s)for(let e in a)(!t||!f(t,e))&&(delete a[e],l=!0)}l&&mt(e.attrs,`set`,``)}function wo(e,t,n,i){let[a,o]=e.propsOptions,s=!1,c;if(t)for(let r in t){if(ne(r))continue;let l=t[r],u;a&&f(a,u=E(r))?!o||!o.includes(u)?n[u]=l:(c||={})[u]=l:lo(e.emitsOptions,r)||(!(r in i)||l!==i[r])&&(i[r]=l,s=!0)}if(o){let t=A(n),i=c||r;for(let r=0;r<o.length;r++){let s=o[r];n[s]=To(a,t,s,i[s],e,!f(i,s))}}return s}function To(e,t,n,r,i,a){let o=e[n];if(o!=null){let e=f(o,`default`);if(e&&r===void 0){let e=o.default;if(o.type!==Function&&!o.skipFactory&&v(e)){let{propsDefaults:a}=i;if(n in a)r=a[n];else{let o=Rs(i);r=a[n]=e.call(null,t),o()}}else r=e;i.ce&&i.ce._setProp(n,r)}o[0]&&(a&&!e?r=!1:o[1]&&(r===``||r===oe(n))&&(r=!0))}return r}var Eo=new WeakMap;function Do(e,t,n=!1){let a=n?Eo:t.propsCache,o=a.get(e);if(o)return o;let s=e.props,c={},u=[],d=!1;if(!v(e)){let r=e=>{d=!0;let[n,r]=Do(e,t,!0);l(c,n),r&&u.push(...r)};!n&&t.mixins.length&&t.mixins.forEach(r),e.extends&&r(e.extends),e.mixins&&e.mixins.forEach(r)}if(!s&&!d)return x(e)&&a.set(e,i),i;if(p(s))for(let e=0;e<s.length;e++){let t=E(s[e]);Oo(t)&&(c[t]=r)}else if(s)for(let e in s){let t=E(e);if(Oo(t)){let n=s[e],r=c[t]=p(n)||v(n)?{type:n}:l({},n),i=r.type,a=!1,o=!0;if(p(i))for(let e=0;e<i.length;++e){let t=i[e],n=v(t)&&t.name;if(n===`Boolean`){a=!0;break}n===`String`&&(o=!1)}else a=v(i)&&i.name===`Boolean`;r[0]=a,r[1]=o,(a||f(r,`default`))&&u.push(t)}}let m=[c,u];return x(e)&&a.set(e,m),m}function Oo(e){return e[0]!==`$`&&!ne(e)}var ko=e=>e===`_`||e===`_ctx`||e===`$stable`,Ao=e=>p(e)?e.map(Es):[Es(e)],jo=(e,t,n)=>{if(t._n)return t;let r=N((...e)=>Ao(t(...e)),n);return r._c=!1,r},Mo=(e,t,n)=>{let r=e._ctx;for(let n in e){if(ko(n))continue;let i=e[n];if(v(i))t[n]=jo(n,i,r);else if(i!=null){let e=Ao(i);t[n]=()=>e}}},No=(e,t)=>{let n=Ao(t);e.slots.default=()=>n},Po=(e,t,n)=>{for(let r in t)(n||!ko(r))&&(e[r]=t[r])},Fo=(e,t,n)=>{let r=e.slots=bo();if(e.vnode.shapeFlag&32){let e=t._;e?(Po(r,t,n),n&&ue(r,`_`,e,!0)):Mo(t,r)}else t&&No(e,t)},Io=(e,t,n)=>{let{vnode:i,slots:a}=e,o=!0,s=r;if(i.shapeFlag&32){let e=t._;e?n&&e===1?o=!1:Po(a,t,n):(o=!t.$stable,Mo(t,a)),s=t}else t&&(No(e,t),s={default:1});if(o)for(let e in a)!ko(e)&&s[e]==null&&delete a[e]},Lo=as;function Ro(e){return Bo(e)}function zo(e){return Bo(e,yi)}function Bo(e,t){let n=me();n.__VUE__=!0;let{insert:o,remove:s,patchProp:c,createElement:l,createText:u,createComment:d,setText:f,setElementText:p,parentNode:m,nextSibling:h,setScopeId:g=a,insertStaticContent:_}=e,v=(e,t,n,r=null,i=null,a=null,o=void 0,s=null,c=!!t.dynamicChildren)=>{if(e===t)return;e&&!vs(e,t)&&(r=O(e),ge(e,i,a,!0),e=null),t.patchFlag===-2&&(c=!1,t.dynamicChildren=null);let{type:l,ref:u,shapeFlag:d}=t;switch(l){case cs:y(e,t,n,r);break;case ls:b(e,t,n,r);break;case us:e??x(t,n,r,o);break;case I:ae(e,t,n,r,i,a,o,s,c);break;default:d&1?w(e,t,n,r,i,a,o,s,c):d&6?oe(e,t,n,r,i,a,o,s,c):(d&64||d&128)&&l.process(e,t,n,r,i,a,o,s,c,Ce)}u!=null&&i?di(u,e&&e.ref,a,t||e,!t):u==null&&e&&e.ref!=null&&di(e.ref,null,a,e,!0)},y=(e,t,n,r)=>{if(e==null)o(t.el=u(t.children),n,r);else{let n=t.el=e.el;t.children!==e.children&&f(n,t.children)}},b=(e,t,n,r)=>{e==null?o(t.el=d(t.children||``),n,r):t.el=e.el},x=(e,t,n,r)=>{[e.el,e.anchor]=_(e.children,t,n,r,e.el,e.anchor)},S=({el:e,anchor:t},n,r)=>{let i;for(;e&&e!==t;)i=h(e),o(e,n,r),e=i;o(t,n,r)},C=({el:e,anchor:t})=>{let n;for(;e&&e!==t;)n=h(e),s(e),e=n;s(t)},w=(e,t,n,r,i,a,o,s,c)=>{if(t.type===`svg`?o=`svg`:t.type===`math`&&(o=`mathml`),e==null)ee(t,n,r,i,a,o,s,c);else{let n=e.el&&e.el._isVueCE?e.el:null;try{n&&n._beginPatch(),re(e,t,i,a,o,s,c)}finally{n&&n._endPatch()}}},ee=(e,t,n,r,i,a,s,u)=>{let d,f,{props:m,shapeFlag:h,transition:g,dirs:_}=e;if(d=e.el=l(e.type,a,m&&m.is,m),h&8?p(d,e.children):h&16&&T(e.children,d,null,r,i,Vo(e,a),s,u),_&&vr(e,null,r,`created`),te(d,e,e.scopeId,s,r),m){for(let e in m)e!==`value`&&!ne(e)&&c(d,e,null,m[e],a,r);`value`in m&&c(d,`value`,null,m.value,a),(f=m.onVnodeBeforeMount)&&As(f,r,e)}_&&vr(e,null,r,`beforeMount`);let v=Uo(i,g);v&&g.beforeEnter(d),o(d,t,n),((f=m&&m.onVnodeMounted)||v||_)&&Lo(()=>{try{f&&As(f,r,e),v&&g.enter(d),_&&vr(e,null,r,`mounted`)}finally{}},i)},te=(e,t,n,r,i)=>{if(n&&g(e,n),r)for(let t=0;t<r.length;t++)g(e,r[t]);if(i){let n=i.subTree;if(t===n||Yo(n.type)&&(n.ssContent===t||n.ssFallback===t)){let t=i.vnode;te(e,t,t.scopeId,t.slotScopeIds,i.parent)}}},T=(e,t,n,r,i,a,o,s,c=0)=>{for(let l=c;l<e.length;l++){let c=e[l]=s?Ds(e[l]):Es(e[l]);v(null,c,t,n,r,i,a,o,s)}},re=(e,t,n,i,a,o,s)=>{let l=t.el=e.el,{patchFlag:u,dynamicChildren:d,dirs:f}=t;u|=e.patchFlag&16;let m=e.props||r,h=t.props||r,g;if(n&&Ho(n,!1),(g=h.onVnodeBeforeUpdate)&&As(g,n,t,e),f&&vr(t,e,n,`beforeUpdate`),n&&Ho(n,!0),d&&(!e.dynamicChildren||e.dynamicChildren.length!==d.length)&&(u=0,s=!1,d=null),(m.innerHTML&&h.innerHTML==null||m.textContent&&h.textContent==null)&&p(l,``),d?ie(e.dynamicChildren,d,l,n,i,Vo(t,a),o):s||de(e,t,l,null,n,i,Vo(t,a),o,!1),u>0){if(u&16)E(l,m,h,n,a);else if(u&2&&m.class!==h.class&&c(l,`class`,null,h.class,a),u&4&&c(l,`style`,m.style,h.style,a),u&8){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let r=e[t],i=m[r],o=h[r];(o!==i||r===`value`)&&c(l,r,i,o,a,n)}}u&1&&e.children!==t.children&&p(l,t.children)}else!s&&d==null&&E(l,m,h,n,a);((g=h.onVnodeUpdated)||f)&&Lo(()=>{g&&As(g,n,t,e),f&&vr(t,e,n,`updated`)},i)},ie=(e,t,n,r,i,a,o)=>{for(let s=0;s<t.length;s++){let c=e[s],l=t[s],u=c.el&&(c.type===I||!vs(c,l)||c.shapeFlag&198)?m(c.el):n;v(c,l,u,null,r,i,a,o,!0)}},E=(e,t,n,i,a)=>{if(t!==n){if(t!==r)for(let r in t)!ne(r)&&!(r in n)&&c(e,r,t[r],null,a,i);for(let r in n){if(ne(r))continue;let o=n[r],s=t[r];o!==s&&r!==`value`&&c(e,r,s,o,a,i)}`value`in n&&c(e,`value`,t.value,n.value,a)}},ae=(e,t,n,r,i,a,s,c,l)=>{let d=t.el=e?e.el:u(``),f=t.anchor=e?e.anchor:u(``),{patchFlag:p,dynamicChildren:m,slotScopeIds:h}=t;h&&(c=c?c.concat(h):h),e==null?(o(d,n,r),o(f,n,r),T(t.children||[],n,f,i,a,s,c,l)):p>0&&p&64&&m&&e.dynamicChildren&&e.dynamicChildren.length===m.length?(ie(e.dynamicChildren,m,n,i,a,s,c),(t.key!=null||i&&t===i.subTree)&&Wo(e,t,!0)):de(e,t,n,f,i,a,s,c,l)},oe=(e,t,n,r,i,a,o,s,c)=>{t.slotScopeIds=s,e==null?t.shapeFlag&512?i.ctx.activate(t,n,r,o,c):se(t,n,r,i,a,o,c):ce(e,t,c)},se=(e,t,n,r,i,a,o)=>{let s=e.component=Ns(e,r,i);if(Bi(e)&&(s.ctx.renderer=Ce),Hs(s,!1,o),s.asyncDep){if(i&&i.registerDep(s,D,o),!e.el){let r=s.subTree=V(ls);b(null,r,t,n),e.placeholder=r.el}}else D(s,e,t,n,i,a,o)},ce=(e,t,n)=>{let r=t.component=e.component;if(ho(e,t,n)){if(r.asyncDep&&!r.asyncResolved){ue(r,t,n);return}r.next=t,r.update()}else t.el=e.el,r.vnode=t},D=(e,t,n,r,i,a,o)=>{let s=()=>{if(e.isMounted){let{next:t,bu:n,u:r,parent:s,vnode:c}=e;{let n=Ko(e);if(n){t&&(t.el=c.el,ue(e,t,o)),n.asyncDep.then(()=>{Lo(()=>{e.isUnmounted||l()},i)});return}}let u=t,d;Ho(e,!1),t?(t.el=c.el,ue(e,t,o)):t=c,n&&le(n),(d=t.props&&t.props.onVnodeBeforeUpdate)&&As(d,s,t,c),Ho(e,!0);let f=uo(e),p=e.subTree;e.subTree=f,v(p,f,m(p.el),O(p),e,i,a),t.el=f.el,u===null&&vo(e,f.el),r&&Lo(r,i),(d=t.props&&t.props.onVnodeUpdated)&&Lo(()=>As(d,s,t,c),i)}else{let o,{el:s,props:c}=t,{bm:l,m:u,parent:d,root:f,type:p}=e,m=Li(t);if(Ho(e,!1),l&&le(l),!m&&(o=c&&c.onVnodeBeforeMount)&&As(o,d,t),Ho(e,!0),s&&Te){let t=()=>{e.subTree=uo(e),Te(s,e.subTree,e,i,null)};m&&p.__asyncHydrate?p.__asyncHydrate(s,e,t):t()}else{f.ce&&f.ce._hasShadowRoot()&&f.ce._injectChildStyle(p,e.parent?e.parent.type:void 0);let o=e.subTree=uo(e);v(null,o,n,r,e,i,a),t.el=o.el}if(u&&Lo(u,i),!m&&(o=c&&c.onVnodeMounted)){let e=t;Lo(()=>As(o,d,e),i)}(t.shapeFlag&256||d&&Li(d.vnode)&&d.vnode.shapeFlag&256)&&e.a&&Lo(e.a,i),e.isMounted=!0,t=n=r=null}};e.scope.on();let c=e.effect=new ze(s);e.scope.off();let l=e.update=c.run.bind(c),u=e.job=c.runIfDirty.bind(c);u.i=e,u.id=e.uid,c.scheduler=()=>tr(u),Ho(e,!0),l()},ue=(e,t,n)=>{t.component=e;let r=e.vnode.props;e.vnode=t,e.next=null,Co(e,t.props,r,n),Io(e,t.children,n),nt(),ir(e),rt()},de=(e,t,n,r,i,a,o,s,c=!1)=>{let l=e&&e.children,u=e?e.shapeFlag:0,d=t.children,{patchFlag:f,shapeFlag:m}=t;if(f>0){if(f&128){pe(l,d,n,r,i,a,o,s,c);return}if(f&256){fe(l,d,n,r,i,a,o,s,c);return}}m&8?(u&16&&be(l,i,a),d!==l&&p(n,d)):u&16?m&16?pe(l,d,n,r,i,a,o,s,c):be(l,i,a,!0):(u&8&&p(n,``),m&16&&T(d,n,r,i,a,o,s,c))},fe=(e,t,n,r,a,o,s,c,l)=>{e||=i,t||=i;let u=e.length,d=t.length,f=Math.min(u,d),p;for(p=0;p<f;p++){let r=t[p]=l?Ds(t[p]):Es(t[p]);v(e[p],r,n,null,a,o,s,c,l)}u>d?be(e,a,o,!0,!1,f):T(t,n,r,a,o,s,c,l,f)},pe=(e,t,n,r,a,o,s,c,l)=>{let u=0,d=t.length,f=e.length-1,p=d-1;for(;u<=f&&u<=p;){let r=e[u],i=t[u]=l?Ds(t[u]):Es(t[u]);if(vs(r,i))v(r,i,n,null,a,o,s,c,l);else break;u++}for(;u<=f&&u<=p;){let r=e[f],i=t[p]=l?Ds(t[p]):Es(t[p]);if(vs(r,i))v(r,i,n,null,a,o,s,c,l);else break;f--,p--}if(u>f){if(u<=p){let e=p+1,i=e<d?t[e].el:r;for(;u<=p;)v(null,t[u]=l?Ds(t[u]):Es(t[u]),n,i,a,o,s,c,l),u++}}else if(u>p)for(;u<=f;)ge(e[u],a,o,!0),u++;else{let m=u,h=u,g=new Map;for(u=h;u<=p;u++){let e=t[u]=l?Ds(t[u]):Es(t[u]);e.key!=null&&g.set(e.key,u)}let _,y=0,b=p-h+1,x=!1,S=0,C=Array(b);for(u=0;u<b;u++)C[u]=0;for(u=m;u<=f;u++){let r=e[u];if(y>=b){ge(r,a,o,!0);continue}let i;if(r.key!=null)i=g.get(r.key);else for(_=h;_<=p;_++)if(C[_-h]===0&&vs(r,t[_])){i=_;break}i===void 0?ge(r,a,o,!0):(C[i-h]=u+1,i>=S?S=i:x=!0,v(r,t[i],n,null,a,o,s,c,l),y++)}let w=x?Go(C):i;for(_=w.length-1,u=b-1;u>=0;u--){let e=h+u,i=t[e],f=t[e+1],p=e+1<d?f.el||Jo(f):r;C[u]===0?v(null,i,n,p,a,o,s,c,l):x&&(_<0||u!==w[_]?he(i,n,p,2):_--)}}},he=(e,t,n,r,i=null)=>{let{el:a,type:c,transition:l,children:u,shapeFlag:d}=e;if(d&6){he(e.component.subTree,t,n,r);return}if(d&128){e.suspense.move(t,n,r);return}if(d&64){c.move(e,t,n,Ce);return}if(c===I){o(a,t,n);for(let e=0;e<u.length;e++)he(u[e],t,n,r);o(e.anchor,t,n);return}if(c===us){S(e,t,n);return}if(r!==2&&d&1&&l){if(r===0)l.persisted&&!a[Gr]?o(a,t,n):(l.beforeEnter(a),o(a,t,n),Lo(()=>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[Gr];a._isLeaving&&a[Gr](!0),l.persisted&&!e?u():r(a,()=>{u(),c&&c()})};i?i(a,u,d):d()}}else o(a,t,n)},ge=(e,t,n,r=!1,i=!1)=>{let{type:a,props:o,ref:s,children:c,dynamicChildren:l,shapeFlag:u,patchFlag:d,dirs:f,cacheIndex:p,memo:m}=e;if(d===-2&&(i=!1),s!=null&&(nt(),di(s,null,n,e,!0),rt()),p!=null&&(t.renderCache[p]=void 0),u&256){t.ctx.deactivate(e);return}let h=u&1&&f,g=!Li(e),_;if(g&&(_=o&&o.onVnodeBeforeUnmount)&&As(_,t,e),u&6)ye(e.component,n,r);else{if(u&128){e.suspense.unmount(n,r);return}h&&vr(e,null,t,`beforeUnmount`),u&64?e.type.remove(e,t,n,Ce,r):l&&!l.hasOnce&&(a!==I||d>0&&d&64)?be(l,t,n,!1,!0):(a===I&&d&384||!i&&u&16)&&be(c,t,n),r&&_e(e)}let v=m!=null&&p==null;(g&&(_=o&&o.onVnodeUnmounted)||h||v)&&Lo(()=>{_&&As(_,t,e),h&&vr(e,null,t,`unmounted`),v&&(e.el=null)},n)},_e=e=>{let{type:t,el:n,anchor:r,transition:i}=e;if(t===I){ve(n,r);return}if(t===us){C(e);return}let a=()=>{s(n),i&&!i.persisted&&i.afterLeave&&i.afterLeave()};if(e.shapeFlag&1&&i&&!i.persisted){let{leave:t,delayLeave:r}=i,o=()=>t(n,a);r?r(e.el,a,o):o()}else a()},ve=(e,t)=>{let n;for(;e!==t;)n=h(e),s(e),e=n;s(t)},ye=(e,t,n)=>{let{bum:r,scope:i,job:a,subTree:o,um:s,m:c,a:l}=e;qo(c),qo(l),r&&le(r),i.stop(),a&&(a.flags|=8,ge(o,e,t,n)),s&&Lo(s,t),Lo(()=>{e.isUnmounted=!0},t)},be=(e,t,n,r=!1,i=!1,a=0)=>{for(let o=a;o<e.length;o++)ge(e[o],t,n,r,i)},O=e=>{if(e.shapeFlag&6)return O(e.component.subTree);if(e.shapeFlag&128)return e.suspense.next();let t=h(e.anchor||e.el),n=t&&t[Mr];return n?h(n):t},xe=!1,Se=(e,t,n)=>{let r;e==null?t._vnode&&(ge(t._vnode,null,null,!0),r=t._vnode.component):v(t._vnode||null,e,t,null,null,null,n),t._vnode=e,xe||=(xe=!0,ir(r),ar(),!1)},Ce={p:v,um:ge,m:he,r:_e,mt:se,mc:T,pc:de,pbc:ie,n:O,o:e},we,Te;return t&&([we,Te]=t(Ce)),{render:Se,hydrate:we,createApp:no(Se,we)}}function Vo({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 Ho({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function Uo(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function Wo(e,t,n=!1){let r=e.children,i=t.children;if(p(r)&&p(i))for(let e=0;e<r.length;e++){let t=r[e],a=i[e];a.shapeFlag&1&&!a.dynamicChildren&&((a.patchFlag<=0||a.patchFlag===32)&&(a=i[e]=Ds(i[e]),a.el=t.el),!n&&a.patchFlag!==-2&&Wo(t,a)),a.type===cs&&(a.patchFlag===-1&&(a=i[e]=Ds(a)),a.el=t.el),a.type===ls&&!a.el&&(a.el=t.el)}}function Go(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 Ko(e){let t=e.subTree.component;if(t)return t.asyncDep&&!t.asyncResolved?t:Ko(t)}function qo(e){if(e)for(let t=0;t<e.length;t++)e[t].flags|=8}function Jo(e){if(e.placeholder)return e.placeholder;let t=e.component;return t?Jo(t.subTree):null}var Yo=e=>e.__isSuspense,Xo=0,Zo={name:`Suspense`,__isSuspense:!0,process(e,t,n,r,i,a,o,s,c,l){if(e==null)$o(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}es(e,t,n,r,i,o,s,c,l)}},hydrate:ns,normalize:rs};function Qo(e,t){let n=e.props&&e.props[t];v(n)&&n()}function $o(e,t,n,r,i,a,o,s,c){let{p:l,o:{createElement:u}}=c,d=u(`div`),f=e.suspense=ts(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?(Qo(e,`onPending`),Qo(e,`onFallback`),l(null,e.ssFallback,t,n,r,null,a,o),os(f,e.ssFallback)):f.resolve(!1,!0)}function es(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,vs(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),os(d,p)))):(d.pendingId=Xo++,_?(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),os(d,p))):m&&vs(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&&vs(m,f))c(m,f,n,r,i,d,a,o,s),os(d,f);else if(Qo(t,`onPending`),d.pendingBranch=f,d.pendingId=f.shapeFlag&512?f.component.suspenseId:Xo++,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 ts(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=ss(e);v&&t&&t.pendingBranch&&(_=t.pendingId,t.deps++);let y=e.props?fe(e.props.timeout):void 0,b=a,x={vnode:e,parent:t,parentComponent:n,namespace:o,container:r,hiddenContainer:i,deps:0,pendingId:Xo++,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),rr(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&&Lo(()=>r.ssFallback.el=null,x)),g||f(o,u,a,0)}x.isFallbackMountPending=!1,os(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&&rr(c),x.effects=[],v&&t&&t.pendingBranch&&_===t.pendingId&&(t.deps--,t.deps===0&&!n&&t.resolve()),Qo(r,`onResolve`)},fallback(e){if(!x.pendingBranch)return;let{vnode:t,activeBranch:n,parentComponent:r,container:i,namespace:a}=x;Qo(t,`onFallback`);let o=m(n),l=()=>{x.isFallbackMountPending=!1,x.isInFallback&&(d(null,e,i,o,r,null,a,s,c),os(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=>{Wn(t,e,0)}).then(a=>{if(e.isUnmounted||x.isUnmounted||x.pendingId!==e.suspenseId)return;zs(),e.asyncResolved=!0;let{vnode:s}=e;Ws(e,a,!1),i&&(s.el=i);let c=!i&&e.subTree.el;t(e,s,h(i||e.subTree.el),i?null:m(e.subTree),x,o,n),c&&(s.placeholder=null,g(c)),vo(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 ns(e,t,n,r,i,a,o,s,c){let l=t.suspense=ts(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 rs(e){let{shapeFlag:t,children:n}=e,r=t&32;e.ssContent=is(r?n.default:n),e.ssFallback=r?is(n.fallback):V(ls)}function is(e){let t;if(v(e)){let n=ms&&e._c;n&&(e._d=!1,L()),e=e(),n&&(e._d=!0,t=fs,ps())}return p(e)&&(e=fo(e)),e=Es(e),t&&!e.dynamicChildren&&(e.dynamicChildren=t.filter(t=>t!==e)),e}function as(e,t){t&&t.pendingBranch?p(e)?t.effects.push(...e):t.effects.push(e):rr(e)}function os(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,vo(r,i))}function ss(e){let t=e.props&&e.props.suspensible;return t!=null&&t!==!1}var I=Symbol.for(`v-fgt`),cs=Symbol.for(`v-txt`),ls=Symbol.for(`v-cmt`),us=Symbol.for(`v-stc`),ds=[],fs=null;function L(e=!1){ds.push(fs=e?null:[])}function ps(){ds.pop(),fs=ds[ds.length-1]||null}var ms=1;function hs(e,t=!1){ms+=e,e<0&&fs&&t&&(fs.hasOnce=!0)}function gs(e){return e.dynamicChildren=ms>0?fs||i:null,ps(),ms>0&&fs&&fs.push(e),e}function R(e,t,n,r,i,a){return gs(B(e,t,n,r,i,a,!0))}function z(e,t,n,r,i){return gs(V(e,t,n,r,i,!0))}function _s(e){return e?e.__v_isVNode===!0:!1}function vs(e,t){return e.type===t.type&&e.key===t.key}function ys(e){}var bs=({key:e})=>e??null,xs=({ref:e,ref_key:t,ref_for:n})=>(typeof e==`number`&&(e=``+e),e==null?null:y(e)||un(e)||v(e)?{i:dr,r:e,k:t,f:!!n}:e);function B(e,t=null,n=null,r=0,i=null,a=e===I?0:1,o=!1,s=!1){let c={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&bs(t),ref:t&&xs(t),scopeId:fr,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:dr};return s?(Os(c,n),a&128&&e.normalize(c)):n&&(c.shapeFlag|=y(n)?8:16),ms>0&&!o&&fs&&(c.patchFlag>0||a&6)&&c.patchFlag!==32&&fs.push(c),c}var V=Ss;function Ss(e,t=null,n=null,r=0,i=null,a=!1){if((!e||e===ua)&&(e=ls),_s(e)){let r=ws(e,t,!0);return n&&Os(r,n),ms>0&&!a&&fs&&(r.shapeFlag&6?fs[fs.indexOf(e)]=r:fs.push(r)),r.patchFlag=-2,r}if(ec(e)&&(e=e.__vccOpts),t){t=Cs(t);let{class:e,style:n}=t;e&&!y(e)&&(t.class=O(e)),x(n)&&(on(n)&&!p(n)&&(n=l({},n)),t.style=ge(n))}let o=y(e)?1:Yo(e)?128:Nr(e)?64:x(e)?4:v(e)?2:0;return B(e,t,n,r,i,o,a,!0)}function Cs(e){return e?on(e)||xo(e)?l({},e):e:null}function ws(e,t,n=!1,r=!1){let{props:i,ref:a,patchFlag:o,children:s,transition:c}=e,l=t?ks(i||{},t):i,u={__v_isVNode:!0,__v_skip:!0,type:e.type,props:l,key:l&&bs(l),ref:t&&t.ref?n&&a?p(a)?a.concat(xs(t)):[a,xs(t)]:xs(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!==I?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&&ws(e.ssContent),ssFallback:e.ssFallback&&ws(e.ssFallback),placeholder:e.placeholder,el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce};return c&&r&&ii(u,c.clone(u)),u}function H(e=` `,t=0){return V(cs,null,e,t)}function Ts(e,t){let n=V(us,null,e);return n.staticCount=t,n}function U(e=``,t=!1){return t?(L(),z(ls,null,e)):V(ls,null,e)}function Es(e){return e==null||typeof e==`boolean`?V(ls):p(e)?V(I,null,e.slice()):_s(e)?Ds(e):V(cs,null,String(e))}function Ds(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:ws(e)}function Os(e,t){let n=0,{shapeFlag:r}=e;if(t==null)t=null;else if(p(t))n=16;else if(typeof t==`object`){if(r&65){let n=t.default;n&&(n._c&&(n._d=!1),Os(e,n()),n._c&&(n._d=!0));return}{n=32;let r=t._;!r&&!xo(t)?t._ctx=dr:r===3&&dr&&(dr.slots._===1?t._=1:(t._=2,e.patchFlag|=1024))}}else if(v(t)){if(r&65){Os(e,{default:t});return}t={default:t,_ctx:dr},n=32}else t=String(t),r&64?(n=16,t=[H(t)]):n=8;e.children=t,e.shapeFlag|=n}function ks(...e){let t={};for(let n=0;n<e.length;n++){let r=e[n];for(let e in r)if(e===`class`)t.class!==r.class&&(t.class=O([t.class,r.class]));else if(e===`style`)t.style=ge([t.style,r.style]);else if(s(e)){let n=t[e],i=r[e];i&&n!==i&&!(p(n)&&n.includes(i))?t[e]=n?[].concat(n,i):i:i==null&&n==null&&!c(e)&&(t[e]=i)}else e!==``&&(t[e]=r[e])}return t}function As(e,t,n,r=null){Un(e,t,7,[n,r])}var js=eo(),Ms=0;function Ns(e,t,n){let i=e.type,a=(t?t.appContext:e.appContext)||js,o={uid:Ms++,vnode:e,type:i,parent:t,appContext:a,root:null,next:null,subTree:null,effect:null,update:null,job:null,scope:new Ne(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:t?t.provides:Object.create(a.provides),ids:t?t.ids:[``,0,0],accessCache:null,renderCache:[],components:null,directives:null,propsOptions:Do(i,a),emitsOptions:co(i,a),emit:null,emitted:null,propsDefaults:r,inheritAttrs:i.inheritAttrs,ctx:r,data:r,props:r,attrs:r,slots:r,refs:r,setupState:r,setupContext:null,suspense:n,suspenseId:n?n.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return o.ctx={_:o},o.root=t?t.root:o,o.emit=oo.bind(null,o),e.ce&&e.ce(o),o}var Ps=null,Fs=()=>Ps||dr,Is,Ls;{let e=me(),t=(t,n)=>{let r;return(r=e[t])||(r=e[t]=[]),r.push(n),e=>{r.length>1?r.forEach(t=>t(e)):r[0](e)}};Is=t(`__VUE_INSTANCE_SETTERS__`,e=>Ps=e),Ls=t(`__VUE_SSR_SETTERS__`,e=>Vs=e)}var Rs=e=>{let t=Ps;return Is(e),e.scope.on(),()=>{e.scope.off(),Is(t)}},zs=()=>{Ps&&Ps.scope.off(),Is(null)};function Bs(e){return e.vnode.shapeFlag&4}var Vs=!1;function Hs(e,t=!1,n=!1){t&&Ls(t);let{props:r,children:i}=e.vnode,a=Bs(e);So(e,r,a,t),Fo(e,i,n||t);let o=a?Us(e,t):void 0;return t&&Ls(!1),o}function Us(e,t){let n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,Sa);let{setup:r}=n;if(r){nt();let n=e.setupContext=r.length>1?Zs(e):null,i=Rs(e),a=Hn(r,e,0,[e.props,n]),o=S(a);if(rt(),i(),(o||e.sp)&&!Li(e)&&si(e),o){if(a.then(zs,zs),t)return a.then(n=>{Ls(!0);try{Ws(e,n,t)}finally{Ls(!1)}}).catch(t=>{Wn(t,e,0)});e.asyncDep=a}else Ws(e,a,t)}else Ys(e,t)}function Ws(e,t,n){v(t)?e.type.__ssrInlineRender?e.ssrRender=t:e.render=t:x(t)&&(e.setupState=_n(t)),Ys(e,n)}var Gs,Ks;function qs(e){Gs=e,Ks=e=>{e.render._rc&&(e.withProxy=new Proxy(e.ctx,Ca))}}var Js=()=>!Gs;function Ys(e,t,n){let r=e.type;if(!e.render){if(!t&&Gs&&!r.render){let t=r.template||Wa(e).template;if(t){let{isCustomElement:n,compilerOptions:i}=e.appContext.config,{delimiters:a,compilerOptions:o}=r,s=l(l({isCustomElement:n,delimiters:a},i),o);r.render=Gs(t,s)}}e.render=r.render||a,Ks&&Ks(e)}{let t=Rs(e);nt();try{Ba(e)}finally{rt(),t()}}}var Xs={get(e,t){return pt(e,`get`,``),e[t]}};function Zs(e){return{attrs:new Proxy(e.attrs,Xs),slots:e.slots,emit:e.emit,expose:t=>{e.exposed=t||{}}}}function Qs(e){return e.exposed?e.exposeProxy||=new Proxy(_n(sn(e.exposed)),{get(t,n){if(n in t)return t[n];if(n in ba)return ba[n](e)},has(e,t){return t in e||t in ba}}):e.proxy}function $s(e,t=!0){return v(e)?e.displayName||e.name:e.name||t&&e.__name}function ec(e){return v(e)&&`__vccOpts`in e}var W=(e,t)=>En(e,t,Vs);function G(e,t,n){try{hs(-1);let r=arguments.length;return r===2?x(t)&&!p(t)?_s(t)?V(e,null,[t]):V(e,t):V(e,null,t):(r>3?n=Array.prototype.slice.call(arguments,2):r===3&&_s(n)&&(n=[n]),V(e,t,n))}finally{hs(1)}}function tc(){}function nc(e,t,n,r){let i=n[r];if(i&&rc(i,e))return i;let a=t();return a.memo=e.slice(),a.cacheIndex=r,n[r]=a}function rc(e,t){let n=e.memo;if(n.length!=t.length)return!1;for(let e=0;e<n.length;e++)if(D(n[e],t[e]))return!1;return ms>0&&fs&&fs.push(e),!0}var ic=`3.5.41`,ac=a,oc=Vn,sc=cr,cc=ur,lc={createComponentInstance:Ns,setupComponent:Hs,renderComponentRoot:uo,setCurrentRenderingInstance:pr,isVNode:_s,normalizeVNode:Es,getComponentPublicInstance:Qs,ensureValidVNode:_a,pushWarningContext:Ln,popWarningContext:Rn},uc=void 0,dc=typeof window<`u`&&window.trustedTypes;if(dc)try{uc=dc.createPolicy(`vue`,{createHTML:e=>e})}catch{}var fc=uc?e=>uc.createHTML(e):e=>e,pc=`http://www.w3.org/2000/svg`,mc=`http://www.w3.org/1998/Math/MathML`,hc=typeof document<`u`?document:null,gc=hc&&hc.createElement(`template`),_c={insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{let t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,r)=>{let i=t===`svg`?hc.createElementNS(pc,e):t===`mathml`?hc.createElementNS(mc,e):n?hc.createElement(e,{is:n}):hc.createElement(e);return e===`select`&&r&&r.multiple!=null&&i.setAttribute(`multiple`,r.multiple),i},createText:e=>hc.createTextNode(e),createComment:e=>hc.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>hc.querySelector(e),setScopeId(e,t){e.setAttribute(t,``)},insertStaticContent(e,t,n,r,i,a){let o=n?n.previousSibling:t.lastChild;if(i&&(i===a||i.nextSibling))for(;t.insertBefore(i.cloneNode(!0),n),!(i===a||!(i=i.nextSibling)););else{gc.innerHTML=fc(r===`svg`?`<svg>${e}</svg>`:r===`mathml`?`<math>${e}</math>`:e);let i=gc.content;if(r===`svg`||r===`mathml`){let e=i.firstChild;for(;e.firstChild;)i.appendChild(e.firstChild);i.removeChild(e)}t.insertBefore(i,n)}return[o?o.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}},vc=`transition`,yc=`animation`,bc=Symbol(`_vtc`),xc={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},Sc=l({},Yr,xc),Cc=(e=>(e.displayName=`Transition`,e.props=Sc,e))((e,{slots:t})=>G($r,Ec(e),t)),wc=(e,t=[])=>{p(e)?e.forEach(e=>e(...t)):e&&e(...t)},Tc=e=>e?p(e)?e.some(e=>e.length>1):e.length>1:!1;function Ec(e){let t={};for(let n in e)n in xc||(t[n]=e[n]);if(e.css===!1)return t;let{name:n=`v`,type:r,duration:i,enterFromClass:a=`${n}-enter-from`,enterActiveClass:o=`${n}-enter-active`,enterToClass:s=`${n}-enter-to`,appearFromClass:c=a,appearActiveClass:u=o,appearToClass:d=s,leaveFromClass:f=`${n}-leave-from`,leaveActiveClass:p=`${n}-leave-active`,leaveToClass:m=`${n}-leave-to`}=e,h=Dc(i),g=h&&h[0],_=h&&h[1],{onBeforeEnter:v,onEnter:y,onEnterCancelled:b,onLeave:x,onLeaveCancelled:S,onBeforeAppear:C=v,onAppear:w=y,onAppearCancelled:ee=b}=t,te=(e,t,n,r)=>{e._enterCancelled=r,Ac(e,t?d:s),Ac(e,t?u:o),n&&n()},T=(e,t)=>{e._isLeaving=!1,Ac(e,f),Ac(e,m),Ac(e,p),t&&t()},ne=e=>(t,n)=>{let i=e?w:y,o=()=>te(t,e,n);wc(i,[t,o]),jc(()=>{Ac(t,e?c:a),kc(t,e?d:s),Tc(i)||Nc(t,r,g,o)})};return l(t,{onBeforeEnter(e){wc(v,[e]),kc(e,a),kc(e,o)},onBeforeAppear(e){wc(C,[e]),kc(e,c),kc(e,u)},onEnter:ne(!1),onAppear:ne(!0),onLeave(e,t){e._isLeaving=!0;let n=()=>T(e,t);kc(e,f),e._enterCancelled?(kc(e,p),Lc(e)):(Lc(e),kc(e,p)),jc(()=>{e._isLeaving&&(Ac(e,f),kc(e,m),Tc(x)||Nc(e,r,_,n))}),wc(x,[e,n])},onEnterCancelled(e){te(e,!1,void 0,!0),wc(b,[e])},onAppearCancelled(e){te(e,!0,void 0,!0),wc(ee,[e])},onLeaveCancelled(e){T(e),wc(S,[e])}})}function Dc(e){if(e==null)return null;if(x(e))return[Oc(e.enter),Oc(e.leave)];{let t=Oc(e);return[t,t]}}function Oc(e){return fe(e)}function kc(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.add(t)),(e[bc]||(e[bc]=new Set)).add(t)}function Ac(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.remove(t));let n=e[bc];n&&(n.delete(t),n.size||(e[bc]=void 0))}function jc(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}var Mc=0;function Nc(e,t,n,r){let i=e._endId=++Mc,a=()=>{i===e._endId&&r()};if(n!=null)return setTimeout(a,n);let{type:o,timeout:s,propCount:c}=Pc(e,t);if(!o)return r();let l=o+`end`,u=0,d=()=>{e.removeEventListener(l,f),a()},f=t=>{t.target===e&&++u>=c&&d()};setTimeout(()=>{u<c&&d()},s+1),e.addEventListener(l,f)}function Pc(e,t){let n=window.getComputedStyle(e),r=e=>(n[e]||``).split(`, `),i=r(`${vc}Delay`),a=r(`${vc}Duration`),o=Fc(i,a),s=r(`${yc}Delay`),c=r(`${yc}Duration`),l=Fc(s,c),u=null,d=0,f=0;t===vc?o>0&&(u=vc,d=o,f=a.length):t===yc?l>0&&(u=yc,d=l,f=c.length):(d=Math.max(o,l),u=d>0?o>l?vc:yc:null,f=u?u===vc?a.length:c.length:0);let p=u===vc&&/\b(?:transform|all)(?:,|$)/.test(r(`${vc}Property`).toString());return{type:u,timeout:d,propCount:f,hasTransform:p}}function Fc(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max(...t.map((t,n)=>Ic(t)+Ic(e[n])))}function Ic(e){return e===`auto`?0:Number(e.slice(0,-1).replace(`,`,`.`))*1e3}function Lc(e){return(e?e.ownerDocument:document).body.offsetHeight}function Rc(e,t,n){let r=e[bc];r&&(t=(t?[t,...r]:[...r]).join(` `)),t==null?e.removeAttribute(`class`):n?e.setAttribute(`class`,t):e.className=t}var zc=Symbol(`_vod`),Bc=Symbol(`_vsh`),Vc={name:`show`,beforeMount(e,{value:t},{transition:n}){e[zc]=e.style.display===`none`?``:e.style.display,n&&t?n.beforeEnter(e):Hc(e,t)},mounted(e,{value:t},{transition:n}){n&&t&&n.enter(e)},updated(e,{value:t,oldValue:n},{transition:r}){!t!=!n&&(r?t?(r.beforeEnter(e),Hc(e,!0),r.enter(e)):r.leave(e,()=>{Hc(e,!1)}):Hc(e,t))},beforeUnmount(e,{value:t}){Hc(e,t)}};function Hc(e,t){e.style.display=t?e[zc]:`none`,e[Bc]=!t}function Uc(){Vc.getSSRProps=({value:e})=>{if(!e)return{style:{display:`none`}}}}var Wc=Symbol(``);function Gc(e){let t=Fs();if(!t)return;let n=t.ut=(n=e(t.proxy))=>{Array.from(document.querySelectorAll(`[data-v-owner="${t.uid}"]`)).forEach(e=>qc(e,n))},r=()=>{let r=e(t.proxy);t.ce?qc(t.ce,r):Kc(t.subTree,r),n(r)};$i(()=>{rr(r)}),Qi(()=>{Dr(r,a,{flush:`post`});let e=new MutationObserver(r);e.observe(t.subTree.el.parentNode,{childList:!0}),na(()=>e.disconnect())})}function Kc(e,t){if(e.shapeFlag&128){let n=e.suspense;e=n.activeBranch,n.pendingBranch&&!n.isHydrating&&n.effects.push(()=>{Kc(n.activeBranch,t)})}for(;e.component;)e=e.component.subTree;if(e.shapeFlag&1&&e.el)qc(e.el,t);else if(e.type===I)e.children.forEach(e=>Kc(e,t));else if(e.type===us){let{el:n,anchor:r}=e;for(;n&&(qc(n,t),n!==r);)n=n.nextSibling}}function qc(e,t){if(e.nodeType===1){let n=e.style,r=``;for(let e in t){let i=je(t[e]);n.setProperty(`--${e}`,i),r+=`--${e}: ${i};`}n[Wc]=r}}var Jc=/(?:^|;)\s*display\s*:/;function Yc(e,t,n){let r=e.style,i=y(n),a=!1;if(n&&!i){if(t){if(y(t))for(let e of t.split(`;`)){let t=e.slice(0,e.indexOf(`:`)).trim();n[t]??Zc(r,t,``)}else for(let e in t)n[e]??Zc(r,e,``)}for(let i in n){i===`display`&&(a=!0);let o=n[i];o==null?Zc(r,i,``):tl(e,i,!y(t)&&t?t[i]:void 0,o)||Zc(r,i,o)}}else if(i){if(t!==n){let e=r[Wc];e&&(n+=`;`+e),r.cssText=n,a=Jc.test(n)}}else t&&e.removeAttribute(`style`);zc in e&&(e[zc]=a?r.display:``,e[Bc]&&(r.display=`none`))}var Xc=/\s*!important$/;function Zc(e,t,n){if(p(n))n.forEach(n=>Zc(e,t,n));else if(n??=``,t.startsWith(`--`))e.setProperty(t,n);else{let r=el(e,t);Xc.test(n)?e.setProperty(oe(r),n.replace(Xc,``),`important`):e[r]=n}}var Qc=[`Webkit`,`Moz`,`ms`],$c={};function el(e,t){let n=$c[t];if(n)return n;let r=E(t);if(r!==`filter`&&r in e)return $c[t]=r;r=se(r);for(let n=0;n<Qc.length;n++){let i=Qc[n]+r;if(i in e)return $c[t]=i}return t}function tl(e,t,n,r){return e.tagName===`TEXTAREA`&&(t===`width`||t===`height`)&&y(r)&&n===r}var nl=`http://www.w3.org/1999/xlink`;function rl(e,t,n,r,i,a=Ce(t)){r&&t.startsWith(`xlink:`)?n==null?e.removeAttributeNS(nl,t.slice(6,t.length)):e.setAttributeNS(nl,t,n):n==null||a&&!we(n)?e.removeAttribute(t):e.setAttribute(t,a?``:b(n)?String(n):n)}function il(e,t,n,r,i){if(t===`innerHTML`||t===`textContent`){n!=null&&(e[t]=t===`innerHTML`?fc(n):n);return}let a=e.tagName;if(t===`value`&&a!==`PROGRESS`&&!a.includes(`-`)){let r=a===`OPTION`?e.getAttribute(`value`)||``:e.value,i=n==null?e.type===`checkbox`?`on`:``:String(n);(r!==i||!(`_value`in e))&&(e.value=i),n??e.removeAttribute(t),e._value=n;return}let o=!1;if(n===``||n==null){let r=typeof e[t];r===`boolean`?n=we(n):n==null&&r===`string`?(n=``,o=!0):r===`number`&&(n=0,o=!0)}try{e[t]=n}catch{}o&&e.removeAttribute(i||t)}function al(e,t,n,r){e.addEventListener(t,n,r)}function ol(e,t,n,r){e.removeEventListener(t,n,r)}var sl=Symbol(`_vei`);function cl(e,t,n,r,i=null){let a=e[sl]||(e[sl]={}),o=a[t];if(r&&o)o.value=r;else{let[n,s]=dl(t);r?al(e,n,a[t]=hl(r,i),s):o&&(ol(e,n,o,s),a[t]=void 0)}}var ll=/(Once|Passive|Capture)$/,ul=/^on:?(?:Once|Passive|Capture)$/;function dl(e){let t,n;for(;(n=e.match(ll))&&!ul.test(e);)t||={},e=e.slice(0,e.length-n[1].length),t[n[1].toLowerCase()]=!0;return[e[2]===`:`?e.slice(3):oe(e.slice(2)),t]}var fl=0,pl=Promise.resolve(),ml=()=>fl||=(pl.then(()=>fl=0),Date.now());function hl(e,t){let n=e=>{if(!e._vts)e._vts=Date.now();else if(e._vts<=n.attached)return;let r=n.value;if(p(r)){let n=e.stopImmediatePropagation;e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0};let i=r.slice(),a=[e];for(let n=0;n<i.length&&!e._stopped;n++){let e=i[n];e&&Un(e,t,5,a)}}else Un(r,t,5,[e])};return n.value=e,n.attached=ml(),n}var gl=e=>e.charCodeAt(0)===111&&e.charCodeAt(1)===110&&e.charCodeAt(2)>96&&e.charCodeAt(2)<123,_l=(e,t,n,r,i,a)=>{let o=i===`svg`;t===`class`?Rc(e,r,o):t===`style`?Yc(e,n,r):s(t)?c(t)||cl(e,t,n,r,a):(t[0]===`.`?(t=t.slice(1),!0):t[0]===`^`?(t=t.slice(1),!1):vl(e,t,r,o))?(il(e,t,r),!e.tagName.includes(`-`)&&(t===`value`||t===`checked`||t===`selected`)&&rl(e,t,r,o,a,t!==`value`)):e._isVueCE&&(yl(e,t)||e._def.__asyncLoader&&(/[A-Z]/.test(t)||!y(r)))?il(e,E(t),r,a,t):(t===`true-value`?e._trueValue=r:t===`false-value`&&(e._falseValue=r),rl(e,t,r,o))};function vl(e,t,n,r){if(r)return!!(t===`innerHTML`||t===`textContent`||t in e&&gl(t)&&v(n));if(t===`spellcheck`||t===`draggable`||t===`translate`||t===`autocorrect`||t===`sandbox`&&e.tagName===`IFRAME`||t===`form`||t===`list`&&e.tagName===`INPUT`||t===`type`&&e.tagName===`TEXTAREA`)return!1;if(t===`width`||t===`height`){let t=e.tagName;if(t===`IMG`||t===`VIDEO`||t===`CANVAS`||t===`SOURCE`)return!1}return gl(t)&&y(n)?!1:t in e}function yl(e,t){let n=e._def.props;if(!n)return!1;let r=E(t);return Array.isArray(n)?n.some(e=>E(e)===r):Object.keys(n).some(e=>E(e)===r)}var bl={};function xl(e,t,n){let r=P(e,t);te(r)&&(r=l({},r,t));class i extends wl{constructor(e){super(r,e,n)}}return i.def=r,i}var Sl=((e,t)=>xl(e,t,hu)),Cl=typeof HTMLElement<`u`?HTMLElement:class{},wl=class e extends Cl{constructor(e,t={},n=mu){super(),this._def=e,this._props=t,this._createApp=n,this._isVueCE=!0,this._instance=null,this._app=null,this._nonce=this._def.nonce,this._connected=!1,this._resolved=!1,this._patching=!1,this._dirty=!1,this._numberProps=null,this._styleChildren=new WeakSet,this._styleAnchors=new WeakMap,this._ob=null,this.shadowRoot&&n!==mu?this._root=this.shadowRoot:e.shadowRoot===!1?this._root=this:(this.attachShadow(l({},e.shadowRootOptions,{mode:`open`})),this._root=this.shadowRoot)}connectedCallback(){if(!this.isConnected)return;!this.shadowRoot&&!this._resolved&&this._parseSlots(),this._connected=!0;let t=this;for(;t&&=t.assignedSlot||t.parentNode||t.host;)if(t instanceof e){this._parent=t;break}this._instance||(this._resolved?this._mount(this._def):t&&t._pendingResolve?this._pendingResolve=t._pendingResolve.then(()=>{if(this._pendingResolve=void 0,this.isConnected)return this._resolveDef()}):this._resolveDef())}_setParent(e=this._parent){e&&(this._instance.parent=e._instance,this._inheritParentContext(e))}_inheritParentContext(e=this._parent){e&&this._app&&Object.setPrototypeOf(this._app._context.provides,e._instance.provides)}disconnectedCallback(){this._connected=!1,$n(()=>{this._connected||(this._ob&&=(this._ob.disconnect(),null),this._app&&this._app.unmount(),this._instance&&(this._instance.ce=void 0),this._app=this._instance=null,this._teleportTargets&&=(this._teleportTargets.clear(),void 0))})}_processMutations(e){for(let t of e)this._setAttr(t.attributeName)}_resolveDef(){if(this._pendingResolve)return this._pendingResolve;for(let e=0;e<this.attributes.length;e++)this._setAttr(this.attributes[e].name);this._ob=new MutationObserver(this._processMutations.bind(this)),this._ob.observe(this,{attributes:!0});let e=(e,t=!1)=>{this._resolved=!0,this._pendingResolve=void 0;let{props:n,styles:r}=e,i;if(n&&!p(n))for(let e in n){let t=n[e];(t===Number||t&&t.type===Number)&&(e in this._props&&(this._props[e]=fe(this._props[e])),(i||=Object.create(null))[E(e)]=!0)}this._numberProps=i,this._resolveProps(e),this.shadowRoot&&this._applyStyles(r),this._mount(e)},t=this._def.__asyncLoader;if(t)return this._pendingResolve=t().then(t=>{t.configureApp=this._def.configureApp,e(this._def=t,!0)}),this._pendingResolve;e(this._def)}_mount(e){this._app=this._createApp(e),this._inheritParentContext(),e.configureApp&&e.configureApp(this._app),this._app._ceVNode=this._createVNode(),this._app.mount(this._root);let t=this._instance&&this._instance.exposed;if(t)for(let e in t)f(this,e)||Object.defineProperty(this,e,{get:()=>M(t[e])})}_resolveProps(e){let{props:t}=e,n=p(t)?t:Object.keys(t||{});for(let e of Object.keys(this))e[0]!==`_`&&n.includes(e)&&this._setProp(e,this[e]);for(let e of n.map(E))Object.defineProperty(this,e,{get(){return this._getProp(e)},set(t){this._setProp(e,t,!0,!this._patching)}})}_setAttr(e){if(e.startsWith(`data-v-`))return;let t=this.hasAttribute(e),n=t?this.getAttribute(e):bl,r=E(e);t&&this._numberProps&&this._numberProps[r]&&(n=fe(n)),this._setProp(r,n,!1,!0)}_getProp(e){return this._props[e]}_setProp(e,t,n=!0,r=!1){if(t!==this._props[e]&&(this._dirty=!0,t===bl?delete this._props[e]:(this._props[e]=t,e===`key`&&this._app&&(this._app._ceVNode.key=t)),r&&this._instance&&this._update(),n)){let n=this._ob;n&&(this._processMutations(n.takeRecords()),n.disconnect()),t===!0?this.setAttribute(oe(e),``):typeof t==`string`||typeof t==`number`?this.setAttribute(oe(e),t+``):t||this.removeAttribute(oe(e)),n&&n.observe(this,{attributes:!0})}}_update(){let e=this._createVNode();this._app&&(e.appContext=this._app._context),fu(e,this._root)}_createVNode(){let e={};this.shadowRoot||(e.onVnodeMounted=e.onVnodeUpdated=this._renderSlots.bind(this));let t=V(this._def,l(e,this._props));return this._instance||(t.ce=e=>{this._instance=e,e.ce=this,e.isCE=!0;let t=(e,t)=>{this.dispatchEvent(new CustomEvent(e,te(t[0])?l({detail:t},t[0]):{detail:t}))};e.emit=(e,...n)=>{t(e,n),oe(e)!==e&&t(oe(e),n)},this._setParent()}),t}_applyStyles(e,t,n){if(!e)return;if(t){if(t===this._def||this._styleChildren.has(t))return;this._styleChildren.add(t)}let r=this._nonce,i=this.shadowRoot,a=n?this._getStyleAnchor(n)||this._getStyleAnchor(this._def):this._getRootStyleInsertionAnchor(i),o=null;for(let s=e.length-1;s>=0;s--){let c=document.createElement(`style`);r&&c.setAttribute(`nonce`,r),c.textContent=e[s],i.insertBefore(c,o||a),o=c,s===0&&(n||this._styleAnchors.set(this._def,c),t&&this._styleAnchors.set(t,c))}}_getStyleAnchor(e){if(!e)return null;let t=this._styleAnchors.get(e);return t&&t.parentNode===this.shadowRoot?t:(t&&this._styleAnchors.delete(e),null)}_getRootStyleInsertionAnchor(e){for(let t=0;t<e.childNodes.length;t++){let n=e.childNodes[t];if(!(n instanceof HTMLStyleElement))return n}return null}_parseSlots(){let e=this._slots={},t;for(;t=this.firstChild;){let n=t.nodeType===1&&t.getAttribute(`slot`)||`default`;(e[n]||(e[n]=[])).push(t),this.removeChild(t)}}_renderSlots(){let e=this._getSlots(),t=this._instance.type.__scopeId;for(let n=0;n<e.length;n++){let r=e[n],i=r.getAttribute(`name`)||`default`,a=this._slots[i],o=r.parentNode;if(a)for(let e of a){if(t&&e.nodeType===1){let n=t+`-s`,r=document.createTreeWalker(e,1);e.setAttribute(n,``);let i;for(;i=r.nextNode();)i.setAttribute(n,``)}o.insertBefore(e,r)}else for(;r.firstChild;)o.insertBefore(r.firstChild,r);o.removeChild(r)}}_getSlots(){let e=[this];this._teleportTargets&&e.push(...this._teleportTargets);let t=new Set;for(let n of e){let e=n.querySelectorAll(`slot`);for(let n=0;n<e.length;n++)t.add(e[n])}return Array.from(t)}_injectChildStyle(e,t){this._applyStyles(e.styles,e,t)}_beginPatch(){this._patching=!0,this._dirty=!1}_endPatch(){this._patching=!1,this._dirty&&this._instance&&this._update()}_hasShadowRoot(){return this._def.shadowRoot!==!1}_removeChildStyle(e){}};function Tl(e){let t=Fs();return t&&t.ce||null}function El(){let e=Tl();return e&&e.shadowRoot}function Dl(e=`$style`){{let t=Fs();if(!t)return r;let n=t.type.__cssModules;return n&&n[e]||r}}var Ol=new WeakMap,kl=new WeakMap,Al=Symbol(`_moveCb`),jl=Symbol(`_enterCb`),Ml=(e=>(delete e.props.mode,e))({name:`TransitionGroup`,props:l({},Sc,{tag:String,moveClass:String}),setup(e,{slots:t}){let n=Fs(),r=qr(),i,a;return ea(()=>{if(!i.length)return;let t=e.moveClass||`${e.name||`v`}-move`;if(!Ll(i[0].el,n.vnode.el,t)){i=[];return}i.forEach(Nl),i.forEach(Pl);let r=i.filter(Fl);Lc(n.vnode.el),r.forEach(e=>{let n=e.el,r=n.style;kc(n,t),r.transform=r.webkitTransform=r.transitionDuration=``;let i=n[Al]=e=>{e&&e.target!==n||(!e||e.propertyName.endsWith(`transform`))&&(n.removeEventListener(`transitionend`,i),n[Al]=null,Ac(n,t))};n.addEventListener(`transitionend`,i)}),i=[]}),()=>{let o=A(e),s=Ec(o),c=o.tag||I;if(i=[],a)for(let e=0;e<a.length;e++){let t=a[e];t.el&&t.el instanceof Element&&!t.el[Bc]&&(i.push(t),ii(t,ti(t,s,r,n)),Ol.set(t,Il(t.el)))}a=t.default?ai(t.default()):[];for(let e=0;e<a.length;e++){let t=a[e];t.key!=null&&ii(t,ti(t,s,r,n))}return V(c,null,a)}}});function Nl(e){let t=e.el;t[Al]&&t[Al](),t[jl]&&t[jl]()}function Pl(e){kl.set(e,Il(e.el))}function Fl(e){let t=Ol.get(e),n=kl.get(e),r=t.left-n.left,i=t.top-n.top;if(r||i){let t=e.el,n=t.style,a=t.getBoundingClientRect(),o=1,s=1;return t.offsetWidth&&(o=a.width/t.offsetWidth),t.offsetHeight&&(s=a.height/t.offsetHeight),(!Number.isFinite(o)||o===0)&&(o=1),(!Number.isFinite(s)||s===0)&&(s=1),Math.abs(o-1)<.01&&(o=1),Math.abs(s-1)<.01&&(s=1),n.transform=n.webkitTransform=`translate(${r/o}px,${i/s}px)`,n.transitionDuration=`0s`,e}}function Il(e){let t=e.getBoundingClientRect();return{left:t.left,top:t.top}}function Ll(e,t,n){let r=e.cloneNode(),i=e[bc];i&&i.forEach(e=>{e.split(/\s+/).forEach(e=>e&&r.classList.remove(e))}),n.split(/\s+/).forEach(e=>e&&r.classList.add(e)),r.style.display=`none`;let a=t.nodeType===1?t:t.parentNode;a.appendChild(r);let{hasTransform:o}=Pc(r);return a.removeChild(r),o}var Rl=e=>{let t=e.props[`onUpdate:modelValue`]||!1;return p(t)?e=>le(t,e):t};function zl(e){e.target.composing=!0}function Bl(e){let t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event(`input`)))}var Vl=Symbol(`_assign`),Hl=Symbol(`_initialValue`);function Ul(e,t,n){return t&&(e=e.trim()),n&&(e=de(e)),e}var Wl={created(e,{modifiers:{lazy:t,trim:n,number:r}},i){e.parentNode&&(e.type===`text`?e[Hl]=e.defaultValue.replace(/[\r\n]/g,``):e.type===`textarea`&&(e[Hl]=e.defaultValue.replace(/\r\n?/g,`
`))),e[Vl]=Rl(i);let a=r||i.props&&i.props.type===`number`;al(e,t?`change`:`input`,t=>{t.target.composing||e[Vl](Ul(e.value,n,a))}),(n||a)&&al(e,`change`,()=>{e.value=Ul(e.value,n,a)}),t||(al(e,`compositionstart`,zl),al(e,`compositionend`,Bl),al(e,`change`,Bl))},mounted(e,{value:t,modifiers:{trim:n,number:r}}){let i=t??``,a=e[Hl];delete e[Hl],a!==void 0&&(e.type===`text`||e.type===`textarea`)&&e.value!==a?e[Vl](Ul(e.value,n,r)):e.value=i},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:r,trim:i,number:a}},o){if(e[Vl]=Rl(o),e.composing)return;let s=(a||e.type===`number`)&&!/^0\d/.test(e.value)?de(e.value):e.value,c=t??``;if(s===c)return;let l=e.getRootNode();(l instanceof Document||l instanceof ShadowRoot)&&l.activeElement===e&&e.type!==`range`&&(r&&t===n||i&&e.value.trim()===c)||(e.value=c)}},Gl={deep:!0,created(e,t,n){e[Vl]=Rl(n),al(e,`change`,()=>{let t=e._modelValue,n=Xl(e),r=e.checked,i=e[Vl];if(p(t)){let e=De(t,n),a=e!==-1;if(r&&!a)i(t.concat(n));else if(!r&&a){let n=[...t];n.splice(e,1),i(n)}}else if(h(t)){let e=new Set(t);r?e.add(n):e.delete(n),i(e)}else i(Zl(e,r))})},mounted:Kl,beforeUpdate(e,t,n){e[Vl]=Rl(n),Kl(e,t,n)}};function Kl(e,{value:t,oldValue:n},r){e._modelValue=t;let i;if(p(t))i=De(t,r.props.value)>-1;else if(h(t))i=t.has(r.props.value);else{if(t===n)return;i=Ee(t,Zl(e,!0))}e.checked!==i&&(e.checked=i)}var ql={created(e,{value:t},n){e.checked=Ee(t,n.props.value),e[Vl]=Rl(n),al(e,`change`,()=>{e[Vl](Xl(e))})},beforeUpdate(e,{value:t,oldValue:n},r){e[Vl]=Rl(r),t!==n&&(e.checked=Ee(t,r.props.value))}},Jl={deep:!0,created(e,{value:t,modifiers:{number:n}},r){e._modelValue=t,al(e,`change`,()=>{let t=Array.prototype.filter.call(e.options,e=>e.selected).map(e=>n?de(Xl(e)):Xl(e));e[Vl](e.multiple?h(e._modelValue)?new Set(t):t:t[0]),e._assigning=!0,$n(()=>{e._assigning=!1})}),e[Vl]=Rl(r)},mounted(e,{value:t}){Yl(e,t)},beforeUpdate(e,{value:t},n){e._modelValue=t,e[Vl]=Rl(n)},updated(e,{value:t}){e._assigning||Yl(e,t)}};function Yl(e,t){let n=e.multiple,r=p(t);if(!(n&&!r&&!h(t))){for(let i=0,a=e.options.length;i<a;i++){let a=e.options[i],o=Xl(a);if(n){if(r){let e=typeof o;a.selected=e===`string`||e===`number`?t.some(e=>String(e)===String(o)):De(t,o)>-1}else a.selected=t.has(o)}else if(Ee(Xl(a),t)){e.selectedIndex!==i&&(e.selectedIndex=i);return}}!n&&e.selectedIndex!==-1&&(e.selectedIndex=-1)}}function Xl(e){return`_value`in e?e._value:e.value}function Zl(e,t){let n=t?`_trueValue`:`_falseValue`;return n in e?e[n]:t}var Ql={created(e,t,n){eu(e,t,n,null,`created`)},mounted(e,t,n){eu(e,t,n,null,`mounted`)},beforeUpdate(e,t,n,r){eu(e,t,n,r,`beforeUpdate`)},updated(e,t,n,r){eu(e,t,n,r,`updated`)}};function $l(e,t){switch(e){case`SELECT`:return Jl;case`TEXTAREA`:return Wl;default:switch(t){case`checkbox`:return Gl;case`radio`:return ql;default:return Wl}}}function eu(e,t,n,r,i){let a=$l(e.tagName,n.props&&n.props.type)[i];a&&a(e,t,n,r)}function tu(){Wl.getSSRProps=({value:e})=>({value:e}),ql.getSSRProps=({value:e},t)=>{if(t.props&&Ee(t.props.value,e))return{checked:!0}},Gl.getSSRProps=({value:e},t)=>{if(p(e)){if(t.props&&De(e,t.props.value)>-1)return{checked:!0}}else if(h(e)){if(t.props&&e.has(t.props.value))return{checked:!0}}else if(e)return{checked:!0}},Ql.getSSRProps=(e,t)=>{if(typeof t.type!=`string`)return;let n=$l(t.type.toUpperCase(),t.props&&t.props.type);if(n.getSSRProps)return n.getSSRProps(e,t)}}var nu=[`ctrl`,`shift`,`alt`,`meta`],ru={stop:e=>e.stopPropagation(),prevent:e=>e.preventDefault(),self:e=>e.target!==e.currentTarget,ctrl:e=>!e.ctrlKey,shift:e=>!e.shiftKey,alt:e=>!e.altKey,meta:e=>!e.metaKey,left:e=>`button`in e&&e.button!==0,middle:e=>`button`in e&&e.button!==1,right:e=>`button`in e&&e.button!==2,exact:(e,t)=>nu.some(n=>e[`${n}Key`]&&!t.includes(n))},iu=(e,t)=>{if(!e)return e;let n=e._withMods||={},r=t.join(`.`);return n[r]||(n[r]=((n,...r)=>{for(let e=0;e<t.length;e++){let r=ru[t[e]];if(r&&r(n,t))return}return e(n,...r)}))},au={esc:`escape`,space:` `,up:`arrow-up`,left:`arrow-left`,right:`arrow-right`,down:`arrow-down`,delete:`backspace`},ou=(e,t)=>{let n=e._withKeys||={},r=t.join(`.`);return n[r]||(n[r]=(n=>{if(!(`key`in n))return;let r=oe(n.key);if(t.some(e=>e===r||au[e]===r))return e(n)}))},su=l({patchProp:_l},_c),cu,lu=!1;function uu(){return cu||=Ro(su)}function du(){return cu=lu?cu:zo(su),lu=!0,cu}var fu=((...e)=>{uu().render(...e)}),pu=((...e)=>{du().hydrate(...e)}),mu=((...e)=>{let t=uu().createApp(...e),{mount:n}=t;return t.mount=e=>{let r=_u(e);if(!r)return;let i=t._component;!v(i)&&!i.render&&!i.template&&(i.template=r.innerHTML),r.nodeType===1&&(r.textContent=``);let a=n(r,!1,gu(r));return r instanceof Element&&(r.removeAttribute(`v-cloak`),r.setAttribute(`data-v-app`,``)),a},t}),hu=((...e)=>{let t=du().createApp(...e),{mount:n}=t;return t.mount=e=>{let t=_u(e);if(t)return n(t,!0,gu(t))},t});function gu(e){if(e instanceof SVGElement)return`svg`;if(typeof MathMLElement==`function`&&e instanceof MathMLElement)return`mathml`}function _u(e){return y(e)?document.querySelector(e):e}var vu=!1,yu=()=>{vu||(vu=!0,tu(),Uc())},bu=t({BaseTransition:()=>$r,BaseTransitionPropsValidators:()=>Yr,Comment:()=>ls,DeprecationTypes:()=>null,EffectScope:()=>Ne,ErrorCodes:()=>Bn,ErrorTypeStrings:()=>oc,Fragment:()=>I,KeepAlive:()=>Vi,ReactiveEffect:()=>ze,Static:()=>us,Suspense:()=>Zo,Teleport:()=>Hr,Text:()=>cs,TrackOpTypes:()=>Dn,Transition:()=>Cc,TransitionGroup:()=>Ml,TriggerOpTypes:()=>On,VueElement:()=>wl,assertNumber:()=>zn,callWithAsyncErrorHandling:()=>Un,callWithErrorHandling:()=>Hn,camelize:()=>E,capitalize:()=>se,cloneVNode:()=>ws,compatUtils:()=>null,compile:()=>xu,computed:()=>W,createApp:()=>mu,createBlock:()=>z,createCommentVNode:()=>U,createElementBlock:()=>R,createElementVNode:()=>B,createHydrationRenderer:()=>zo,createPropsRestProxy:()=>La,createRenderer:()=>Ro,createSSRApp:()=>hu,createSlots:()=>ga,createStaticVNode:()=>Ts,createTextVNode:()=>H,createVNode:()=>V,customRef:()=>yn,defineAsyncComponent:()=>Ri,defineComponent:()=>P,defineCustomElement:()=>xl,defineEmits:()=>Ta,defineExpose:()=>Ea,defineModel:()=>ka,defineOptions:()=>Da,defineProps:()=>wa,defineSSRCustomElement:()=>Sl,defineSlots:()=>Oa,devtools:()=>sc,effect:()=>Qe,effectScope:()=>Pe,getCurrentInstance:()=>Fs,getCurrentScope:()=>Fe,getCurrentWatcher:()=>Mn,getTransitionRawChildren:()=>ai,guardReactiveProps:()=>Cs,h:()=>G,handleError:()=>Wn,hasInjectionContext:()=>xr,hydrate:()=>pu,hydrateOnIdle:()=>ji,hydrateOnInteraction:()=>Fi,hydrateOnMediaQuery:()=>Pi,hydrateOnVisible:()=>Ni,initCustomFormatter:()=>tc,initDirectivesForSSR:()=>yu,inject:()=>br,isMemoSame:()=>rc,isProxy:()=>on,isReactive:()=>nn,isReadonly:()=>rn,isRef:()=>un,isRuntimeOnly:()=>Js,isShallow:()=>an,isVNode:()=>_s,markRaw:()=>sn,mergeDefaults:()=>Fa,mergeModels:()=>Ia,mergeProps:()=>ks,nextTick:()=>$n,nodeOps:()=>_c,normalizeClass:()=>O,normalizeProps:()=>xe,normalizeStyle:()=>ge,onActivated:()=>Ui,onBeforeMount:()=>Zi,onBeforeUnmount:()=>ta,onBeforeUpdate:()=>$i,onDeactivated:()=>Wi,onErrorCaptured:()=>oa,onMounted:()=>Qi,onRenderTracked:()=>aa,onRenderTriggered:()=>ia,onScopeDispose:()=>Ie,onServerPrefetch:()=>ra,onUnmounted:()=>na,onUpdated:()=>ea,onWatcherCleanup:()=>Nn,openBlock:()=>L,patchProp:()=>_l,popScopeId:()=>hr,provide:()=>yr,proxyRefs:()=>_n,pushScopeId:()=>mr,queuePostFlushCb:()=>rr,reactive:()=>Zt,readonly:()=>$t,ref:()=>j,registerRuntimeCompiler:()=>qs,render:()=>fu,renderList:()=>ha,renderSlot:()=>F,resolveComponent:()=>la,resolveDirective:()=>fa,resolveDynamicComponent:()=>da,resolveFilter:()=>null,resolveTransitionHooks:()=>ti,setBlockTracking:()=>hs,setDevtoolsHook:()=>cc,setTransitionHooks:()=>ii,shallowReactive:()=>Qt,shallowReadonly:()=>en,shallowRef:()=>dn,ssrContextKey:()=>Sr,ssrUtils:()=>lc,stop:()=>$e,toDisplayString:()=>k,toHandlerKey:()=>ce,toHandlers:()=>va,toRaw:()=>A,toRef:()=>Cn,toRefs:()=>bn,toValue:()=>hn,transformVNodeArgs:()=>ys,triggerRef:()=>mn,unref:()=>M,useAttrs:()=>Ma,useCssModule:()=>Dl,useCssVars:()=>Gc,useHost:()=>Tl,useId:()=>oi,useModel:()=>io,useSSRContext:()=>Cr,useShadowRoot:()=>El,useSlots:()=>ja,useTemplateRef:()=>ci,useTransitionState:()=>qr,vModelCheckbox:()=>Gl,vModelDynamic:()=>Ql,vModelRadio:()=>ql,vModelSelect:()=>Jl,vModelText:()=>Wl,vShow:()=>Vc,version:()=>ic,warn:()=>ac,watch:()=>Dr,watchEffect:()=>wr,watchPostEffect:()=>Tr,watchSyncEffect:()=>Er,withAsyncContext:()=>Ra,withCtx:()=>N,withDefaults:()=>Aa,withDirectives:()=>_r,withKeys:()=>ou,withMemo:()=>nc,withModifiers:()=>iu,withScopeId:()=>gr}),xu=()=>{};function Su(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function Cu(e){if(Array.isArray(e))return e}function wu(e){if(Array.isArray(e))return Su(e)}function Tu(e,t){if(!(e instanceof t))throw TypeError(`Cannot call a class as a function`)}function Eu(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,`value`in r&&(r.writable=!0),Object.defineProperty(e,Lu(r.key),r)}}function Du(e,t,n){return t&&Eu(e.prototype,t),n&&Eu(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function Ou(e,t){var n=typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(!n){if(Array.isArray(e)||(n=zu(e))||t&&e&&typeof e.length==`number`){n&&(e=n);var r=0,i=function(){};return{s:i,n:function(){return r>=e.length?{done:!0}:{done:!1,value:e[r++]}},e:function(e){throw e},f:i}}throw TypeError(`Invalid attempt to iterate non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}var a,o=!0,s=!1;return{s:function(){n=n.call(e)},n:function(){var e=n.next();return o=e.done,e},e:function(e){s=!0,a=e},f:function(){try{o||n.return==null||n.return()}finally{if(s)throw a}}}}function K(e,t,n){return(t=Lu(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function ku(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function Au(e,t){var n=e==null?null:typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(n!=null){var r,i,a,o,s=[],c=!0,l=!1;try{if(a=(n=n.call(e)).next,t===0){if(Object(n)!==n)return;c=!1}else for(;!(c=(r=a.call(n)).done)&&(s.push(r.value),s.length!==t);c=!0);}catch(e){l=!0,i=e}finally{try{if(!c&&n.return!=null&&(o=n.return(),Object(o)!==o))return}finally{if(l)throw i}}return s}}function ju(){throw TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Mu(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Nu(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function q(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Nu(Object(n),!0).forEach(function(t){K(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Nu(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function Pu(e,t){return Cu(e)||Au(e,t)||zu(e,t)||ju()}function Fu(e){return wu(e)||ku(e)||zu(e)||Mu()}function Iu(e,t){if(typeof e!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(typeof r!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function Lu(e){var t=Iu(e,`string`);return typeof t==`symbol`?t:t+``}function Ru(e){"@babel/helpers - typeof";return Ru=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},Ru(e)}function zu(e,t){if(e){if(typeof e==`string`)return Su(e,t);var n={}.toString.call(e).slice(8,-1);return n===`Object`&&e.constructor&&(n=e.constructor.name),n===`Map`||n===`Set`?Array.from(e):n===`Arguments`||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?Su(e,t):void 0}}var Bu=function(){},Vu={},Hu={},Uu=null,Wu={mark:Bu,measure:Bu};try{typeof window<`u`&&(Vu=window),typeof document<`u`&&(Hu=document),typeof MutationObserver<`u`&&(Uu=MutationObserver),typeof performance<`u`&&(Wu=performance)}catch{}var Gu=(Vu.navigator||{}).userAgent,Ku=Gu===void 0?``:Gu,qu=Vu,Ju=Hu,Yu=Uu,Xu=Wu;qu.document;var Zu=!!Ju.documentElement&&!!Ju.head&&typeof Ju.addEventListener==`function`&&typeof Ju.createElement==`function`,Qu=~Ku.indexOf(`MSIE`)||~Ku.indexOf(`Trident/`),$u,ed=/fa(k|kd|s|r|l|t|d|dr|dl|dt|b|slr|slpr|wsb|tl|ns|nds|es|gt|jr|jfr|jdr|usb|ufsb|udsb|cr|ss|sr|sl|st|sds|sdr|sdl|sdt|sldr|slpdr|pr|ms|vs)?[\-\ ]/,td=/Font ?Awesome ?([567 ]*)(Solid|Regular|Light|Thin|Duotone|Brands|Free|Pro|Sharp Duotone|Sharp|Kit|Notdog Duo|Notdog|Chisel|Etch|Graphite|Thumbprint|Jelly Fill|Jelly Duo|Jelly|Utility|Utility Fill|Utility Duo|Slab Press|Slab|Slab Duo|Slab Press Duo|Pixel|Mosaic|Vellum|Whiteboard)?.*/i,nd={classic:{fa:`solid`,fas:`solid`,"fa-solid":`solid`,far:`regular`,"fa-regular":`regular`,fal:`light`,"fa-light":`light`,fat:`thin`,"fa-thin":`thin`,fab:`brands`,"fa-brands":`brands`},duotone:{fa:`solid`,fad:`solid`,"fa-solid":`solid`,"fa-duotone":`solid`,fadr:`regular`,"fa-regular":`regular`,fadl:`light`,"fa-light":`light`,fadt:`thin`,"fa-thin":`thin`},sharp:{fa:`solid`,fass:`solid`,"fa-solid":`solid`,fasr:`regular`,"fa-regular":`regular`,fasl:`light`,"fa-light":`light`,fast:`thin`,"fa-thin":`thin`},"sharp-duotone":{fa:`solid`,fasds:`solid`,"fa-solid":`solid`,fasdr:`regular`,"fa-regular":`regular`,fasdl:`light`,"fa-light":`light`,fasdt:`thin`,"fa-thin":`thin`},slab:{"fa-regular":`regular`,faslr:`regular`},"slab-press":{"fa-regular":`regular`,faslpr:`regular`},"slab-duo":{"fa-regular":`regular`,fasldr:`regular`},"slab-press-duo":{"fa-regular":`regular`,faslpdr:`regular`},thumbprint:{"fa-light":`light`,fatl:`light`},vellum:{"fa-solid":`solid`,favs:`solid`},pixel:{"fa-regular":`regular`,fapr:`regular`},mosaic:{"fa-solid":`solid`,fams:`solid`},whiteboard:{"fa-semibold":`semibold`,fawsb:`semibold`},notdog:{"fa-solid":`solid`,fans:`solid`},"notdog-duo":{"fa-solid":`solid`,fands:`solid`},etch:{"fa-solid":`solid`,faes:`solid`},graphite:{"fa-thin":`thin`,fagt:`thin`},jelly:{"fa-regular":`regular`,fajr:`regular`},"jelly-fill":{"fa-regular":`regular`,fajfr:`regular`},"jelly-duo":{"fa-regular":`regular`,fajdr:`regular`},chisel:{"fa-regular":`regular`,facr:`regular`},utility:{"fa-semibold":`semibold`,fausb:`semibold`},"utility-duo":{"fa-semibold":`semibold`,faudsb:`semibold`},"utility-fill":{"fa-semibold":`semibold`,faufsb:`semibold`}},rd={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},id=[`fa-classic`,`fa-duotone`,`fa-sharp`,`fa-sharp-duotone`,`fa-thumbprint`,`fa-whiteboard`,`fa-notdog`,`fa-notdog-duo`,`fa-chisel`,`fa-etch`,`fa-graphite`,`fa-jelly`,`fa-jelly-fill`,`fa-jelly-duo`,`fa-slab`,`fa-slab-press`,`fa-slab-press-duo`,`fa-slab-duo`,`fa-mosaic`,`fa-pixel`,`fa-vellum`,`fa-utility`,`fa-utility-duo`,`fa-utility-fill`],ad=`classic`,od=`duotone`,sd=`sharp`,cd=`sharp-duotone`,ld=`chisel`,ud=`etch`,dd=`graphite`,fd=`jelly`,pd=`jelly-duo`,md=`jelly-fill`,hd=`mosaic`,gd=`notdog`,_d=`notdog-duo`,vd=`pixel`,yd=`slab`,bd=`slab-duo`,xd=`slab-press`,Sd=`slab-press-duo`,Cd=`thumbprint`,wd=`utility`,Td=`utility-duo`,Ed=`utility-fill`,Dd=`vellum`,Od=`whiteboard`,kd=`Classic`,Ad=`Duotone`,jd=`Sharp`,Md=`Sharp Duotone`,Nd=`Chisel`,Pd=`Etch`,Fd=`Graphite`,Id=`Jelly`,Ld=`Jelly Duo`,Rd=`Jelly Fill`,zd=`Mosaic`,Bd=`Notdog`,Vd=`Notdog Duo`,Hd=`Pixel`,Ud=`Slab`,Wd=`Slab Duo`,Gd=`Slab Press`,Kd=`Slab Press Duo`,qd=`Thumbprint`,Jd=`Utility`,Yd=`Utility Duo`,Xd=`Utility Fill`,Zd=`Vellum`,Qd=`Whiteboard`,$d=[ad,od,sd,cd,ld,ud,dd,fd,pd,md,hd,gd,_d,vd,yd,bd,xd,Sd,Cd,wd,Td,Ed,Dd,Od];$u={},K(K(K(K(K(K(K(K(K(K($u,ad,kd),od,Ad),sd,jd),cd,Md),ld,Nd),ud,Pd),dd,Fd),fd,Id),pd,Ld),md,Rd),K(K(K(K(K(K(K(K(K(K($u,hd,zd),gd,Bd),_d,Vd),vd,Hd),yd,Ud),bd,Wd),xd,Gd),Sd,Kd),Cd,qd),wd,Jd),K(K(K(K($u,Td,Yd),Ed,Xd),Dd,Zd),Od,Qd);var ef={classic:{900:`fas`,400:`far`,normal:`far`,300:`fal`,100:`fat`},duotone:{900:`fad`,400:`fadr`,300:`fadl`,100:`fadt`},sharp:{900:`fass`,400:`fasr`,300:`fasl`,100:`fast`},"sharp-duotone":{900:`fasds`,400:`fasdr`,300:`fasdl`,100:`fasdt`},slab:{400:`faslr`},"slab-press":{400:`faslpr`},"slab-duo":{400:`fasldr`},"slab-press-duo":{400:`faslpdr`},vellum:{900:`favs`},mosaic:{900:`fams`},pixel:{400:`fapr`},whiteboard:{600:`fawsb`},thumbprint:{300:`fatl`},notdog:{900:`fans`},"notdog-duo":{900:`fands`},etch:{900:`faes`},graphite:{100:`fagt`},chisel:{400:`facr`},jelly:{400:`fajr`},"jelly-fill":{400:`fajfr`},"jelly-duo":{400:`fajdr`},utility:{600:`fausb`},"utility-duo":{600:`faudsb`},"utility-fill":{600:`faufsb`}},tf={"Font Awesome 7 Free":{900:`fas`,400:`far`},"Font Awesome 7 Pro":{900:`fas`,400:`far`,normal:`far`,300:`fal`,100:`fat`},"Font Awesome 7 Brands":{400:`fab`,normal:`fab`},"Font Awesome 7 Duotone":{900:`fad`,400:`fadr`,normal:`fadr`,300:`fadl`,100:`fadt`},"Font Awesome 7 Sharp":{900:`fass`,400:`fasr`,normal:`fasr`,300:`fasl`,100:`fast`},"Font Awesome 7 Sharp Duotone":{900:`fasds`,400:`fasdr`,normal:`fasdr`,300:`fasdl`,100:`fasdt`},"Font Awesome 7 Jelly":{400:`fajr`,normal:`fajr`},"Font Awesome 7 Jelly Fill":{400:`fajfr`,normal:`fajfr`},"Font Awesome 7 Jelly Duo":{400:`fajdr`,normal:`fajdr`},"Font Awesome 7 Slab":{400:`faslr`,normal:`faslr`},"Font Awesome 7 Slab Press":{400:`faslpr`,normal:`faslpr`},"Font Awesome 7 Slab Duo":{400:`fasldr`,normal:`fasldr`},"Font Awesome 7 Slab Press Duo":{400:`faslpdr`,normal:`faslpdr`},"Font Awesome 7 Pixel":{400:`fapr`,normal:`fapr`},"Font Awesome 7 Mosaic":{900:`fams`,normal:`fams`},"Font Awesome 7 Vellum":{900:`favs`,normal:`favs`},"Font Awesome 7 Thumbprint":{300:`fatl`,normal:`fatl`},"Font Awesome 7 Notdog":{900:`fans`,normal:`fans`},"Font Awesome 7 Notdog Duo":{900:`fands`,normal:`fands`},"Font Awesome 7 Etch":{900:`faes`,normal:`faes`},"Font Awesome 7 Graphite":{100:`fagt`,normal:`fagt`},"Font Awesome 7 Chisel":{400:`facr`,normal:`facr`},"Font Awesome 7 Whiteboard":{600:`fawsb`,normal:`fawsb`},"Font Awesome 7 Utility":{600:`fausb`,normal:`fausb`},"Font Awesome 7 Utility Duo":{600:`faudsb`,normal:`faudsb`},"Font Awesome 7 Utility Fill":{600:`faufsb`,normal:`faufsb`}},nf=new Map([[`classic`,{defaultShortPrefixId:`fas`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`,`brands`],futureStyleIds:[],defaultFontWeight:900}],[`duotone`,{defaultShortPrefixId:`fad`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`sharp`,{defaultShortPrefixId:`fass`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`sharp-duotone`,{defaultShortPrefixId:`fasds`,defaultStyleId:`solid`,styleIds:[`solid`,`regular`,`light`,`thin`],futureStyleIds:[],defaultFontWeight:900}],[`chisel`,{defaultShortPrefixId:`facr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`etch`,{defaultShortPrefixId:`faes`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`graphite`,{defaultShortPrefixId:`fagt`,defaultStyleId:`thin`,styleIds:[`thin`],futureStyleIds:[],defaultFontWeight:100}],[`jelly`,{defaultShortPrefixId:`fajr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`jelly-duo`,{defaultShortPrefixId:`fajdr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`jelly-fill`,{defaultShortPrefixId:`fajfr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`mosaic`,{defaultShortPrefixId:`fams`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`notdog`,{defaultShortPrefixId:`fans`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`notdog-duo`,{defaultShortPrefixId:`fands`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`pixel`,{defaultShortPrefixId:`fapr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab`,{defaultShortPrefixId:`faslr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-duo`,{defaultShortPrefixId:`fasldr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-press`,{defaultShortPrefixId:`faslpr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`slab-press-duo`,{defaultShortPrefixId:`faslpdr`,defaultStyleId:`regular`,styleIds:[`regular`],futureStyleIds:[],defaultFontWeight:400}],[`thumbprint`,{defaultShortPrefixId:`fatl`,defaultStyleId:`light`,styleIds:[`light`],futureStyleIds:[],defaultFontWeight:300}],[`utility`,{defaultShortPrefixId:`fausb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`utility-duo`,{defaultShortPrefixId:`faudsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`utility-fill`,{defaultShortPrefixId:`faufsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}],[`vellum`,{defaultShortPrefixId:`favs`,defaultStyleId:`solid`,styleIds:[`solid`],futureStyleIds:[],defaultFontWeight:900}],[`whiteboard`,{defaultShortPrefixId:`fawsb`,defaultStyleId:`semibold`,styleIds:[`semibold`],futureStyleIds:[],defaultFontWeight:600}]]),rf={chisel:{regular:`facr`},classic:{brands:`fab`,light:`fal`,regular:`far`,solid:`fas`,thin:`fat`},duotone:{light:`fadl`,regular:`fadr`,solid:`fad`,thin:`fadt`},etch:{solid:`faes`},graphite:{thin:`fagt`},jelly:{regular:`fajr`},"jelly-duo":{regular:`fajdr`},"jelly-fill":{regular:`fajfr`},mosaic:{solid:`fams`},notdog:{solid:`fans`},"notdog-duo":{solid:`fands`},pixel:{regular:`fapr`},sharp:{light:`fasl`,regular:`fasr`,solid:`fass`,thin:`fast`},"sharp-duotone":{light:`fasdl`,regular:`fasdr`,solid:`fasds`,thin:`fasdt`},slab:{regular:`faslr`},"slab-duo":{regular:`fasldr`},"slab-press":{regular:`faslpr`},"slab-press-duo":{regular:`faslpdr`},thumbprint:{light:`fatl`},utility:{semibold:`fausb`},"utility-duo":{semibold:`faudsb`},"utility-fill":{semibold:`faufsb`},vellum:{solid:`favs`},whiteboard:{semibold:`fawsb`}},af=[`fak`,`fa-kit`,`fakd`,`fa-kit-duotone`],of={kit:{fak:`kit`,"fa-kit":`kit`},"kit-duotone":{fakd:`kit-duotone`,"fa-kit-duotone":`kit-duotone`}},sf=[`kit`];K(K({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var cf={kit:{"fa-kit":`fak`},"kit-duotone":{"fa-kit-duotone":`fakd`}},lf={"Font Awesome Kit":{400:`fak`,normal:`fak`},"Font Awesome Kit Duotone":{400:`fakd`,normal:`fakd`}},uf={kit:{fak:`fa-kit`},"kit-duotone":{fakd:`fa-kit-duotone`}},df={kit:{kit:`fak`},"kit-duotone":{"kit-duotone":`fakd`}},ff,pf={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},mf=[`fa-classic`,`fa-duotone`,`fa-sharp`,`fa-sharp-duotone`,`fa-thumbprint`,`fa-whiteboard`,`fa-notdog`,`fa-notdog-duo`,`fa-chisel`,`fa-etch`,`fa-graphite`,`fa-jelly`,`fa-jelly-fill`,`fa-jelly-duo`,`fa-slab`,`fa-slab-press`,`fa-slab-press-duo`,`fa-slab-duo`,`fa-mosaic`,`fa-pixel`,`fa-vellum`,`fa-utility`,`fa-utility-duo`,`fa-utility-fill`];ff={},K(K(K(K(K(K(K(K(K(K(ff,`classic`,`Classic`),`duotone`,`Duotone`),`sharp`,`Sharp`),`sharp-duotone`,`Sharp Duotone`),`chisel`,`Chisel`),`etch`,`Etch`),`graphite`,`Graphite`),`jelly`,`Jelly`),`jelly-duo`,`Jelly Duo`),`jelly-fill`,`Jelly Fill`),K(K(K(K(K(K(K(K(K(K(ff,`mosaic`,`Mosaic`),`notdog`,`Notdog`),`notdog-duo`,`Notdog Duo`),`pixel`,`Pixel`),`slab`,`Slab`),`slab-duo`,`Slab Duo`),`slab-press`,`Slab Press`),`slab-press-duo`,`Slab Press Duo`),`thumbprint`,`Thumbprint`),`utility`,`Utility`),K(K(K(K(ff,`utility-duo`,`Utility Duo`),`utility-fill`,`Utility Fill`),`vellum`,`Vellum`),`whiteboard`,`Whiteboard`),K(K({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var hf={classic:{"fa-brands":`fab`,"fa-duotone":`fad`,"fa-light":`fal`,"fa-regular":`far`,"fa-solid":`fas`,"fa-thin":`fat`},duotone:{"fa-regular":`fadr`,"fa-light":`fadl`,"fa-thin":`fadt`},sharp:{"fa-solid":`fass`,"fa-regular":`fasr`,"fa-light":`fasl`,"fa-thin":`fast`},"sharp-duotone":{"fa-solid":`fasds`,"fa-regular":`fasdr`,"fa-light":`fasdl`,"fa-thin":`fasdt`},slab:{"fa-regular":`faslr`},"slab-press":{"fa-regular":`faslpr`},"slab-duo":{"fa-regular":`fasldr`},"slab-press-duo":{"fa-regular":`faslpdr`},pixel:{"fa-regular":`fapr`},mosaic:{"fa-solid":`fams`},vellum:{"fa-solid":`favs`},whiteboard:{"fa-semibold":`fawsb`},thumbprint:{"fa-light":`fatl`},notdog:{"fa-solid":`fans`},"notdog-duo":{"fa-solid":`fands`},etch:{"fa-solid":`faes`},graphite:{"fa-thin":`fagt`},jelly:{"fa-regular":`fajr`},"jelly-fill":{"fa-regular":`fajfr`},"jelly-duo":{"fa-regular":`fajdr`},chisel:{"fa-regular":`facr`},utility:{"fa-semibold":`fausb`},"utility-duo":{"fa-semibold":`faudsb`},"utility-fill":{"fa-semibold":`faufsb`}},gf={classic:[`fas`,`far`,`fal`,`fat`,`fad`],duotone:[`fadr`,`fadl`,`fadt`],sharp:[`fass`,`fasr`,`fasl`,`fast`],"sharp-duotone":[`fasds`,`fasdr`,`fasdl`,`fasdt`],slab:[`faslr`],"slab-press":[`faslpr`],"slab-duo":[`fasldr`],"slab-press-duo":[`faslpdr`],pixel:[`fapr`],mosaic:[`fams`],vellum:[`favs`],whiteboard:[`fawsb`],thumbprint:[`fatl`],notdog:[`fans`],"notdog-duo":[`fands`],etch:[`faes`],graphite:[`fagt`],jelly:[`fajr`],"jelly-fill":[`fajfr`],"jelly-duo":[`fajdr`],chisel:[`facr`],utility:[`fausb`],"utility-duo":[`faudsb`],"utility-fill":[`faufsb`]},_f={classic:{fab:`fa-brands`,fad:`fa-duotone`,fal:`fa-light`,far:`fa-regular`,fas:`fa-solid`,fat:`fa-thin`},duotone:{fadr:`fa-regular`,fadl:`fa-light`,fadt:`fa-thin`},sharp:{fass:`fa-solid`,fasr:`fa-regular`,fasl:`fa-light`,fast:`fa-thin`},"sharp-duotone":{fasds:`fa-solid`,fasdr:`fa-regular`,fasdl:`fa-light`,fasdt:`fa-thin`},slab:{faslr:`fa-regular`},"slab-press":{faslpr:`fa-regular`},"slab-duo":{fasldr:`fa-regular`},"slab-press-duo":{faslpdr:`fa-regular`},pixel:{fapr:`fa-regular`},mosaic:{fams:`fa-solid`},vellum:{favs:`fa-solid`},whiteboard:{fawsb:`fa-semibold`},thumbprint:{fatl:`fa-light`},notdog:{fans:`fa-solid`},"notdog-duo":{fands:`fa-solid`},etch:{faes:`fa-solid`},graphite:{fagt:`fa-thin`},jelly:{fajr:`fa-regular`},"jelly-fill":{fajfr:`fa-regular`},"jelly-duo":{fajdr:`fa-regular`},chisel:{facr:`fa-regular`},utility:{fausb:`fa-semibold`},"utility-duo":{faudsb:`fa-semibold`},"utility-fill":{faufsb:`fa-semibold`}},vf=`fa.fas.far.fal.fat.fad.fadr.fadl.fadt.fab.fass.fasr.fasl.fast.fasds.fasdr.fasdl.fasdt.faslr.faslpr.fasldr.faslpdr.fapr.fams.favs.fawsb.fatl.fans.fands.faes.fagt.fajr.fajfr.fajdr.facr.fausb.faudsb.faufsb`.split(`.`).concat(mf,[`fa-solid`,`fa-regular`,`fa-light`,`fa-thin`,`fa-duotone`,`fa-brands`,`fa-semibold`]),yf=[`solid`,`regular`,`light`,`thin`,`duotone`,`brands`,`semibold`],bf=[1,2,3,4,5,6,7,8,9,10],xf=bf.concat([11,12,13,14,15,16,17,18,19,20]),Sf=[].concat(Fu(Object.keys(gf)),yf,[`aw`,`fw`,`pull-left`,`pull-right`],[`2xs`,`xs`,`sm`,`lg`,`xl`,`2xl`,`beat`,`beat-fade`,`border`,`bounce`,`buzz`,`canvas-square`,`canvas-roomy`,`fade`,`flip-360`,`flip-both`,`flip-horizontal`,`flip-vertical`,`flip`,`float`,`inverse`,`jello`,`layers`,`layers-bottom-left`,`layers-bottom-right`,`layers-counter`,`layers-text`,`layers-top-left`,`layers-top-right`,`li`,`pull-end`,`pull-start`,`pulse`,`rotate-180`,`rotate-270`,`rotate-90`,`rotate-by`,`shake`,`spin-pulse`,`spin-reverse`,`spin`,`spin-snap`,`spin-snap-4`,`spin-snap-8`,`stack-1x`,`stack-2x`,`stack`,`swing`,`ul`,`wag`,`width-auto`,`width-fixed`,pf.GROUP,pf.SWAP_OPACITY,pf.PRIMARY,pf.SECONDARY],bf.map(function(e){return`${e}x`}),xf.map(function(e){return`w-${e}`})),Cf={"Font Awesome 5 Free":{900:`fas`,400:`far`},"Font Awesome 5 Pro":{900:`fas`,400:`far`,normal:`far`,300:`fal`},"Font Awesome 5 Brands":{400:`fab`,normal:`fab`},"Font Awesome 5 Duotone":{900:`fad`}},wf=`___FONT_AWESOME___`,Tf=16,Ef=`fa`,Df=`svg-inline--fa`,Of=`data-fa-i2svg`,kf=`data-fa-pseudo-element`,Af=`data-fa-pseudo-element-pending`,jf=`data-prefix`,Mf=`data-icon`,Nf=`fontawesome-i2svg`,Pf=`async`,Ff=[`HTML`,`HEAD`,`STYLE`,`SCRIPT`],If=[`::before`,`::after`,`:before`,`:after`],Lf=function(){try{return!0}catch{return!1}}();function Rf(e){return new Proxy(e,{get:function(e,t){return t in e?e[t]:e[ad]}})}var zf=q({},nd);zf[ad]=q(q(q(q({},{"fa-duotone":`duotone`}),nd[ad]),of.kit),of[`kit-duotone`]);var Bf=Rf(zf),Vf=q({},rf);Vf[ad]=q(q(q(q({},{duotone:`fad`}),Vf[ad]),df.kit),df[`kit-duotone`]);var Hf=Rf(Vf),Uf=q({},_f);Uf[ad]=q(q({},Uf[ad]),uf.kit);var Wf=Rf(Uf),Gf=q({},hf);Gf[ad]=q(q({},Gf[ad]),cf.kit),Rf(Gf);var Kf=ed,qf=`fa-layers-text`,Jf=td;Rf(q({},ef));var Yf=[`class`,`data-prefix`,`data-icon`,`data-fa-transform`,`data-fa-mask`],Xf=rd,Zf=[].concat(Fu(sf),Fu(Sf)),Qf=qu.FontAwesomeConfig||{};function $f(e){var t=Ju.querySelector(`script[`+e+`]`);if(t)return t.getAttribute(e)}function ep(e){return e===``?!0:e===`false`?!1:e===`true`||e}Ju&&typeof Ju.querySelector==`function`&&[[`data-family-prefix`,`familyPrefix`],[`data-css-prefix`,`cssPrefix`],[`data-family-default`,`familyDefault`],[`data-style-default`,`styleDefault`],[`data-replacement-class`,`replacementClass`],[`data-auto-replace-svg`,`autoReplaceSvg`],[`data-auto-add-css`,`autoAddCss`],[`data-search-pseudo-elements`,`searchPseudoElements`],[`data-search-pseudo-elements-warnings`,`searchPseudoElementsWarnings`],[`data-search-pseudo-elements-full-scan`,`searchPseudoElementsFullScan`],[`data-observe-mutations`,`observeMutations`],[`data-mutate-approach`,`mutateApproach`],[`data-keep-original-source`,`keepOriginalSource`],[`data-measure-performance`,`measurePerformance`],[`data-show-missing-icons`,`showMissingIcons`]].forEach(function(e){var t=Pu(e,2),n=t[0],r=t[1],i=ep($f(n));i!=null&&(Qf[r]=i)});var tp={styleDefault:`solid`,familyDefault:ad,cssPrefix:Ef,replacementClass:Df,autoReplaceSvg:!0,autoAddCss:!0,searchPseudoElements:!1,searchPseudoElementsWarnings:!0,searchPseudoElementsFullScan:!1,observeMutations:!0,mutateApproach:`async`,keepOriginalSource:!0,measurePerformance:!1,showMissingIcons:!0};Qf.familyPrefix&&(Qf.cssPrefix=Qf.familyPrefix);var np=q(q({},tp),Qf);np.autoReplaceSvg||(np.observeMutations=!1);var J={};Object.keys(tp).forEach(function(e){Object.defineProperty(J,e,{enumerable:!0,set:function(t){np[e]=t,rp.forEach(function(e){return e(J)})},get:function(){return np[e]}})}),Object.defineProperty(J,"familyPrefix",{enumerable:!0,set:function(e){np.cssPrefix=e,rp.forEach(function(e){return e(J)})},get:function(){return np.cssPrefix}}),qu.FontAwesomeConfig=J;var rp=[];function ip(e){return rp.push(e),function(){rp.splice(rp.indexOf(e),1)}}var ap=Tf,op={size:16,x:0,y:0,rotate:0,flipX:!1,flipY:!1};function sp(e){if(!(!e||!Zu)){var t=Ju.createElement(`style`);t.setAttribute(`type`,`text/css`),t.innerHTML=e;for(var n=Ju.head.childNodes,r=null,i=n.length-1;i>-1;i--){var a=n[i],o=(a.tagName||``).toUpperCase();[`STYLE`,`LINK`].indexOf(o)>-1&&(r=a)}return Ju.head.insertBefore(t,r),e}}var cp=`0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`;function lp(){for(var e=12,t=``;e-->0;)t+=cp[Math.random()*62|0];return t}function up(e){for(var t=[],n=(e||[]).length>>>0;n--;)t[n]=e[n];return t}function dp(e){return e.classList?up(e.classList):(e.getAttribute(`class`)||``).split(` `).filter(function(e){return e})}function fp(e){return`${e}`.replace(/&/g,`&amp;`).replace(/"/g,`&quot;`).replace(/'/g,`&#39;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`)}function pp(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}="${fp(e[n])}" `},``).trim()}function mp(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}: ${e[n].trim()};`},``)}function hp(e){return e.size!==op.size||e.x!==op.x||e.y!==op.y||e.rotate!==op.rotate||e.flipX||e.flipY}function gp(e){var t=e.transform,n=e.containerWidth,r=e.iconWidth;return{outer:{transform:`translate(${n/2} 256)`},inner:{transform:`${`translate(${t.x*32}, ${t.y*32}) `} ${`scale(${t.size/16*(t.flipX?-1:1)}, ${t.size/16*(t.flipY?-1:1)}) `} ${`rotate(${t.rotate} 0 0)`}`},path:{transform:`translate(${r/2*-1} -256)`}}}function _p(e){var t=e.transform,n=e.width,r=n===void 0?Tf:n,i=e.height,a=i===void 0?Tf:i,o=e.startCentered,s=o!==void 0&&o,c=``;return c+=s&&Qu?`translate(${t.x/ap-r/2}em, ${t.y/ap-a/2}em) `:s?`translate(calc(-50% + ${t.x/ap}em), calc(-50% + ${t.y/ap}em)) `:`translate(${t.x/ap}em, ${t.y/ap}em) `,c+=`scale(${t.size/ap*(t.flipX?-1:1)}, ${t.size/ap*(t.flipY?-1:1)}) `,c+=`rotate(${t.rotate}deg) `,c}var vp=`:root, :host {
  --fa-font-solid: normal 900 1em/1 'Font Awesome 7 Free';
  --fa-font-regular: normal 400 1em/1 'Font Awesome 7 Free';
  --fa-font-light: normal 300 1em/1 'Font Awesome 7 Pro';
  --fa-font-thin: normal 100 1em/1 'Font Awesome 7 Pro';
  --fa-font-duotone: normal 900 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-regular: normal 400 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-light: normal 300 1em/1 'Font Awesome 7 Duotone';
  --fa-font-duotone-thin: normal 100 1em/1 'Font Awesome 7 Duotone';
  --fa-font-brands: normal 400 1em/1 'Font Awesome 7 Brands';
  --fa-font-sharp-solid: normal 900 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-regular: normal 400 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-light: normal 300 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-thin: normal 100 1em/1 'Font Awesome 7 Sharp';
  --fa-font-sharp-duotone-solid: normal 900 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-regular: normal 400 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-light: normal 300 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-sharp-duotone-thin: normal 100 1em/1 'Font Awesome 7 Sharp Duotone';
  --fa-font-slab-regular: normal 400 1em/1 'Font Awesome 7 Slab';
  --fa-font-slab-press-regular: normal 400 1em/1 'Font Awesome 7 Slab Press';
  --fa-font-slab-duo-regular: normal 400 1em/1 'Font Awesome 7 Slab Duo';
  --fa-font-slab-press-duo-regular: normal 400 1em/1 'Font Awesome 7 Slab Press Duo';
  --fa-font-pixel-regular: normal 400 1em/1 'Font Awesome 7 Pixel';
  --fa-font-mosaic-solid: normal 900 1em/1 'Font Awesome 7 Mosaic';
  --fa-font-vellum-solid: normal 900 1em/1 'Font Awesome 7 Vellum';
  --fa-font-whiteboard-semibold: normal 600 1em/1 'Font Awesome 7 Whiteboard';
  --fa-font-thumbprint-light: normal 300 1em/1 'Font Awesome 7 Thumbprint';
  --fa-font-notdog-solid: normal 900 1em/1 'Font Awesome 7 Notdog';
  --fa-font-notdog-duo-solid: normal 900 1em/1 'Font Awesome 7 Notdog Duo';
  --fa-font-etch-solid: normal 900 1em/1 'Font Awesome 7 Etch';
  --fa-font-graphite-thin: normal 100 1em/1 'Font Awesome 7 Graphite';
  --fa-font-jelly-regular: normal 400 1em/1 'Font Awesome 7 Jelly';
  --fa-font-jelly-fill-regular: normal 400 1em/1 'Font Awesome 7 Jelly Fill';
  --fa-font-jelly-duo-regular: normal 400 1em/1 'Font Awesome 7 Jelly Duo';
  --fa-font-chisel-regular: normal 400 1em/1 'Font Awesome 7 Chisel';
  --fa-font-utility-semibold: normal 600 1em/1 'Font Awesome 7 Utility';
  --fa-font-utility-duo-semibold: normal 600 1em/1 'Font Awesome 7 Utility Duo';
  --fa-font-utility-fill-semibold: normal 600 1em/1 'Font Awesome 7 Utility Fill';
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

.fa-stack-1x,
.fa-stack-2x {
  inset: 0;
  margin: auto;
  position: absolute;
  z-index: var(--fa-stack-z-index, auto);
}`;function yp(){var e=Ef,t=Df,n=J.cssPrefix,r=J.replacementClass,i=vp;if(n!==e||r!==t){var a=RegExp(`\\.${e}\\-`,`g`),o=RegExp(`\\--${e}\\-`,`g`),s=RegExp(`\\.${t}`,`g`);i=i.replace(a,`.${n}-`).replace(o,`--${n}-`).replace(s,`.${r}`)}return i}var bp=!1;function xp(){J.autoAddCss&&!bp&&(sp(yp()),bp=!0)}var Sp={mixout:function(){return{dom:{css:yp,insertCss:xp}}},hooks:function(){return{beforeDOMElementCreation:function(){xp()},beforeI2svg:function(){xp()}}}},Cp=qu||{};Cp[wf]||(Cp[wf]={}),Cp[wf].styles||(Cp[wf].styles={}),Cp[wf].hooks||(Cp[wf].hooks={}),Cp[wf].shims||(Cp[wf].shims=[]);var wp=Cp[wf],Tp=[],Ep=function(){Ju.removeEventListener(`DOMContentLoaded`,Ep),Dp=1,Tp.map(function(e){return e()})},Dp=!1;Zu&&(Dp=(Ju.documentElement.doScroll?/^loaded|^c/:/^loaded|^i|^c/).test(Ju.readyState),Dp||Ju.addEventListener(`DOMContentLoaded`,Ep));function Op(e){Zu&&(Dp?setTimeout(e,0):Tp.push(e))}function kp(e){var t=e.tag,n=e.attributes,r=n===void 0?{}:n,i=e.children,a=i===void 0?[]:i;return typeof e==`string`?fp(e):`<${t} ${pp(r)}>${a.map(kp).join(``)}</${t}>`}function Ap(e,t,n){if(e&&e[t]&&e[t][n])return{prefix:t,iconName:n,icon:e[t][n]}}var jp=function(e,t){return function(n,r,i,a){return e.call(t,n,r,i,a)}},Mp=function(e,t,n,r){var i=Object.keys(e),a=i.length,o=r===void 0?t:jp(t,r),s,c,l;for(n===void 0?(s=1,l=e[i[0]]):(s=0,l=n);s<a;s++)c=i[s],l=o(l,e[c],c,e);return l};function Np(e){return Fu(e).length===1?e.codePointAt(0).toString(16):null}function Pp(e){return Object.keys(e).reduce(function(t,n){var r=e[n];return r.icon?t[r.iconName]=r.icon:t[n]=r,t},{})}function Fp(e,t){var n=(arguments.length>2&&arguments[2]!==void 0?arguments[2]:{}).skipHooks,r=n!==void 0&&n,i=Pp(t);typeof wp.hooks.addPack==`function`&&!r?wp.hooks.addPack(e,Pp(t)):wp.styles[e]=q(q({},wp.styles[e]||{}),i),e===`fas`&&Fp(`fa`,t)}var Ip=wp.styles,Lp=wp.shims,Rp=Object.keys(Wf),zp=Rp.reduce(function(e,t){return e[t]=Object.keys(Wf[t]),e},{}),Bp=null,Vp={},Hp={},Up={},Wp={},Gp={};function Kp(e){return~Zf.indexOf(e)}function qp(e,t){var n=t.split(`-`),r=n[0],i=n.slice(1).join(`-`);return r===e&&i!==``&&!Kp(i)?i:null}var Jp=function(){var e=function(e){return Mp(Ip,function(t,n,r){return t[r]=Mp(n,e,{}),t},{})};Vp=e(function(e,t,n){return t[3]&&(e[t[3]]=n),t[2]&&t[2].filter(function(e){return typeof e==`number`}).forEach(function(t){e[t.toString(16)]=n}),e}),Hp=e(function(e,t,n){return e[n]=n,t[2]&&t[2].filter(function(e){return typeof e==`string`}).forEach(function(t){e[t]=n}),e}),Gp=e(function(e,t,n){var r=t[2];return e[n]=n,r.forEach(function(t){e[t]=n}),e});var t=`far`in Ip||J.autoFetchSvg,n=Mp(Lp,function(e,n){var r=n[0],i=n[1],a=n[2];return i===`far`&&!t&&(i=`fas`),typeof r==`string`&&(e.names[r]={prefix:i,iconName:a}),typeof r==`number`&&(e.unicodes[r.toString(16)]={prefix:i,iconName:a}),e},{names:{},unicodes:{}});Up=n.names,Wp=n.unicodes,Bp=rm(J.styleDefault,{family:J.familyDefault})};ip(function(e){Bp=rm(e.styleDefault,{family:J.familyDefault})}),Jp();function Yp(e,t){return(Vp[e]||{})[t]}function Xp(e,t){return(Hp[e]||{})[t]}function Zp(e,t){return(Gp[e]||{})[t]}function Qp(e){return Up[e]||{prefix:null,iconName:null}}function $p(e){var t=Wp[e],n=Yp(`fas`,e);return t||(n?{prefix:`fas`,iconName:n}:null)||{prefix:null,iconName:null}}function em(){return Bp}var tm=function(){return{prefix:null,iconName:null,rest:[]}};function nm(e){var t=ad,n=Rp.reduce(function(e,t){return e[t]=`${J.cssPrefix}-${t}`,e},{});return $d.forEach(function(r){(e.includes(n[r])||e.some(function(e){return zp[r].includes(e)}))&&(t=r)}),t}function rm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).family,n=t===void 0?ad:t,r=Bf[n][e];if(n===od&&!e)return`fad`;var i=Hf[n][e]||Hf[n][r],a=e in wp.styles?e:null;return i||a||null}function im(e){var t=[],n=null;return e.forEach(function(e){var r=qp(J.cssPrefix,e);r?n=r:e&&t.push(e)}),{iconName:n,rest:t}}function am(e){return e.sort().filter(function(e,t,n){return n.indexOf(e)===t})}var om=vf.concat(af);function sm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).skipLookups,n=t!==void 0&&t,r=null,i=am(e.filter(function(e){return om.includes(e)})),a=am(e.filter(function(e){return!om.includes(e)})),o=Pu(i.filter(function(e){return r=e,!id.includes(e)}),1)[0],s=o===void 0?null:o,c=nm(i),l=q(q({},im(a)),{},{prefix:rm(s,{family:c})});return q(q(q({},l),dm({values:e,family:c,styles:Ip,config:J,canonical:l,givenPrefix:r})),cm(n,r,l))}function cm(e,t,n){var r=n.prefix,i=n.iconName;if(e||!r||!i)return{prefix:r,iconName:i};var a=t===`fa`?Qp(i):{},o=Zp(r,i);return i=a.iconName||o||i,r=a.prefix||r,r===`far`&&!Ip.far&&Ip.fas&&!J.autoFetchSvg&&(r=`fas`),{prefix:r,iconName:i}}var lm=$d.filter(function(e){return e!==ad||e!==od}),um=Object.keys(_f).filter(function(e){return e!==ad}).map(function(e){return Object.keys(_f[e])}).flat();function dm(e){var t=e.values,n=e.family,r=e.canonical,i=e.givenPrefix,a=i===void 0?``:i,o=e.styles,s=o===void 0?{}:o,c=e.config,l=c===void 0?{}:c,u=n===od,d=t.includes(`fa-duotone`)||t.includes(`fad`),f=l.familyDefault===`duotone`,p=r.prefix===`fad`||r.prefix===`fa-duotone`;return!u&&(d||f||p)&&(r.prefix=`fad`),(t.includes(`fa-brands`)||t.includes(`fab`))&&(r.prefix=`fab`),!r.prefix&&lm.includes(n)&&(Object.keys(s).find(function(e){return um.includes(e)})||l.autoFetchSvg)&&(r.prefix=nf.get(n).defaultShortPrefixId,r.iconName=Zp(r.prefix,r.iconName)||r.iconName),(r.prefix===`fa`||a===`fa`)&&(r.prefix=em()||`fas`),r}var fm=function(){function e(){Tu(this,e),this.definitions={}}return Du(e,[{key:`add`,value:function(){var e=this,t=[...arguments].reduce(this._pullDefinitions,{});Object.keys(t).forEach(function(n){e.definitions[n]=q(q({},e.definitions[n]||{}),t[n]),Fp(n,t[n]);var r=Wf[ad][n];r&&Fp(r,t[n]),Jp()})}},{key:`reset`,value:function(){this.definitions={}}},{key:`_pullDefinitions`,value:function(e,t){var n=t.prefix&&t.iconName&&t.icon?{0:t}:t;return Object.keys(n).map(function(t){var r=n[t],i=r.prefix,a=r.iconName,o=r.icon,s=o[2];e[i]||(e[i]={}),s.length>0&&s.forEach(function(t){typeof t==`string`&&(e[i][t]=o)}),e[i][a]=o}),e}}])}(),pm=[],mm={},hm={},gm=Object.keys(hm);function _m(e,t){var n=t.mixoutsTo;return pm=e,mm={},Object.keys(hm).forEach(function(e){gm.indexOf(e)===-1&&delete hm[e]}),pm.forEach(function(e){var t=e.mixout?e.mixout():{};if(Object.keys(t).forEach(function(e){typeof t[e]==`function`&&(n[e]=t[e]),Ru(t[e])===`object`&&Object.keys(t[e]).forEach(function(r){n[e]||(n[e]={}),n[e][r]=t[e][r]})}),e.hooks){var r=e.hooks();Object.keys(r).forEach(function(e){mm[e]||(mm[e]=[]),mm[e].push(r[e])})}e.provides&&e.provides(hm)}),n}function vm(e,t){var n=[...arguments].slice(2);return(mm[e]||[]).forEach(function(e){t=e.apply(null,[t].concat(n))}),t}function ym(e){var t=[...arguments].slice(1);(mm[e]||[]).forEach(function(e){e.apply(null,t)})}function bm(){var e=arguments[0],t=Array.prototype.slice.call(arguments,1);return hm[e]?hm[e].apply(null,t):void 0}function xm(e){e.prefix===`fa`&&(e.prefix=`fas`);var t=e.iconName,n=e.prefix||em();if(t)return t=Zp(n,t)||t,Ap(Sm.definitions,n,t)||Ap(wp.styles,n,t)}var Sm=new fm,Cm={noAuto:function(){J.autoReplaceSvg=!1,J.observeMutations=!1,ym(`noAuto`)},config:J,dom:{i2svg:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return Zu?(ym(`beforeI2svg`,e),bm(`pseudoElements2svg`,e),bm(`i2svg`,e)):Promise.reject(Error(`Operation requires a DOM of some kind.`))},watch:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},t=e.autoReplaceSvgRoot;J.autoReplaceSvg===!1&&(J.autoReplaceSvg=!0),J.observeMutations=!0,Op(function(){wm({autoReplaceSvgRoot:t}),ym(`watch`,e)})}},parse:{icon:function(e){if(e===null)return null;if(Ru(e)===`object`&&e.prefix&&e.iconName)return{prefix:e.prefix,iconName:Zp(e.prefix,e.iconName)||e.iconName};if(Array.isArray(e)&&e.length===2){var t=e[1].indexOf(`fa-`)===0?e[1].slice(3):e[1],n=rm(e[0]);return{prefix:n,iconName:Zp(n,t)||t}}if(typeof e==`string`&&(e.indexOf(`${J.cssPrefix}-`)>-1||e.match(Kf))){var r=sm(e.split(` `),{skipLookups:!0});return{prefix:r.prefix||em(),iconName:Zp(r.prefix,r.iconName)||r.iconName}}if(typeof e==`string`){var i=em();return{prefix:i,iconName:Zp(i,e)||e}}}},library:Sm,findIconDefinition:xm,toHtml:kp},wm=function(){var e=(arguments.length>0&&arguments[0]!==void 0?arguments[0]:{}).autoReplaceSvgRoot,t=e===void 0?Ju:e;(Object.keys(wp.styles).length>0||J.autoFetchSvg)&&Zu&&J.autoReplaceSvg&&Cm.dom.i2svg({node:t})};function Tm(e,t){return Object.defineProperty(e,"abstract",{get:t}),Object.defineProperty(e,"html",{get:function(){return e.abstract.map(function(e){return kp(e)})}}),Object.defineProperty(e,"node",{get:function(){if(Zu){var t=Ju.createElement(`div`);return t.innerHTML=e.html,t.children}}}),e}function Em(e){var t=e.children,n=e.main,r=e.mask,i=e.attributes,a=e.styles,o=e.transform;if(hp(o)&&n.found&&!r.found){var s={x:n.width/n.height/2,y:.5};i.style=mp(q(q({},a),{},{"transform-origin":`${s.x+o.x/16}em ${s.y+o.y/16}em`}))}return[{tag:`svg`,attributes:i,children:t}]}function Dm(e){var t=e.prefix,n=e.iconName,r=e.children,i=e.attributes,a=e.symbol,o=a===!0?`${t}-${J.cssPrefix}-${n}`:a;return[{tag:`svg`,attributes:{style:`display: none;`},children:[{tag:`symbol`,attributes:q(q({},i),{},{id:o}),children:r}]}]}function Om(e){return[`aria-label`,`aria-labelledby`,`title`,`role`].some(function(t){return t in e})}function km(e){var t=e.icons,n=t.main,r=t.mask,i=e.prefix,a=e.iconName,o=e.transform,s=e.symbol,c=e.maskId,l=e.extra,u=e.watchable,d=u!==void 0&&u,f=r.found?r:n,p=f.width,m=f.height,h=[J.replacementClass,a?`${J.cssPrefix}-${a}`:``].filter(function(e){return l.classes.indexOf(e)===-1}).filter(function(e){return e!==``||!!e}).concat(l.classes).join(` `),g={children:[],attributes:q(q({},l.attributes),{},{"data-prefix":i,"data-icon":a,class:h,role:l.attributes.role||`img`,viewBox:`0 0 ${p} ${m}`})};!Om(l.attributes)&&!l.attributes[`aria-hidden`]&&(g.attributes[`aria-hidden`]=`true`),d&&(g.attributes[Of]=``);var _=q(q({},g),{},{prefix:i,iconName:a,main:n,mask:r,maskId:c,transform:o,symbol:s,styles:q({},l.styles)}),v=r.found&&n.found?bm(`generateAbstractMask`,_)||{children:[],attributes:{}}:bm(`generateAbstractIcon`,_)||{children:[],attributes:{}},y=v.children,b=v.attributes;return _.children=y,_.attributes=b,s?Dm(_):Em(_)}function Am(e){var t=e.content,n=e.width,r=e.height,i=e.transform,a=e.extra,o=e.watchable,s=o!==void 0&&o,c=q(q({},a.attributes),{},{class:a.classes.join(` `)});s&&(c[Of]=``);var l=q({},a.styles);hp(i)&&(l.transform=_p({transform:i,startCentered:!0,width:n,height:r}),l[`-webkit-transform`]=l.transform);var u=mp(l);u.length>0&&(c.style=u);var d=[];return d.push({tag:`span`,attributes:c,children:[t]}),d}function jm(e){var t=e.content,n=e.extra,r=q(q({},n.attributes),{},{class:n.classes.join(` `)}),i=mp(n.styles);i.length>0&&(r.style=i);var a=[];return a.push({tag:`span`,attributes:r,children:[t]}),a}var Mm=wp.styles;function Nm(e){var t=e[0],n=e[1],r=Pu(e.slice(4),1)[0],i=null;return i=Array.isArray(r)?{tag:`g`,attributes:{class:`${J.cssPrefix}-${Xf.GROUP}`},children:[{tag:`path`,attributes:{class:`${J.cssPrefix}-${Xf.SECONDARY}`,fill:`currentColor`,d:r[0]}},{tag:`path`,attributes:{class:`${J.cssPrefix}-${Xf.PRIMARY}`,fill:`currentColor`,d:r[1]}}]}:{tag:`path`,attributes:{fill:`currentColor`,d:r}},{found:!0,width:t,height:n,icon:i}}var Pm={found:!1,width:512,height:512};function Fm(e,t){!Lf&&!J.showMissingIcons&&e&&console.error(`Icon with name "${e}" and prefix "${t}" is missing.`)}function Im(e,t){var n=t;return t===`fa`&&J.styleDefault!==null&&(t=em()),new Promise(function(r,i){if(n===`fa`){var a=Qp(e)||{};e=a.iconName||e,t=a.prefix||t}if(e&&t&&Mm[t]&&Mm[t][e]){var o=Mm[t][e];return r(Nm(o))}Fm(e,t),r(q(q({},Pm),{},{icon:J.showMissingIcons&&e&&bm(`missingIconAbstract`)||{}}))})}var Lm=function(){},Rm=J.measurePerformance&&Xu&&Xu.mark&&Xu.measure?Xu:{mark:Lm,measure:Lm},zm=`FA "7.3.1"`,Bm=function(e){return Rm.mark(`${zm} ${e} begins`),function(){return Vm(e)}},Vm=function(e){Rm.mark(`${zm} ${e} ends`),Rm.measure(`${zm} ${e}`,`${zm} ${e} begins`,`${zm} ${e} ends`)},Hm={begin:Bm,end:Vm},Um=function(){};function Wm(e){return typeof(e.getAttribute?e.getAttribute(Of):null)==`string`}function Gm(e){var t=e.getAttribute?e.getAttribute(jf):null,n=e.getAttribute?e.getAttribute(Mf):null;return t&&n}function Km(e){return e&&e.classList&&e.classList.contains&&e.classList.contains(J.replacementClass)}function qm(){return J.autoReplaceSvg===!0?Qm.replace:Qm[J.autoReplaceSvg]||Qm.replace}function Jm(e){return Ju.createElementNS(`http://www.w3.org/2000/svg`,e)}function Ym(e){return Ju.createElement(e)}function Xm(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).ceFn,n=t===void 0?e.tag===`svg`?Jm:Ym:t;if(typeof e==`string`)return Ju.createTextNode(e);var r=n(e.tag);return Object.keys(e.attributes||[]).forEach(function(t){r.setAttribute(t,e.attributes[t])}),(e.children||[]).forEach(function(e){r.appendChild(Xm(e,{ceFn:n}))}),r}function Zm(e){var t=` ${e.outerHTML} `;return t=`${t}Font Awesome fontawesome.com `,t}var Qm={replace:function(e){var t=e[0];if(t.parentNode){if(e[1].forEach(function(e){t.parentNode.insertBefore(Xm(e),t)}),t.getAttribute(Of)===null&&J.keepOriginalSource){var n=Ju.createComment(Zm(t));t.parentNode.replaceChild(n,t)}else t.remove()}},nest:function(e){var t=e[0],n=e[1];if(~dp(t).indexOf(J.replacementClass))return Qm.replace(e);var r=RegExp(`${J.cssPrefix}-.*`);if(delete n[0].attributes.id,n[0].attributes.class){var i=n[0].attributes.class.split(` `).reduce(function(e,t){return t===J.replacementClass||t.match(r)?e.toSvg.push(t):e.toNode.push(t),e},{toNode:[],toSvg:[]});n[0].attributes.class=i.toSvg.join(` `),i.toNode.length===0?t.removeAttribute(`class`):t.setAttribute(`class`,i.toNode.join(` `))}var a=n.map(function(e){return kp(e)}).join(`
`);t.setAttribute(Of,``),t.innerHTML=a}};function $m(e){e()}function eh(e,t){var n=typeof t==`function`?t:Um;if(e.length===0)n();else{var r=$m;J.mutateApproach===Pf&&(r=qu.requestAnimationFrame||$m),r(function(){var t=qm(),r=Hm.begin(`mutate`);e.map(t),r(),n()})}}var th=!1;function nh(){th=!0}function rh(){th=!1}var ih=null;function ah(e){if(Yu&&J.observeMutations){var t=e.treeCallback,n=t===void 0?Um:t,r=e.nodeCallback,i=r===void 0?Um:r,a=e.pseudoElementsCallback,o=a===void 0?Um:a,s=e.observeMutationsRoot,c=s===void 0?Ju:s;ih=new Yu(function(e){if(!th){var t=em();up(e).forEach(function(e){if(e.type===`childList`&&e.addedNodes.length>0&&!Wm(e.addedNodes[0])&&(J.searchPseudoElements&&o(e.target),n(e.target)),e.type===`attributes`&&e.target.parentNode&&J.searchPseudoElements&&o([e.target],!0),e.type===`attributes`&&Wm(e.target)&&~Yf.indexOf(e.attributeName)){if(e.attributeName===`class`&&Gm(e.target)){var r=sm(dp(e.target)),a=r.prefix,s=r.iconName;e.target.setAttribute(jf,a||t),s&&e.target.setAttribute(Mf,s)}else Km(e.target)&&i(e.target)}})}}),Zu&&ih.observe(c,{childList:!0,attributes:!0,characterData:!0,subtree:!0})}}function oh(){ih&&ih.disconnect()}function sh(e){var t=e.getAttribute(`style`),n=[];return t&&(n=t.split(`;`).reduce(function(e,t){var n=t.split(`:`),r=n[0],i=n.slice(1);return r&&i.length>0&&(e[r]=i.join(`:`).trim()),e},{})),n}function ch(e){var t=e.getAttribute(`data-prefix`),n=e.getAttribute(`data-icon`),r=e.innerText===void 0?``:e.innerText.trim(),i=sm(dp(e));return i.prefix||=em(),t&&n&&(i.prefix=t,i.iconName=n),i.iconName&&i.prefix?i:(i.prefix&&r.length>0&&(i.iconName=Xp(i.prefix,e.innerText)||Yp(i.prefix,Np(e.innerText))),!i.iconName&&J.autoFetchSvg&&e.firstChild&&e.firstChild.nodeType===Node.TEXT_NODE&&(i.iconName=e.firstChild.data),i)}function lh(e){return up(e.attributes).reduce(function(e,t){return e.name!==`class`&&e.name!==`style`&&(e[t.name]=t.value),e},{})}function uh(){return{iconName:null,prefix:null,transform:op,symbol:!1,mask:{iconName:null,prefix:null,rest:[]},maskId:null,extra:{classes:[],styles:{},attributes:{}}}}function dh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{styleParser:!0},n=ch(e),r=n.iconName,i=n.prefix,a=n.rest,o=lh(e),s=vm(`parseNodeAttributes`,{},e);return q({iconName:r,prefix:i,transform:op,mask:{iconName:null,prefix:null,rest:[]},maskId:null,symbol:!1,extra:{classes:a,styles:t.styleParser?sh(e):[],attributes:o}},s)}var fh=wp.styles;function ph(e){var t=J.autoReplaceSvg===`nest`?dh(e,{styleParser:!1}):dh(e);return~t.extra.classes.indexOf(qf)?bm(`generateLayersText`,e,t):bm(`generateSvgReplacementMutation`,e,t)}function mh(){return[].concat(Fu(af),Fu(vf))}function hh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(!Zu)return Promise.resolve();var n=Ju.documentElement.classList,r=function(e){return n.add(`${Nf}-${e}`)},i=function(e){return n.remove(`${Nf}-${e}`)},a=J.autoFetchSvg?mh():id.concat(Object.keys(fh));a.includes(`fa`)||a.push(`fa`);var o=[`.${qf}:not([${Of}])`].concat(a.map(function(e){return`.${e}:not([${Of}])`})).join(`, `);if(o.length===0)return Promise.resolve();var s=[];try{s=up(e.querySelectorAll(o))}catch{}if(s.length>0)r(`pending`),i(`complete`);else return Promise.resolve();var c=Hm.begin(`onTree`),l=s.reduce(function(e,t){try{var n=ph(t);n&&e.push(n)}catch(e){Lf||e.name===`MissingIcon`&&console.error(e)}return e},[]);return new Promise(function(e,n){Promise.all(l).then(function(n){eh(n,function(){r(`active`),r(`complete`),i(`pending`),typeof t==`function`&&t(),c(),e()})}).catch(function(e){c(),n(e)})})}function gh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;ph(e).then(function(e){e&&eh([e],t)})}function _h(e){return function(t){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},r=(t||{}).icon?t:xm(t||{}),i=n.mask;return i&&=(i||{}).icon?i:xm(i||{}),e(r,q(q({},n),{},{mask:i}))}}var vh=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?op:n,i=t.symbol,a=i!==void 0&&i,o=t.mask,s=o===void 0?null:o,c=t.maskId,l=c===void 0?null:c,u=t.classes,d=u===void 0?[]:u,f=t.attributes,p=f===void 0?{}:f,m=t.styles,h=m===void 0?{}:m;if(e){var g=e.prefix,_=e.iconName,v=e.icon;return Tm(q({type:`icon`},e),function(){return ym(`beforeDOMElementCreation`,{iconDefinition:e,params:t}),km({icons:{main:Nm(v),mask:s?Nm(s.icon):{found:!1,width:null,height:null,icon:{}}},prefix:g,iconName:_,transform:q(q({},op),r),symbol:a,maskId:l,extra:{attributes:p,styles:h,classes:d}})})}},yh={mixout:function(){return{icon:_h(vh)}},hooks:function(){return{mutationObserverCallbacks:function(e){return e.treeCallback=hh,e.nodeCallback=gh,e}}},provides:function(e){e.i2svg=function(e){var t=e.node,n=t===void 0?Ju:t,r=e.callback;return hh(n,r===void 0?function(){}:r)},e.generateSvgReplacementMutation=function(e,t){var n=t.iconName,r=t.prefix,i=t.transform,a=t.symbol,o=t.mask,s=t.maskId,c=t.extra;return new Promise(function(t,l){Promise.all([Im(n,r),o.iconName?Im(o.iconName,o.prefix):Promise.resolve({found:!1,width:512,height:512,icon:{}})]).then(function(o){var l=Pu(o,2),u=l[0],d=l[1];t([e,km({icons:{main:u,mask:d},prefix:r,iconName:n,transform:i,symbol:a,maskId:s,extra:c,watchable:!0})])}).catch(l)})},e.generateAbstractIcon=function(e){var t=e.children,n=e.attributes,r=e.main,i=e.transform,a=e.styles,o=mp(a);o.length>0&&(n.style=o);var s;return hp(i)&&(s=bm(`generateAbstractTransformGrouping`,{main:r,transform:i,containerWidth:r.width,iconWidth:r.width})),t.push(s||r.icon),{children:t,attributes:n}}}},bh={mixout:function(){return{layer:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.classes,r=n===void 0?[]:n;return Tm({type:`layer`},function(){ym(`beforeDOMElementCreation`,{assembler:e,params:t});var n=[];return e(function(e){Array.isArray(e)?e.map(function(e){n=n.concat(e.abstract)}):n=n.concat(e.abstract)}),[{tag:`span`,attributes:{class:[`${J.cssPrefix}-layers`].concat(Fu(r)).join(` `)},children:n}]})}}}},xh={mixout:function(){return{counter:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.title,r=n===void 0?null:n,i=t.classes,a=i===void 0?[]:i,o=t.attributes,s=o===void 0?{}:o,c=t.styles,l=c===void 0?{}:c;return Tm({type:`counter`,content:e},function(){return ym(`beforeDOMElementCreation`,{content:e,params:t}),jm({content:e.toString(),title:r,extra:{attributes:s,styles:l,classes:[`${J.cssPrefix}-layers-counter`].concat(Fu(a))}})})}}}},Sh={mixout:function(){return{text:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?op:n,i=t.classes,a=i===void 0?[]:i,o=t.attributes,s=o===void 0?{}:o,c=t.styles,l=c===void 0?{}:c;return Tm({type:`text`,content:e},function(){return ym(`beforeDOMElementCreation`,{content:e,params:t}),Am({content:e,transform:q(q({},op),r),extra:{attributes:s,styles:l,classes:[`${J.cssPrefix}-layers-text`].concat(Fu(a))}})})}}},provides:function(e){e.generateLayersText=function(e,t){var n=t.transform,r=t.extra,i=null,a=null;if(Qu){var o=parseInt(getComputedStyle(e).fontSize,10),s=e.getBoundingClientRect();i=s.width/o,a=s.height/o}return Promise.resolve([e,Am({content:e.innerHTML,width:i,height:a,transform:n,extra:r,watchable:!0})])}}},Ch=RegExp(`"`,`ug`),wh=[1105920,1112319],Th=q(q(q(q({},{FontAwesome:{normal:`fas`,400:`fas`}}),tf),Cf),lf),Eh=Object.keys(Th).reduce(function(e,t){return e[t.toLowerCase()]=Th[t],e},{}),Dh=Object.keys(Eh).reduce(function(e,t){var n=Eh[t];return e[t]=n[900]||Fu(Object.entries(n))[0][1],e},{});function Oh(e){return Np(Fu(e.replace(Ch,``))[0]||``)}function kh(e){var t=e.getPropertyValue(`font-feature-settings`).includes(`ss01`),n=e.getPropertyValue(`content`).replace(Ch,``),r=n.codePointAt(0),i=r>=wh[0]&&r<=wh[1],a=n.length===2&&n[0]===n[1];return i||a||t}function Ah(e,t){var n=e.replace(/^['"]|['"]$/g,``).toLowerCase(),r=parseInt(t),i=isNaN(r)?`normal`:r;return(Eh[n]||{})[i]||Dh[n]}function jh(e,t){var n=`${Af}${t.replace(`:`,`-`)}`;return new Promise(function(r,i){if(e.getAttribute(n)!==null)return r();var a=up(e.children).filter(function(e){return e.getAttribute(kf)===t})[0],o=qu.getComputedStyle(e,t),s=o.getPropertyValue(`font-family`),c=s.match(Jf),l=o.getPropertyValue(`font-weight`),u=o.getPropertyValue(`content`);if(a&&!c)return e.removeChild(a),r();if(c&&u!==`none`&&u!==``){var d=o.getPropertyValue(`content`),f=Ah(s,l),p=Oh(d),m=c[0].startsWith(`FontAwesome`),h=kh(o),g=Yp(f,p),_=g;if(m){var v=$p(p);v.iconName&&v.prefix&&(g=v.iconName,f=v.prefix)}if(g&&!h&&(!a||a.getAttribute(jf)!==f||a.getAttribute(Mf)!==_)){e.setAttribute(n,_),a&&e.removeChild(a);var y=uh(),b=y.extra;b.attributes[kf]=t,Im(g,f).then(function(i){var a=km(q(q({},y),{},{icons:{main:i,mask:tm()},prefix:f,iconName:_,extra:b,watchable:!0})),o=Ju.createElementNS(`http://www.w3.org/2000/svg`,`svg`);t===`::before`?e.insertBefore(o,e.firstChild):e.appendChild(o),o.outerHTML=a.map(function(e){return kp(e)}).join(`
`),e.removeAttribute(n),r()}).catch(i)}else r()}else r()})}function Mh(e){return Promise.all([jh(e,`::before`),jh(e,`::after`)])}function Nh(e){return e.parentNode!==document.head&&!~Ff.indexOf(e.tagName.toUpperCase())&&!e.getAttribute(kf)&&(!e.parentNode||e.parentNode.tagName!==`svg`)}var Ph=function(e){return!!e&&If.some(function(t){return e.includes(t)})},Fh=function(e){if(!e)return[];var t=new Set,n=e.split(/,(?![^()]*\))/).map(function(e){return e.trim()});n=n.flatMap(function(e){return e.includes(`(`)?e:e.split(`,`).map(function(e){return e.trim()})});var r=Ou(n),i;try{for(r.s();!(i=r.n()).done;){var a=i.value;if(Ph(a)){var o=If.reduce(function(e,t){return e.replace(t,``)},a);o!==``&&o!==`*`&&t.add(o)}}}catch(e){r.e(e)}finally{r.f()}return t};function Ih(e){var t=arguments.length>1&&arguments[1]!==void 0&&arguments[1];if(Zu){var n;if(t)n=e;else if(J.searchPseudoElementsFullScan)n=e.querySelectorAll(`*`);else{var r=new Set,i=Ou(document.styleSheets),a;try{for(i.s();!(a=i.n()).done;){var o=a.value;try{var s=Ou(o.cssRules),c;try{for(s.s();!(c=s.n()).done;){var l=c.value,u=Ou(Fh(l.selectorText)),d;try{for(u.s();!(d=u.n()).done;){var f=d.value;r.add(f)}}catch(e){u.e(e)}finally{u.f()}}}catch(e){s.e(e)}finally{s.f()}}catch(e){J.searchPseudoElementsWarnings&&console.warn(`Font Awesome: cannot parse stylesheet: ${o.href} (${e.message})
If it declares any Font Awesome CSS pseudo-elements, they will not be rendered as SVG icons. Add crossorigin="anonymous" to the <link>, enable searchPseudoElementsFullScan for slower but more thorough DOM parsing, or suppress this warning by setting searchPseudoElementsWarnings to false.`)}}}catch(e){i.e(e)}finally{i.f()}if(!r.size)return;var p=Array.from(r).join(`, `);try{n=e.querySelectorAll(p)}catch{}}return new Promise(function(e,t){var r=up(n).filter(Nh).map(Mh),i=Hm.begin(`searchPseudoElements`);nh(),Promise.all(r).then(function(){i(),rh(),e()}).catch(function(){i(),rh(),t()})})}}var Lh={hooks:function(){return{mutationObserverCallbacks:function(e){return e.pseudoElementsCallback=Ih,e}}},provides:function(e){e.pseudoElements2svg=function(e){var t=e.node,n=t===void 0?Ju:t;J.searchPseudoElements&&Ih(n)}}},Rh=!1,zh={mixout:function(){return{dom:{unwatch:function(){nh(),Rh=!0}}}},hooks:function(){return{bootstrap:function(){ah(vm(`mutationObserverCallbacks`,{}))},noAuto:function(){oh()},watch:function(e){var t=e.observeMutationsRoot;Rh?rh():ah(vm(`mutationObserverCallbacks`,{observeMutationsRoot:t}))}}}},Bh=function(e){return e.toLowerCase().split(` `).reduce(function(e,t){var n=t.toLowerCase().split(`-`),r=n[0],i=n.slice(1).join(`-`);if(r&&i===`h`)return e.flipX=!0,e;if(r&&i===`v`)return e.flipY=!0,e;if(i=parseFloat(i),isNaN(i))return e;switch(r){case`grow`:e.size+=i;break;case`shrink`:e.size-=i;break;case`left`:e.x-=i;break;case`right`:e.x+=i;break;case`up`:e.y-=i;break;case`down`:e.y+=i;break;case`rotate`:e.rotate+=i}return e},{size:16,x:0,y:0,flipX:!1,flipY:!1,rotate:0})},Vh={mixout:function(){return{parse:{transform:function(e){return Bh(e)}}}},hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-transform`);return n&&(e.transform=Bh(n)),e}}},provides:function(e){e.generateAbstractTransformGrouping=function(e){var t=e.main,n=e.transform,r=e.containerWidth,i=e.iconWidth,a={outer:{transform:`translate(${r/2} 256)`},inner:{transform:`${`translate(${n.x*32}, ${n.y*32}) `} ${`scale(${n.size/16*(n.flipX?-1:1)}, ${n.size/16*(n.flipY?-1:1)}) `} ${`rotate(${n.rotate} 0 0)`}`},path:{transform:`translate(${i/2*-1} -256)`}};return{tag:`g`,attributes:q({},a.outer),children:[{tag:`g`,attributes:q({},a.inner),children:[{tag:t.icon.tag,children:t.icon.children,attributes:q(q({},t.icon.attributes),a.path)}]}]}}}},Hh={x:0,y:0,width:`100%`,height:`100%`};function Uh(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:!0;return e.attributes&&(e.attributes.fill||t)&&(e.attributes.fill=`black`),e}function Wh(e){return e.tag===`g`?e.children:[e]}_m([Sp,yh,bh,xh,Sh,Lh,zh,Vh,{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-mask`),r=n?sm(n.split(` `).map(function(e){return e.trim()})):tm();return r.prefix||=em(),e.mask=r,e.maskId=t.getAttribute(`data-fa-mask-id`),e}}},provides:function(e){e.generateAbstractMask=function(e){var t=e.children,n=e.attributes,r=e.main,i=e.mask,a=e.maskId,o=e.transform,s=r.width,c=r.icon,l=i.width,u=i.icon,d=gp({transform:o,containerWidth:l,iconWidth:s}),f={tag:`rect`,attributes:q(q({},Hh),{},{fill:`white`})},p=c.children?{children:c.children.map(Uh)}:{},m={tag:`g`,attributes:q({},d.inner),children:[Uh(q({tag:c.tag,attributes:q(q({},c.attributes),d.path)},p))]},h={tag:`g`,attributes:q({},d.outer),children:[m]},g=`mask-${a||lp()}`,_=`clip-${a||lp()}`,v={tag:`mask`,attributes:q(q({},Hh),{},{id:g,maskUnits:`userSpaceOnUse`,maskContentUnits:`userSpaceOnUse`}),children:[f,h]},y={tag:`defs`,children:[{tag:`clipPath`,attributes:{id:_},children:Wh(u)},v]};return t.push(y,{tag:`rect`,attributes:q({fill:`currentColor`,"clip-path":`url(#${_})`,mask:`url(#${g})`},Hh)}),{children:t,attributes:n}}}},{provides:function(e){var t=!1;qu.matchMedia&&(t=qu.matchMedia(`(prefers-reduced-motion: reduce)`).matches),e.missingIconAbstract=function(){var e=[],n={fill:`currentColor`},r={attributeType:`XML`,repeatCount:`indefinite`,dur:`2s`};e.push({tag:`path`,attributes:q(q({},n),{},{d:`M156.5,447.7l-12.6,29.5c-18.7-9.5-35.9-21.2-51.5-34.9l22.7-22.7C127.6,430.5,141.5,440,156.5,447.7z M40.6,272H8.5 c1.4,21.2,5.4,41.7,11.7,61.1L50,321.2C45.1,305.5,41.8,289,40.6,272z M40.6,240c1.4-18.8,5.2-37,11.1-54.1l-29.5-12.6 C14.7,194.3,10,216.7,8.5,240H40.6z M64.3,156.5c7.8-14.9,17.2-28.8,28.1-41.5L69.7,92.3c-13.7,15.6-25.5,32.8-34.9,51.5 L64.3,156.5z M397,419.6c-13.9,12-29.4,22.3-46.1,30.4l11.9,29.8c20.7-9.9,39.8-22.6,56.9-37.6L397,419.6z M115,92.4 c13.9-12,29.4-22.3,46.1-30.4l-11.9-29.8c-20.7,9.9-39.8,22.6-56.8,37.6L115,92.4z M447.7,355.5c-7.8,14.9-17.2,28.8-28.1,41.5 l22.7,22.7c13.7-15.6,25.5-32.9,34.9-51.5L447.7,355.5z M471.4,272c-1.4,18.8-5.2,37-11.1,54.1l29.5,12.6 c7.5-21.1,12.2-43.5,13.6-66.8H471.4z M321.2,462c-15.7,5-32.2,8.2-49.2,9.4v32.1c21.2-1.4,41.7-5.4,61.1-11.7L321.2,462z M240,471.4c-18.8-1.4-37-5.2-54.1-11.1l-12.6,29.5c21.1,7.5,43.5,12.2,66.8,13.6V471.4z M462,190.8c5,15.7,8.2,32.2,9.4,49.2h32.1 c-1.4-21.2-5.4-41.7-11.7-61.1L462,190.8z M92.4,397c-12-13.9-22.3-29.4-30.4-46.1l-29.8,11.9c9.9,20.7,22.6,39.8,37.6,56.9 L92.4,397z M272,40.6c18.8,1.4,36.9,5.2,54.1,11.1l12.6-29.5C317.7,14.7,295.3,10,272,8.5V40.6z M190.8,50 c15.7-5,32.2-8.2,49.2-9.4V8.5c-21.2,1.4-41.7,5.4-61.1,11.7L190.8,50z M442.3,92.3L419.6,115c12,13.9,22.3,29.4,30.5,46.1 l29.8-11.9C470,128.5,457.3,109.4,442.3,92.3z M397,92.4l22.7-22.7c-15.6-13.7-32.8-25.5-51.5-34.9l-12.6,29.5 C370.4,72.1,384.4,81.5,397,92.4z`})});var i=q(q({},r),{},{attributeName:`opacity`}),a={tag:`circle`,attributes:q(q({},n),{},{cx:`256`,cy:`364`,r:`28`}),children:[]};return t||a.children.push({tag:`animate`,attributes:q(q({},r),{},{attributeName:`r`,values:`28;14;28;28;14;28;`})},{tag:`animate`,attributes:q(q({},i),{},{values:`1;0;1;1;0;1;`})}),e.push(a),e.push({tag:`path`,attributes:q(q({},n),{},{opacity:`1`,d:`M263.7,312h-16c-6.6,0-12-5.4-12-12c0-71,77.4-63.9,77.4-107.8c0-20-17.8-40.2-57.4-40.2c-29.1,0-44.3,9.6-59.2,28.7 c-3.9,5-11.1,6-16.2,2.4l-13.1-9.2c-5.6-3.9-6.9-11.8-2.6-17.2c21.2-27.2,46.4-44.7,91.2-44.7c52.3,0,97.4,29.8,97.4,80.2 c0,67.6-77.4,63.5-77.4,107.8C275.7,306.6,270.3,312,263.7,312z`}),children:t?[]:[{tag:`animate`,attributes:q(q({},i),{},{values:`1;0;0;0;0;1;`})}]}),t||e.push({tag:`path`,attributes:q(q({},n),{},{opacity:`0`,d:`M232.5,134.5l7,168c0.3,6.4,5.6,11.5,12,11.5h9c6.4,0,11.7-5.1,12-11.5l7-168c0.3-6.8-5.2-12.5-12-12.5h-23 C237.7,122,232.2,127.7,232.5,134.5z`}),children:[{tag:`animate`,attributes:q(q({},i),{},{values:`0;0;1;1;0;0;`})}]}),{tag:`g`,attributes:{class:`missing`},children:e}}}},{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-symbol`);return e.symbol=n===null?!1:n===``||n,e}}}}],{mixoutsTo:Cm}),Cm.noAuto,Cm.config,Cm.library,Cm.dom;var Gh=Cm.parse;Cm.findIconDefinition,Cm.toHtml;var Kh=Cm.icon;Cm.layer,Cm.text,Cm.counter;function qh(e,t){(t==null||t>e.length)&&(t=e.length);for(var n=0,r=Array(t);n<t;n++)r[n]=e[n];return r}function Jh(e){if(Array.isArray(e))return qh(e)}function Yh(e,t,n){return(t=ig(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function Xh(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function Zh(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Qh(e,t){var n=Object.keys(e);if(Object.getOwnPropertySymbols){var r=Object.getOwnPropertySymbols(e);t&&(r=r.filter(function(t){return Object.getOwnPropertyDescriptor(e,t).enumerable})),n.push.apply(n,r)}return n}function $h(e){for(var t=1;t<arguments.length;t++){var n=arguments[t]==null?{}:arguments[t];t%2?Qh(Object(n),!0).forEach(function(t){Yh(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Qh(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function eg(e,t){if(e==null)return{};var n,r,i=tg(e,t);if(Object.getOwnPropertySymbols){var a=Object.getOwnPropertySymbols(e);for(r=0;r<a.length;r++)n=a[r],t.indexOf(n)===-1&&{}.propertyIsEnumerable.call(e,n)&&(i[n]=e[n])}return i}function tg(e,t){if(e==null)return{};var n={};for(var r in e)if({}.hasOwnProperty.call(e,r)){if(t.indexOf(r)!==-1)continue;n[r]=e[r]}return n}function ng(e){return Jh(e)||Xh(e)||og(e)||Zh()}function rg(e,t){if(typeof e!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var r=n.call(e,t||`default`);if(typeof r!=`object`)return r;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}function ig(e){var t=rg(e,`string`);return typeof t==`symbol`?t:t+``}function ag(e){"@babel/helpers - typeof";return ag=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},ag(e)}function og(e,t){if(e){if(typeof e==`string`)return qh(e,t);var n={}.toString.call(e).slice(8,-1);return n===`Object`&&e.constructor&&(n=e.constructor.name),n===`Map`||n===`Set`?Array.from(e):n===`Arguments`||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)?qh(e,t):void 0}}function sg(e,t){return Array.isArray(t)&&t.length>0||!Array.isArray(t)&&t?Yh({},e,t):{}}function cg(e){var t,n=(t={"fa-spin":e.spin,"fa-pulse":e.pulse,"fa-fw":e.fixedWidth,"fa-border":e.border,"fa-li":e.listItem,"fa-inverse":e.inverse,"fa-flip":e.flip===!0,"fa-flip-horizontal":e.flip===`horizontal`||e.flip===`both`,"fa-flip-vertical":e.flip===`vertical`||e.flip===`both`},Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(t,`fa-${e.size}`,e.size!==null),`fa-rotate-${e.rotation}`,e.rotation!==null),`fa-rotate-by`,e.rotateBy),`fa-pull-${e.pull}`,e.pull!==null),`fa-swap-opacity`,e.swapOpacity),`fa-bounce`,e.bounce),`fa-shake`,e.shake),`fa-beat`,e.beat),`fa-fade`,e.fade),`fa-beat-fade`,e.beatFade),Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(Yh(t,`fa-flash`,e.flash),`fa-spin-pulse`,e.spinPulse),`fa-spin-reverse`,e.spinReverse),`fa-width-auto`,e.widthAuto),`fa-canvas-square`,e.canvasSquare),`fa-canvas-roomy`,e.canvasRoomy),`fa-flip-360`,e.flip360),`fa-buzz`,e.buzz),`fa-float`,e.float),`fa-jello`,e.jello),Yh(Yh(Yh(Yh(Yh(t,`fa-spin-snap`,e.spinSnap),`fa-spin-snap-4`,e.spinSnap4),`fa-spin-snap-8`,e.spinSnap8),`fa-swing`,e.swing),`fa-wag`,e.wag));return Object.keys(n).map(function(e){return n[e]?e:null}).filter(function(e){return e})}var lg=typeof globalThis<`u`?globalThis:typeof window<`u`?window:typeof global<`u`?global:typeof self<`u`?self:{},ug={exports:{}};(function(e){(function(t){var n=function(e,t,r){if(!l(t)||d(t)||f(t)||p(t)||c(t))return t;var i,a=0,o=0;if(u(t))for(i=[],o=t.length;a<o;a++)i.push(n(e,t[a],r));else for(var s in i={},t)Object.prototype.hasOwnProperty.call(t,s)&&(i[e(s,r)]=n(e,t[s],r));return i},r=function(e,t){t||={};var n=t.separator||`_`,r=t.split||/(?=[A-Z])/;return e.split(r).join(n)},i=function(e){return m(e)?e:(e=e.replace(/[\-_\s]+(.)?/g,function(e,t){return t?t.toUpperCase():``}),e.substr(0,1).toLowerCase()+e.substr(1))},a=function(e){var t=i(e);return t.substr(0,1).toUpperCase()+t.substr(1)},o=function(e,t){return r(e,t).toLowerCase()},s=Object.prototype.toString,c=function(e){return typeof e==`function`},l=function(e){return e===Object(e)},u=function(e){return s.call(e)==`[object Array]`},d=function(e){return s.call(e)==`[object Date]`},f=function(e){return s.call(e)==`[object RegExp]`},p=function(e){return s.call(e)==`[object Boolean]`},m=function(e){return e-=0,e===e},h=function(e,t){var n=t&&`process`in t?t.process:t;return typeof n==`function`?function(t,r){return n(t,e,r)}:e},g={camelize:i,decamelize:o,pascalize:a,depascalize:o,camelizeKeys:function(e,t){return n(h(i,t),e)},decamelizeKeys:function(e,t){return n(h(o,t),e,t)},pascalizeKeys:function(e,t){return n(h(a,t),e)},depascalizeKeys:function(){return this.decamelizeKeys.apply(this,arguments)}};e.exports?e.exports=g:t.humps=g})(lg)})(ug);var dg=ug.exports,fg=[`gradientFill`],pg=[`class`,`style`],mg=[`type`,`stops`,`id`];function hg(e){return e.split(`;`).map(function(e){return e.trim()}).filter(function(e){return e}).reduce(function(e,t){var n=t.indexOf(`:`),r=dg.camelize(t.slice(0,n));return e[r]=t.slice(n+1).trim(),e},{})}function gg(e){return e.split(/\s+/).reduce(function(e,t){return e[t]=!0,e},{})}function _g(e,t){return G(`stop`,$h({key:`${t}-${e.offset}`,offset:e.offset,"stop-color":e.color},e.opacity!==void 0&&{"stop-opacity":e.opacity}))}function vg(e){if(typeof e==`string`)return e;var t=(e.children||[]).map(vg);return e.tag===`path`&&e.attributes&&`fill`in e.attributes?$h($h({},e),{},{attributes:$h($h({},e.attributes),{},{fill:void 0}),children:t}):$h($h({},e),{},{children:t})}function yg(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=arguments.length>2&&arguments[2]!==void 0?arguments[2]:{};if(typeof e==`string`)return e;var r=t.gradientFill,i=r===void 0?null:r,a=eg(t,fg),o=i||`fill`in n?vg(e):e,s=(o.children||[]).map(function(e){return yg(e,{},{})}),c=Object.keys(o.attributes||{}).reduce(function(e,t){var n=o.attributes[t];switch(t){case`class`:e.class=gg(n);break;case`style`:e.style=hg(n);break;default:e.attrs[t]=n}return e},{attrs:{},class:{},style:{}});n.class;var l=n.style,u=l===void 0?{}:l,d=eg(n,pg);if(i&&i.id&&(i.type===`linear`||i.type===`radial`)){var f=i.type,p=i.stops,m=p===void 0?[]:p,h=i.id,g=eg(i,mg),_=G(f===`linear`?`linearGradient`:`radialGradient`,$h($h({},g),{},{id:h}),m.map(_g));return G(o.tag,$h($h($h($h({},a),{},{class:c.class,style:$h($h({},c.style),u)},c.attrs),d),{},{fill:`url(#${h})`}),[_].concat(ng(s)))}return G(e.tag,$h($h($h({},a),{},{class:c.class,style:$h($h({},c.style),u)},c.attrs),d),s)}var bg=!1;try{bg=!0}catch{}function xg(){if(!bg&&console&&typeof console.error==`function`){var e;(e=console).error.apply(e,arguments)}}function Sg(e){if(e&&ag(e)===`object`&&e.prefix&&e.iconName&&e.icon)return e;if(Gh.icon)return Gh.icon(e);if(e===null)return null;if(ag(e)===`object`&&e.prefix&&e.iconName)return e;if(Array.isArray(e)&&e.length===2)return{prefix:e[0],iconName:e[1]};if(typeof e==`string`)return{prefix:`fas`,iconName:e}}var Cg=P({name:`FontAwesomeIcon`,props:{border:{type:Boolean,default:!1},fixedWidth:{type:Boolean,default:!1},flip:{type:[Boolean,String],default:!1,validator:function(e){return[!0,!1,`horizontal`,`vertical`,`both`].indexOf(e)>-1}},icon:{type:[Object,Array,String],required:!0},mask:{type:[Object,Array,String],default:null},maskId:{type:String,default:null},listItem:{type:Boolean,default:!1},pull:{type:String,default:null,validator:function(e){return[`right`,`left`].indexOf(e)>-1}},pulse:{type:Boolean,default:!1},rotation:{type:[String,Number],default:null,validator:function(e){return[90,180,270].indexOf(Number.parseInt(e,10))>-1}},rotateBy:{type:Boolean,default:!1},swapOpacity:{type:Boolean,default:!1},size:{type:String,default:null,validator:function(e){return[`2xs`,`xs`,`sm`,`lg`,`xl`,`2xl`,`1x`,`2x`,`3x`,`4x`,`5x`,`6x`,`7x`,`8x`,`9x`,`10x`].indexOf(e)>-1}},spin:{type:Boolean,default:!1},transform:{type:[String,Object],default:null},symbol:{type:[Boolean,String],default:!1},title:{type:String,default:null},titleId:{type:String,default:null},inverse:{type:Boolean,default:!1},bounce:{type:Boolean,default:!1},shake:{type:Boolean,default:!1},beat:{type:Boolean,default:!1},fade:{type:Boolean,default:!1},beatFade:{type:Boolean,default:!1},flash:{type:Boolean,default:!1},spinPulse:{type:Boolean,default:!1},spinReverse:{type:Boolean,default:!1},widthAuto:{type:Boolean,default:!1},canvasSquare:{type:Boolean,default:!1},canvasRoomy:{type:Boolean,default:!1},gradientFill:{type:Object,default:null,validator:function(e){return typeof e.id!=`string`||!e.id?(console.warn(`FontAwesomeIcon: gradientFill.id must be a non-empty string`),!1):e.type!==`linear`&&e.type!==`radial`?(console.warn(`FontAwesomeIcon: gradientFill.type must be "linear" or "radial"`),!1):!0}},flip360:{type:Boolean,default:!1},buzz:{type:Boolean,default:!1},float:{type:Boolean,default:!1},jello:{type:Boolean,default:!1},spinSnap:{type:Boolean,default:!1},spinSnap4:{type:Boolean,default:!1},spinSnap8:{type:Boolean,default:!1},swing:{type:Boolean,default:!1},wag:{type:Boolean,default:!1}},setup:function(e,t){var n=t.attrs,r=W(function(){return Sg(e.icon)}),i=W(function(){return sg(`classes`,cg(e))}),a=W(function(){return sg(`transform`,typeof e.transform==`string`?Gh.transform(e.transform):e.transform)}),o=W(function(){return sg(`mask`,Sg(e.mask))}),s=W(function(){var t=$h($h($h($h({},i.value),a.value),o.value),{},{symbol:e.symbol,maskId:e.maskId});return t.title=e.title,t.titleId=e.titleId,Kh(r.value,t)});Dr(s,function(e){if(!e)return xg(`Could not find one or more icon(s)`,r.value,o.value)},{immediate:!0}),e.gradientFill&&e.symbol&&xg(`gradientFill is not supported when symbol is true and will be ignored`);var c=W(function(){return s.value?yg(s.value.abstract[0],{gradientFill:e.symbol?null:e.gradientFill},n):null});return function(){return c.value}}}),wg=typeof window<`u`,Tg,Eg=e=>Tg=e,Dg=Symbol();function Og(e){return e&&typeof e==`object`&&Object.prototype.toString.call(e)===`[object Object]`&&typeof e.toJSON!=`function`}var kg=typeof window==`object`&&window.window===window?window:typeof self==`object`&&self.self===self?self:typeof global==`object`&&global.global===global?global:typeof globalThis==`object`?globalThis:{HTMLElement:null};function Ag(e,{autoBom:t=!1}={}){return t&&/^\s*(?:text\/\S*|application\/xml|\S*\/\S*\+xml)\s*;.*charset\s*=\s*utf-8/i.test(e.type)?new Blob([`﻿`,e],{type:e.type}):e}function jg(e,t,n){let r=new XMLHttpRequest;r.open(`GET`,e),r.responseType=`blob`,r.onload=function(){Ig(r.response,t,n)},r.onerror=function(){console.error(`could not download file`)},r.send()}function Mg(e){let t=new XMLHttpRequest;t.open(`HEAD`,e,!1);try{t.send()}catch{}return t.status>=200&&t.status<=299}function Ng(e){try{e.dispatchEvent(new MouseEvent(`click`))}catch{let t=new MouseEvent(`click`,{bubbles:!0,cancelable:!0,view:window,detail:0,screenX:80,screenY:20,clientX:80,clientY:20,ctrlKey:!1,altKey:!1,shiftKey:!1,metaKey:!1,button:0,relatedTarget:null});e.dispatchEvent(t)}}var Pg=typeof navigator==`object`?navigator:{userAgent:``},Fg=/Macintosh/.test(Pg.userAgent)&&/AppleWebKit/.test(Pg.userAgent)&&!/Safari/.test(Pg.userAgent),Ig=wg?typeof HTMLAnchorElement<`u`&&`download`in HTMLAnchorElement.prototype&&!Fg?Lg:`msSaveOrOpenBlob`in Pg?Rg:zg:()=>{};function Lg(e,t=`download`,n){let r=document.createElement(`a`);r.download=t,r.rel=`noopener`,typeof e==`string`?(r.href=e,r.origin===location.origin?Ng(r):Mg(r.href)?jg(e,t,n):(r.target=`_blank`,Ng(r))):(r.href=URL.createObjectURL(e),setTimeout(function(){URL.revokeObjectURL(r.href)},4e4),setTimeout(function(){Ng(r)},0))}function Rg(e,t=`download`,n){if(typeof e==`string`){if(Mg(e))jg(e,t,n);else{let t=document.createElement(`a`);t.href=e,t.target=`_blank`,setTimeout(function(){Ng(t)})}}else navigator.msSaveOrOpenBlob(Ag(e,n),t)}function zg(e,t,n,r){if(r||=open(``,`_blank`),r&&(r.document.title=r.document.body.innerText=`downloading...`),typeof e==`string`)return jg(e,t,n);let i=e.type===`application/octet-stream`,a=/constructor/i.test(String(kg.HTMLElement))||`safari`in kg,o=/CriOS\/[\d]+/.test(navigator.userAgent);if((o||i&&a||Fg)&&typeof FileReader<`u`){let t=new FileReader;t.onloadend=function(){let e=t.result;if(typeof e!=`string`)throw r=null,Error(`Wrong reader.result type`);e=o?e:e.replace(/^data:[^;]*;/,`data:attachment/file;`),r?r.location.href=e:location.assign(e),r=null},t.readAsDataURL(e)}else{let t=URL.createObjectURL(e);r?r.location.assign(t):location.href=t,r=null,setTimeout(function(){URL.revokeObjectURL(t)},4e4)}}var{assign:Bg}=Object;function Vg(){let e=Pe(!0),t=e.run(()=>j({})),n=[],r=[],i=sn({install(e){Eg(i),i._a=e,e.provide(Dg,i),e.config.globalProperties.$pinia=i,r.forEach(e=>n.push(e)),r=[]},use(e){return this._a?n.push(e):r.push(e),this},_p:n,_a:null,_e:e,_s:new Map,state:t});return i}var Hg=()=>{};function Ug(e,t,n,r=Hg){e.add(t);let i=()=>{e.delete(t)&&r()};return!n&&Fe()&&Ie(i),i}function Wg(e,...t){e.forEach(e=>{e(...t)})}var Gg=e=>e(),Kg=Symbol(),qg=Symbol();function Jg(e,t){e instanceof Map&&t instanceof Map?t.forEach((t,n)=>e.set(n,t)):e instanceof Set&&t instanceof Set&&t.forEach(e.add,e);for(let n in t){if(!Object.hasOwn(t,n))continue;let r=t[n],i=e[n];e[n]=Og(i)&&Og(r)&&Object.hasOwn(e,n)&&!un(r)&&!nn(r)?Jg(i,r):r}return e}var Yg=Symbol();function Xg(e){return!e||typeof e!=`object`||!Object.hasOwn(e,Yg)}var{assign:Zg}=Object;function Qg(e){return!!(un(e)&&e.effect)}function $g(e,t,n,r){let{state:i,actions:a,getters:o}=t,s=n.state.value[e],c;function l(){return s||(n.state.value[e]=i?i():{}),Zg(bn(n.state.value[e]),a,Object.keys(o||{}).reduce((t,r)=>(t[r]=sn(W(()=>{Eg(n);let t=n._s.get(e);return o[r].call(t,t)})),t),{}))}return c=e_(e,l,t,n,r,!0),c}function e_(e,t,n={},r,i,a){let o,s=Zg({actions:{}},n),c={deep:!0},l,u,d=new Set,f=new Set,p,m=r.state.value[e];!a&&!m&&(r.state.value[e]={});let h;function g(t){let n;l=u=!1,typeof t==`function`?(t(r.state.value[e]),n={type:`patch function`,storeId:e,events:p}):(Jg(r.state.value[e],t),n={type:`patch object`,payload:t,storeId:e,events:p});let i=h=Symbol();$n().then(()=>{h===i&&(l=!0)}),u=!0,Wg(d,n,r.state.value[e])}let _=a?function(){let{state:e}=n,t=e?e():{};this.$patch(e=>{Zg(e,t)})}:Hg;function v(){o.stop(),d.clear(),f.clear(),r._s.delete(e)}let y=(t,n=``)=>{if(Kg in t)return t[qg]=n,t;let i=function(){Eg(r);let n=Array.from(arguments),a=new Set,o=new Set;function s(e){a.add(e)}function c(e){o.add(e)}Wg(f,{args:n,name:i[qg],store:b,after:s,onError:c});let l;try{l=t.apply(this&&this.$id===e?this:b,n)}catch(e){throw Wg(o,e),e}return l instanceof Promise?l.then(e=>(Wg(a,e),e)).catch(e=>(Wg(o,e),Promise.reject(e))):(Wg(a,l),l)};return i[Kg]=!0,i[qg]=n,i},b=Zt({_p:r,$id:e,$onAction:Ug.bind(null,f),$patch:g,$reset:_,$subscribe(t,n={}){if(d.has(t))return Hg;let i=Ug(d,t,n.detached,()=>a()),a=o.run(()=>Dr(()=>r.state.value[e],r=>{(n.flush===`sync`?u:l)&&t({storeId:e,type:`direct`,events:p},r)},Zg({},c,n)));return i},$dispose:v});r._s.set(e,b);let x=(r._a&&r._a.runWithContext||Gg)(()=>r._e.run(()=>(o=Pe()).run(()=>t({action:y}))));for(let t in x){let n=x[t];un(n)&&!Qg(n)||nn(n)?a||(m&&Xg(n)&&(un(n)?n.value=m[t]:((n instanceof Set||n instanceof Map)&&n.clear(),Jg(n,m[t]))),r.state.value[e][t]=n):typeof n==`function`&&(x[t]=y(n,t),s.actions[t]=n)}return Zg(b,x),Zg(A(b),x),Object.defineProperty(b,"$state",{get:()=>r.state.value[e],set:e=>{g(t=>{Zg(t,e)})}}),r._p.forEach(e=>{let t=o.run(()=>e({store:b,app:r._a,pinia:r,options:s}));Zg(b,t)}),m&&a&&n.hydrate&&n.hydrate(b.$state,m),l=!0,u=!0,b}function t_(e,t,n){let r,i=typeof t==`function`;r=i?n:t;function a(n,a){let o=xr();return n||=o?br(Dg,null):null,n&&Eg(n),n=Tg,n._s.has(e)||(i?e_(e,t,r,n):$g(e,r,n)),n._s.get(e)}return a.$id=e,a}function n_(e){let t=A(e),n={};for(let r in t){let i=t[r];i?.effect?n[r]=W({get:()=>e[r],set(t){e[r]=t}}):(un(i)||nn(i))&&(n[r]=Cn(e,r))}return n}var r_={prefix:`fab`,iconName:`github`,icon:[512,512,[],`f09b`,`M216.5 362.5c-66-8-112.5-55.5-112.5-117 0-25 9-52 24-70-6.5-16.5-5.5-51.5 2-66 20-2.5 47 8 63 22.5 19-6 39-9 63.5-9s44.5 3 62.5 8.5c15.5-14 43-24.5 63-22 7 13.5 8 48.5 1.5 65.5 16 19 24.5 44.5 24.5 70.5 0 61.5-46.5 108-113.5 116.5 17 11 28.5 35 28.5 62.5l0 52C323 491.5 335.5 500 350.5 494 441 459.5 512 369 512 257 512 115.5 397 0 255.5 0S0 115.5 0 257c0 111 70.5 203 165.5 237.5 13.5 5 26.5-4 26.5-17.5l0-40c-7 3-16 5-24 5-33 0-52.5-18-66.5-51.5-5.5-13.5-11.5-21.5-23-23-6-.5-8-3-8-6 0-6 10-10.5 20-10.5 14.5 0 27 9 40 27.5 10 14.5 20.5 21 33 21s20.5-4.5 32-16c8.5-8.5 15-16 21-21z`]},i_={prefix:`fas`,iconName:`magnifying-glass`,icon:[512,512,[128269,`search`],`f002`,`M416 208c0 45.9-14.9 88.3-40 122.7L502.6 457.4c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L330.7 376C296.3 401.1 253.9 416 208 416 93.1 416 0 322.9 0 208S93.1 0 208 0 416 93.1 416 208zM208 352a144 144 0 1 0 0-288 144 144 0 1 0 0 288z`]},a_={prefix:`fas`,iconName:`key`,icon:[512,512,[128273],`f084`,`M336 352c97.2 0 176-78.8 176-176S433.2 0 336 0 160 78.8 160 176c0 18.7 2.9 36.8 8.3 53.7L7 391c-4.5 4.5-7 10.6-7 17l0 80c0 13.3 10.7 24 24 24l80 0c13.3 0 24-10.7 24-24l0-40 40 0c13.3 0 24-10.7 24-24l0-40 40 0c6.4 0 12.5-2.5 17-7l33.3-33.3c16.9 5.4 35 8.3 53.7 8.3zM376 96a40 40 0 1 1 0 80 40 40 0 1 1 0-80z`]},o_={prefix:`fas`,iconName:`sort-up`,icon:[384,512,[`sort-asc`],`f0de`,`M32 224c-12.9 0-24.6-7.8-29.6-19.8S.2 178.5 9.4 169.4l160-160c12.5-12.5 32.8-12.5 45.3 0l160 160c9.2 9.2 11.9 22.9 6.9 34.9S364.9 224 352 224L32 224z`]},s_={prefix:`fas`,iconName:`eye`,icon:[576,512,[128065],`f06e`,`M288 32c-80.8 0-145.5 36.8-192.6 80.6-46.8 43.5-78.1 95.4-93 131.1-3.3 7.9-3.3 16.7 0 24.6 14.9 35.7 46.2 87.7 93 131.1 47.1 43.7 111.8 80.6 192.6 80.6s145.5-36.8 192.6-80.6c46.8-43.5 78.1-95.4 93-131.1 3.3-7.9 3.3-16.7 0-24.6-14.9-35.7-46.2-87.7-93-131.1-47.1-43.7-111.8-80.6-192.6-80.6zM144 256a144 144 0 1 1 288 0 144 144 0 1 1 -288 0zm144-64c0 35.3-28.7 64-64 64-11.5 0-22.3-3-31.7-8.4-1 10.9-.1 22.1 2.9 33.2 13.7 51.2 66.4 81.6 117.6 67.9s81.6-66.4 67.9-117.6c-12.2-45.7-55.5-74.8-101.1-70.8 5.3 9.3 8.4 20.1 8.4 31.7z`]},c_={prefix:`fas`,iconName:`chevron-up`,icon:[448,512,[],`f077`,`M201.4 105.4c12.5-12.5 32.8-12.5 45.3 0l192 192c12.5 12.5 12.5 32.8 0 45.3s-32.8 12.5-45.3 0L224 173.3 54.6 342.6c-12.5 12.5-32.8 12.5-45.3 0s-12.5-32.8 0-45.3l192-192z`]},l_={prefix:`fas`,iconName:`circle-xmark`,icon:[512,512,[61532,`times-circle`,`xmark-circle`],`f057`,`M256 512a256 256 0 1 0 0-512 256 256 0 1 0 0 512zM167 167c9.4-9.4 24.6-9.4 33.9 0l55 55 55-55c9.4-9.4 24.6-9.4 33.9 0s9.4 24.6 0 33.9l-55 55 55 55c9.4 9.4 9.4 24.6 0 33.9s-24.6 9.4-33.9 0l-55-55-55 55c-9.4 9.4-24.6 9.4-33.9 0s-9.4-24.6 0-33.9l55-55-55-55c-9.4-9.4-9.4-24.6 0-33.9z`]},u_={prefix:`fas`,iconName:`circle-exclamation`,icon:[512,512,[`exclamation-circle`],`f06a`,`M256 512a256 256 0 1 1 0-512 256 256 0 1 1 0 512zm0-192a32 32 0 1 0 0 64 32 32 0 1 0 0-64zm0-192c-18.2 0-32.7 15.5-31.4 33.7l7.4 104c.9 12.6 11.4 22.3 23.9 22.3 12.6 0 23-9.7 23.9-22.3l7.4-104c1.3-18.2-13.1-33.7-31.4-33.7z`]},d_={prefix:`fas`,iconName:`chart-line`,icon:[512,512,[`line-chart`],`f201`,`M64 64c0-17.7-14.3-32-32-32S0 46.3 0 64L0 400c0 44.2 35.8 80 80 80l400 0c17.7 0 32-14.3 32-32s-14.3-32-32-32L80 416c-8.8 0-16-7.2-16-16L64 64zm406.6 86.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0L320 210.7 262.6 153.4c-12.5-12.5-32.8-12.5-45.3 0l-96 96c-12.5 12.5-12.5 32.8 0 45.3s32.8 12.5 45.3 0l73.4-73.4 57.4 57.4c12.5 12.5 32.8 12.5 45.3 0l128-128z`]},f_={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`]},p_={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`]},m_={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`]},h_={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`]},g_={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`]},__={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`]},v_={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`]},y_={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`]},b_={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`]},x_={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 S_(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=S_(e[t]))&&(r&&(r+=` `),r+=n)}else for(n in e)e[n]&&(r&&(r+=` `),r+=n)}return r}function C_(){for(var e,t,n=0,r=``,i=arguments.length;n<i;n++)(e=arguments[n])&&(t=S_(e))&&(r&&(r+=` `),r+=t);return r}var w_=e=>typeof e==`boolean`?`${e}`:e===0?`0`:e,T_=C_,E_=(e,t)=>n=>{if(t?.variants==null)return T_(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=w_(t)||w_(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 T_(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)},D_=(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},O_=(e,t)=>({classGroupId:e,validator:t}),k_=(e=new Map,t=null,n)=>({nextPart:e,validators:t,classGroupId:n}),A_=`-`,j_=[],M_=`arbitrary..`,N_=e=>{let t=I_(e),{conflictingClassGroups:n,conflictingClassGroupModifiers:r}=e;return{getClassGroupId:e=>{if(e.startsWith(`[`)&&e.endsWith(`]`))return F_(e);let n=e.split(A_);return P_(n,+(n[0]===``&&n.length>1),t)},getConflictingClassGroupIds:(e,t)=>{if(t){let t=r[e],i=n[e];return t?i?D_(i,t):t:i||j_}return n[e]||j_}}},P_=(e,t,n)=>{if(e.length-t===0)return n.classGroupId;let r=e[t],i=n.nextPart.get(r);if(i){let n=P_(e,t+1,i);if(n)return n}let a=n.validators;if(a===null)return;let o=t===0?e.join(A_):e.slice(t).join(A_),s=a.length;for(let e=0;e<s;e++){let t=a[e];if(t.validator(o))return t.classGroupId}},F_=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?M_+r:void 0})(),I_=e=>{let{theme:t,classGroups:n}=e;return L_(n,t)},L_=(e,t)=>{let n=k_();for(let r in e){let i=e[r];R_(i,n,r,t)}return n},R_=(e,t,n,r)=>{let i=e.length;for(let a=0;a<i;a++){let i=e[a];z_(i,t,n,r)}},z_=(e,t,n,r)=>{if(typeof e==`string`){B_(e,t,n);return}if(typeof e==`function`){V_(e,t,n,r);return}H_(e,t,n,r)},B_=(e,t,n)=>{let r=e===``?t:U_(t,e);r.classGroupId=n},V_=(e,t,n,r)=>{if(W_(e)){R_(e(r),t,n,r);return}t.validators===null&&(t.validators=[]),t.validators.push(O_(n,e))},H_=(e,t,n,r)=>{let i=Object.entries(e),a=i.length;for(let e=0;e<a;e++){let[a,o]=i[e];R_(o,U_(t,a),n,r)}},U_=(e,t)=>{let n=e,r=t.split(A_),i=r.length;for(let e=0;e<i;e++){let t=r[e],i=n.nextPart.get(t);i||(i=k_(),n.nextPart.set(t,i)),n=i}return n},W_=e=>`isThemeGetter`in e&&e.isThemeGetter===!0,G_=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)}}},K_=`!`,q_=`:`,J_=[],Y_=(e,t,n,r,i)=>({modifiers:e,hasImportantModifier:t,baseClassName:n,maybePostfixModifierPosition:r,isExternal:i}),X_=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===q_){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(K_)?(c=s.slice(0,-1),l=!0):s.startsWith(K_)&&(c=s.slice(1),l=!0);let u=a&&a>i?a-i:void 0;return Y_(t,l,c,u)};if(t){let e=t+q_,n=r;r=t=>t.startsWith(e)?n(t.slice(e.length)):Y_(J_,!1,t,void 0,!0)}if(n){let e=r;r=t=>n({className:t,parseClassName:e})}return r},Z_=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}},Q_=e=>({cache:G_(e.cacheSize),parseClassName:X_(e),sortModifiers:Z_(e),postfixLookupClassGroupIds:$_(e),...N_(e)}),$_=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},ev=/\s+/,tv=(e,t)=>{let{parseClassName:n,getClassGroupId:r,getConflictingClassGroupIds:i,sortModifiers:a,postfixLookupClassGroupIds:o}=t,s=[],c=e.trim().split(ev),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?_+K_:_,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},nv=(...e)=>{let t=0,n,r,i=``;for(;t<e.length;)(n=e[t++])&&(r=rv(n))&&(i&&(i+=` `),i+=r);return i},rv=e=>{if(typeof e==`string`)return e;let t,n=``;for(let r=0;r<e.length;r++)e[r]&&(t=rv(e[r]))&&(n&&(n+=` `),n+=t);return n},iv=(e,...t)=>{let n,r,i,a,o=o=>(n=Q_(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=tv(e,n);return i(e,a),a};return a=o,(...e)=>a(nv(...e))},av=[],ov=e=>{let t=t=>t[e]||av;return t.isThemeGetter=!0,t},sv=/^\[(?:(\w[\w-]*):)?(.+)\]$/i,cv=/^\((?:(\w[\w-]*):)?(.+)\)$/i,lv=/^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/,uv=/^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/,dv=/\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$/,fv=/^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/,pv=/^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/,mv=/^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/,hv=e=>lv.test(e),Y=e=>!!e&&!Number.isNaN(Number(e)),gv=e=>!!e&&Number.isInteger(Number(e)),_v=e=>e.endsWith(`%`)&&Y(e.slice(0,-1)),vv=e=>uv.test(e),yv=()=>!0,bv=e=>dv.test(e)&&!fv.test(e),xv=()=>!1,Sv=e=>pv.test(e),Cv=e=>mv.test(e),wv=e=>!X(e)&&!Z(e),Tv=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)),Ev=e=>Vv(e,Gv,xv),X=e=>sv.test(e),Dv=e=>Vv(e,Kv,bv),Ov=e=>Vv(e,qv,Y),kv=e=>Vv(e,Yv,yv),Av=e=>Vv(e,Jv,xv),jv=e=>Vv(e,Uv,xv),Mv=e=>Vv(e,Wv,Cv),Nv=e=>Vv(e,Xv,Sv),Z=e=>cv.test(e),Pv=e=>Hv(e,Kv),Fv=e=>Hv(e,Jv),Iv=e=>Hv(e,Uv),Lv=e=>Hv(e,Gv),Rv=e=>Hv(e,Wv),zv=e=>Hv(e,Xv,!0),Bv=e=>Hv(e,Yv,!0),Vv=(e,t,n)=>{let r=sv.exec(e);return r?r[1]?t(r[1]):n(r[2]):!1},Hv=(e,t,n=!1)=>{let r=cv.exec(e);return r?r[1]?t(r[1]):n:!1},Uv=e=>e===`position`||e===`percentage`,Wv=e=>e===`image`||e===`url`,Gv=e=>e===`length`||e===`size`||e===`bg-size`,Kv=e=>e===`length`,qv=e=>e===`number`,Jv=e=>e===`family-name`,Yv=e=>e===`number`||e===`weight`,Xv=e=>e===`shadow`,Zv=iv(()=>{let e=ov(`color`),t=ov(`font`),n=ov(`text`),r=ov(`font-weight`),i=ov(`tracking`),a=ov(`leading`),o=ov(`breakpoint`),s=ov(`container`),c=ov(`spacing`),l=ov(`radius`),u=ov(`shadow`),d=ov(`inset-shadow`),f=ov(`text-shadow`),p=ov(`drop-shadow`),m=ov(`blur`),h=ov(`perspective`),g=ov(`aspect`),_=ov(`ease`),v=ov(`animate`),y=()=>[`auto`,`avoid`,`all`,`avoid-page`,`page`,`left`,`right`,`column`],b=()=>[`center`,`top`,`bottom`,`left`,`right`,`top-left`,`left-top`,`top-right`,`right-top`,`bottom-right`,`right-bottom`,`bottom-left`,`left-bottom`],x=()=>[...b(),Z,X],S=()=>[`auto`,`hidden`,`clip`,`visible`,`scroll`],C=()=>[`auto`,`contain`,`none`],w=()=>[Z,X,c],ee=()=>[hv,`full`,`auto`,...w()],te=()=>[gv,`none`,`subgrid`,Z,X],T=()=>[`auto`,{span:[`full`,gv,Z,X]},gv,Z,X],ne=()=>[gv,`auto`,Z,X],re=()=>[`auto`,`min`,`max`,`fr`,Z,X],ie=()=>[`start`,`end`,`center`,`between`,`around`,`evenly`,`stretch`,`baseline`,`center-safe`,`end-safe`],E=()=>[`start`,`end`,`center`,`stretch`,`center-safe`,`end-safe`],ae=()=>[`auto`,...w()],oe=()=>[hv,`auto`,`full`,`dvw`,`dvh`,`lvw`,`lvh`,`svw`,`svh`,`min`,`max`,`fit`,...w()],se=()=>[hv,`screen`,`full`,`dvw`,`lvw`,`svw`,`min`,`max`,`fit`,...w()],ce=()=>[hv,`screen`,`full`,`lh`,`dvh`,`lvh`,`svh`,`min`,`max`,`fit`,...w()],D=()=>[e,Z,X],le=()=>[...b(),Iv,jv,{position:[Z,X]}],ue=()=>[`no-repeat`,{repeat:[``,`x`,`y`,`space`,`round`]}],de=()=>[`auto`,`cover`,`contain`,Lv,Ev,{size:[Z,X]}],fe=()=>[_v,Pv,Dv],pe=()=>[``,`none`,`full`,l,Z,X],me=()=>[``,Y,Pv,Dv],he=()=>[`solid`,`dashed`,`dotted`,`double`],ge=()=>[`normal`,`multiply`,`screen`,`overlay`,`darken`,`lighten`,`color-dodge`,`color-burn`,`hard-light`,`soft-light`,`difference`,`exclusion`,`hue`,`saturation`,`color`,`luminosity`],_e=()=>[Y,_v,Iv,jv],ve=()=>[``,`none`,m,Z,X],ye=()=>[`none`,Y,Z,X],be=()=>[`none`,Y,Z,X],O=()=>[Y,Z,X],xe=()=>[hv,`full`,...w()];return{cacheSize:500,theme:{animate:[`spin`,`ping`,`pulse`,`bounce`],aspect:[`video`],blur:[vv],breakpoint:[vv],color:[yv],container:[vv],"drop-shadow":[vv],ease:[`in`,`out`,`in-out`],font:[wv],"font-weight":[`thin`,`extralight`,`light`,`normal`,`medium`,`semibold`,`bold`,`extrabold`,`black`],"inset-shadow":[vv],leading:[`none`,`tight`,`snug`,`normal`,`relaxed`,`loose`],perspective:[`dramatic`,`near`,`normal`,`midrange`,`distant`,`none`],radius:[vv],shadow:[vv],spacing:[`px`,Y],text:[vv],"text-shadow":[vv],tracking:[`tighter`,`tight`,`normal`,`wide`,`wider`,`widest`]},classGroups:{aspect:[{aspect:[`auto`,`square`,hv,X,Z,g]}],container:[`container`],"container-type":[{"@container":[``,`normal`,`size`,Z,X]}],"container-named":[Tv],columns:[{columns:[Y,X,Z,s]}],"break-after":[{"break-after":y()}],"break-before":[{"break-before":y()}],"break-inside":[{"break-inside":[`auto`,`avoid`,`avoid-page`,`avoid-column`]}],"box-decoration":[{"box-decoration":[`slice`,`clone`]}],box:[{box:[`border`,`content`]}],display:[`block`,`inline-block`,`inline`,`flex`,`inline-flex`,`table`,`inline-table`,`table-caption`,`table-cell`,`table-column`,`table-column-group`,`table-footer-group`,`table-header-group`,`table-row-group`,`table-row`,`flow-root`,`grid`,`inline-grid`,`contents`,`list-item`,`hidden`],sr:[`sr-only`,`not-sr-only`],float:[{float:[`right`,`left`,`none`,`start`,`end`]}],clear:[{clear:[`left`,`right`,`both`,`none`,`start`,`end`]}],isolation:[`isolate`,`isolation-auto`],"object-fit":[{object:[`contain`,`cover`,`fill`,`none`,`scale-down`]}],"object-position":[{object:x()}],overflow:[{overflow:S()}],"overflow-x":[{"overflow-x":S()}],"overflow-y":[{"overflow-y":S()}],overscroll:[{overscroll:C()}],"overscroll-x":[{"overscroll-x":C()}],"overscroll-y":[{"overscroll-y":C()}],position:[`static`,`fixed`,`absolute`,`relative`,`sticky`],inset:[{inset:ee()}],"inset-x":[{"inset-x":ee()}],"inset-y":[{"inset-y":ee()}],start:[{"inset-s":ee(),start:ee()}],end:[{"inset-e":ee(),end:ee()}],"inset-bs":[{"inset-bs":ee()}],"inset-be":[{"inset-be":ee()}],top:[{top:ee()}],right:[{right:ee()}],bottom:[{bottom:ee()}],left:[{left:ee()}],visibility:[`visible`,`invisible`,`collapse`],z:[{z:[gv,`auto`,Z,X]}],basis:[{basis:[hv,`full`,`auto`,s,...w()]}],"flex-direction":[{flex:[`row`,`row-reverse`,`col`,`col-reverse`]}],"flex-wrap":[{flex:[`nowrap`,`wrap`,`wrap-reverse`]}],flex:[{flex:[Y,hv,`auto`,`initial`,`none`,X]}],grow:[{grow:[``,Y,Z,X]}],shrink:[{shrink:[``,Y,Z,X]}],order:[{order:[gv,`first`,`last`,`none`,Z,X]}],"grid-cols":[{"grid-cols":te()}],"col-start-end":[{col:T()}],"col-start":[{"col-start":ne()}],"col-end":[{"col-end":ne()}],"grid-rows":[{"grid-rows":te()}],"row-start-end":[{row:T()}],"row-start":[{"row-start":ne()}],"row-end":[{"row-end":ne()}],"grid-flow":[{"grid-flow":[`row`,`col`,`dense`,`row-dense`,`col-dense`]}],"auto-cols":[{"auto-cols":re()}],"auto-rows":[{"auto-rows":re()}],gap:[{gap:w()}],"gap-x":[{"gap-x":w()}],"gap-y":[{"gap-y":w()}],"justify-content":[{justify:[...ie(),`normal`]}],"justify-items":[{"justify-items":[...E(),`normal`]}],"justify-self":[{"justify-self":[`auto`,...E()]}],"align-content":[{content:[`normal`,...ie()]}],"align-items":[{items:[...E(),{baseline:[``,`last`]}]}],"align-self":[{self:[`auto`,...E(),{baseline:[``,`last`]}]}],"place-content":[{"place-content":ie()}],"place-items":[{"place-items":[...E(),`baseline`]}],"place-self":[{"place-self":[`auto`,...E()]}],p:[{p:w()}],px:[{px:w()}],py:[{py:w()}],ps:[{ps:w()}],pe:[{pe:w()}],pbs:[{pbs:w()}],pbe:[{pbe:w()}],pt:[{pt:w()}],pr:[{pr:w()}],pb:[{pb:w()}],pl:[{pl:w()}],m:[{m:ae()}],mx:[{mx:ae()}],my:[{my:ae()}],ms:[{ms:ae()}],me:[{me:ae()}],mbs:[{mbs:ae()}],mbe:[{mbe:ae()}],mt:[{mt:ae()}],mr:[{mr:ae()}],mb:[{mb:ae()}],ml:[{ml:ae()}],"space-x":[{"space-x":w()}],"space-x-reverse":[`space-x-reverse`],"space-y":[{"space-y":w()}],"space-y-reverse":[`space-y-reverse`],size:[{size:oe()}],"inline-size":[{inline:[`auto`,...se()]}],"min-inline-size":[{"min-inline":[`auto`,...se()]}],"max-inline-size":[{"max-inline":[`none`,...se()]}],"block-size":[{block:[`auto`,...ce()]}],"min-block-size":[{"min-block":[`auto`,...ce()]}],"max-block-size":[{"max-block":[`none`,...ce()]}],w:[{w:[s,`screen`,...oe()]}],"min-w":[{"min-w":[s,`screen`,`none`,...oe()]}],"max-w":[{"max-w":[s,`screen`,`none`,`prose`,{screen:[o]},...oe()]}],h:[{h:[`screen`,`lh`,...oe()]}],"min-h":[{"min-h":[`screen`,`lh`,`none`,...oe()]}],"max-h":[{"max-h":[`screen`,`lh`,...oe()]}],"font-size":[{text:[`base`,n,Pv,Dv]}],"font-smoothing":[`antialiased`,`subpixel-antialiased`],"font-style":[`italic`,`not-italic`],"font-weight":[{font:[r,Bv,kv]}],"font-stretch":[{"font-stretch":[`ultra-condensed`,`extra-condensed`,`condensed`,`semi-condensed`,`normal`,`semi-expanded`,`expanded`,`extra-expanded`,`ultra-expanded`,_v,X]}],"font-family":[{font:[Fv,Av,t]}],"font-features":[{"font-features":[X]}],"fvn-normal":[`normal-nums`],"fvn-ordinal":[`ordinal`],"fvn-slashed-zero":[`slashed-zero`],"fvn-figure":[`lining-nums`,`oldstyle-nums`],"fvn-spacing":[`proportional-nums`,`tabular-nums`],"fvn-fraction":[`diagonal-fractions`,`stacked-fractions`],tracking:[{tracking:[i,Z,X]}],"line-clamp":[{"line-clamp":[Y,`none`,Z,Ov]}],leading:[{leading:[a,...w()]}],"list-image":[{"list-image":[`none`,Z,X]}],"list-style-position":[{list:[`inside`,`outside`]}],"list-style-type":[{list:[`disc`,`decimal`,`none`,Z,X]}],"text-alignment":[{text:[`left`,`center`,`right`,`justify`,`start`,`end`]}],"placeholder-color":[{placeholder:D()}],"text-color":[{text:D()}],"text-decoration":[`underline`,`overline`,`line-through`,`no-underline`],"text-decoration-style":[{decoration:[...he(),`wavy`]}],"text-decoration-thickness":[{decoration:[Y,`from-font`,`auto`,Z,Dv]}],"text-decoration-color":[{decoration:D()}],"underline-offset":[{"underline-offset":[Y,`auto`,Z,X]}],"text-transform":[`uppercase`,`lowercase`,`capitalize`,`normal-case`],"text-overflow":[`truncate`,`text-ellipsis`,`text-clip`],"text-wrap":[{text:[`wrap`,`nowrap`,`balance`,`pretty`]}],indent:[{indent:w()}],"tab-size":[{tab:[gv,Z,X]}],"vertical-align":[{align:[`baseline`,`top`,`middle`,`bottom`,`text-top`,`text-bottom`,`sub`,`super`,Z,X]}],whitespace:[{whitespace:[`normal`,`nowrap`,`pre`,`pre-line`,`pre-wrap`,`break-spaces`]}],break:[{break:[`normal`,`words`,`all`,`keep`]}],wrap:[{wrap:[`break-word`,`anywhere`,`normal`]}],hyphens:[{hyphens:[`none`,`manual`,`auto`]}],content:[{content:[`none`,Z,X]}],"bg-attachment":[{bg:[`fixed`,`local`,`scroll`]}],"bg-clip":[{"bg-clip":[`border`,`padding`,`content`,`text`]}],"bg-origin":[{"bg-origin":[`border`,`padding`,`content`]}],"bg-position":[{bg:le()}],"bg-repeat":[{bg:ue()}],"bg-size":[{bg:de()}],"bg-image":[{bg:[`none`,{linear:[{to:[`t`,`tr`,`r`,`br`,`b`,`bl`,`l`,`tl`]},gv,Z,X],radial:[``,Z,X],conic:[gv,Z,X]},Rv,Mv]}],"bg-color":[{bg:D()}],"gradient-from-pos":[{from:fe()}],"gradient-via-pos":[{via:fe()}],"gradient-to-pos":[{to:fe()}],"gradient-from":[{from:D()}],"gradient-via":[{via:D()}],"gradient-to":[{to:D()}],rounded:[{rounded:pe()}],"rounded-s":[{"rounded-s":pe()}],"rounded-e":[{"rounded-e":pe()}],"rounded-t":[{"rounded-t":pe()}],"rounded-r":[{"rounded-r":pe()}],"rounded-b":[{"rounded-b":pe()}],"rounded-l":[{"rounded-l":pe()}],"rounded-ss":[{"rounded-ss":pe()}],"rounded-se":[{"rounded-se":pe()}],"rounded-ee":[{"rounded-ee":pe()}],"rounded-es":[{"rounded-es":pe()}],"rounded-tl":[{"rounded-tl":pe()}],"rounded-tr":[{"rounded-tr":pe()}],"rounded-br":[{"rounded-br":pe()}],"rounded-bl":[{"rounded-bl":pe()}],"border-w":[{border:me()}],"border-w-x":[{"border-x":me()}],"border-w-y":[{"border-y":me()}],"border-w-s":[{"border-s":me()}],"border-w-e":[{"border-e":me()}],"border-w-bs":[{"border-bs":me()}],"border-w-be":[{"border-be":me()}],"border-w-t":[{"border-t":me()}],"border-w-r":[{"border-r":me()}],"border-w-b":[{"border-b":me()}],"border-w-l":[{"border-l":me()}],"divide-x":[{"divide-x":me()}],"divide-x-reverse":[`divide-x-reverse`],"divide-y":[{"divide-y":me()}],"divide-y-reverse":[`divide-y-reverse`],"border-style":[{border:[...he(),`hidden`,`none`]}],"divide-style":[{divide:[...he(),`hidden`,`none`]}],"border-color":[{border:D()}],"border-color-x":[{"border-x":D()}],"border-color-y":[{"border-y":D()}],"border-color-s":[{"border-s":D()}],"border-color-e":[{"border-e":D()}],"border-color-bs":[{"border-bs":D()}],"border-color-be":[{"border-be":D()}],"border-color-t":[{"border-t":D()}],"border-color-r":[{"border-r":D()}],"border-color-b":[{"border-b":D()}],"border-color-l":[{"border-l":D()}],"divide-color":[{divide:D()}],"outline-style":[{outline:[...he(),`none`,`hidden`]}],"outline-offset":[{"outline-offset":[Y,Z,X]}],"outline-w":[{outline:[``,Y,Pv,Dv]}],"outline-color":[{outline:D()}],shadow:[{shadow:[``,`none`,u,zv,Nv]}],"shadow-color":[{shadow:D()}],"inset-shadow":[{"inset-shadow":[`none`,d,zv,Nv]}],"inset-shadow-color":[{"inset-shadow":D()}],"ring-w":[{ring:me()}],"ring-w-inset":[`ring-inset`],"ring-color":[{ring:D()}],"ring-offset-w":[{"ring-offset":[Y,Dv]}],"ring-offset-color":[{"ring-offset":D()}],"inset-ring-w":[{"inset-ring":me()}],"inset-ring-color":[{"inset-ring":D()}],"text-shadow":[{"text-shadow":[`none`,f,zv,Nv]}],"text-shadow-color":[{"text-shadow":D()}],opacity:[{opacity:[Y,Z,X]}],"mix-blend":[{"mix-blend":[...ge(),`plus-darker`,`plus-lighter`]}],"bg-blend":[{"bg-blend":ge()}],"mask-clip":[{"mask-clip":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]},`mask-no-clip`],"mask-composite":[{mask:[`add`,`subtract`,`intersect`,`exclude`]}],"mask-image-linear-pos":[{"mask-linear":[Y]}],"mask-image-linear-from-pos":[{"mask-linear-from":_e()}],"mask-image-linear-to-pos":[{"mask-linear-to":_e()}],"mask-image-linear-from-color":[{"mask-linear-from":D()}],"mask-image-linear-to-color":[{"mask-linear-to":D()}],"mask-image-t-from-pos":[{"mask-t-from":_e()}],"mask-image-t-to-pos":[{"mask-t-to":_e()}],"mask-image-t-from-color":[{"mask-t-from":D()}],"mask-image-t-to-color":[{"mask-t-to":D()}],"mask-image-r-from-pos":[{"mask-r-from":_e()}],"mask-image-r-to-pos":[{"mask-r-to":_e()}],"mask-image-r-from-color":[{"mask-r-from":D()}],"mask-image-r-to-color":[{"mask-r-to":D()}],"mask-image-b-from-pos":[{"mask-b-from":_e()}],"mask-image-b-to-pos":[{"mask-b-to":_e()}],"mask-image-b-from-color":[{"mask-b-from":D()}],"mask-image-b-to-color":[{"mask-b-to":D()}],"mask-image-l-from-pos":[{"mask-l-from":_e()}],"mask-image-l-to-pos":[{"mask-l-to":_e()}],"mask-image-l-from-color":[{"mask-l-from":D()}],"mask-image-l-to-color":[{"mask-l-to":D()}],"mask-image-x-from-pos":[{"mask-x-from":_e()}],"mask-image-x-to-pos":[{"mask-x-to":_e()}],"mask-image-x-from-color":[{"mask-x-from":D()}],"mask-image-x-to-color":[{"mask-x-to":D()}],"mask-image-y-from-pos":[{"mask-y-from":_e()}],"mask-image-y-to-pos":[{"mask-y-to":_e()}],"mask-image-y-from-color":[{"mask-y-from":D()}],"mask-image-y-to-color":[{"mask-y-to":D()}],"mask-image-radial":[{"mask-radial":[Z,X]}],"mask-image-radial-from-pos":[{"mask-radial-from":_e()}],"mask-image-radial-to-pos":[{"mask-radial-to":_e()}],"mask-image-radial-from-color":[{"mask-radial-from":D()}],"mask-image-radial-to-color":[{"mask-radial-to":D()}],"mask-image-radial-shape":[{"mask-radial":[`circle`,`ellipse`]}],"mask-image-radial-size":[{"mask-radial":[{closest:[`side`,`corner`],farthest:[`side`,`corner`]}]}],"mask-image-radial-pos":[{"mask-radial-at":b()}],"mask-image-conic-pos":[{"mask-conic":[Y]}],"mask-image-conic-from-pos":[{"mask-conic-from":_e()}],"mask-image-conic-to-pos":[{"mask-conic-to":_e()}],"mask-image-conic-from-color":[{"mask-conic-from":D()}],"mask-image-conic-to-color":[{"mask-conic-to":D()}],"mask-mode":[{mask:[`alpha`,`luminance`,`match`]}],"mask-origin":[{"mask-origin":[`border`,`padding`,`content`,`fill`,`stroke`,`view`]}],"mask-position":[{mask:le()}],"mask-repeat":[{mask:ue()}],"mask-size":[{mask:de()}],"mask-type":[{"mask-type":[`alpha`,`luminance`]}],"mask-image":[{mask:[`none`,Z,X]}],filter:[{filter:[``,`none`,Z,X]}],blur:[{blur:ve()}],brightness:[{brightness:[Y,Z,X]}],contrast:[{contrast:[Y,Z,X]}],"drop-shadow":[{"drop-shadow":[``,`none`,p,zv,Nv]}],"drop-shadow-color":[{"drop-shadow":D()}],grayscale:[{grayscale:[``,Y,Z,X]}],"hue-rotate":[{"hue-rotate":[Y,Z,X]}],invert:[{invert:[``,Y,Z,X]}],saturate:[{saturate:[Y,Z,X]}],sepia:[{sepia:[``,Y,Z,X]}],"backdrop-filter":[{"backdrop-filter":[``,`none`,Z,X]}],"backdrop-blur":[{"backdrop-blur":ve()}],"backdrop-brightness":[{"backdrop-brightness":[Y,Z,X]}],"backdrop-contrast":[{"backdrop-contrast":[Y,Z,X]}],"backdrop-grayscale":[{"backdrop-grayscale":[``,Y,Z,X]}],"backdrop-hue-rotate":[{"backdrop-hue-rotate":[Y,Z,X]}],"backdrop-invert":[{"backdrop-invert":[``,Y,Z,X]}],"backdrop-opacity":[{"backdrop-opacity":[Y,Z,X]}],"backdrop-saturate":[{"backdrop-saturate":[Y,Z,X]}],"backdrop-sepia":[{"backdrop-sepia":[``,Y,Z,X]}],"border-collapse":[{border:[`collapse`,`separate`]}],"border-spacing":[{"border-spacing":w()}],"border-spacing-x":[{"border-spacing-x":w()}],"border-spacing-y":[{"border-spacing-y":w()}],"table-layout":[{table:[`auto`,`fixed`]}],caption:[{caption:[`top`,`bottom`]}],transition:[{transition:[``,`all`,`colors`,`opacity`,`shadow`,`transform`,`none`,Z,X]}],"transition-behavior":[{transition:[`normal`,`discrete`]}],duration:[{duration:[Y,`initial`,Z,X]}],ease:[{ease:[`linear`,`initial`,_,Z,X]}],delay:[{delay:[Y,Z,X]}],animate:[{animate:[`none`,v,Z,X]}],backface:[{backface:[`hidden`,`visible`]}],perspective:[{perspective:[h,Z,X]}],"perspective-origin":[{"perspective-origin":x()}],rotate:[{rotate:ye()}],"rotate-x":[{"rotate-x":ye()}],"rotate-y":[{"rotate-y":ye()}],"rotate-z":[{"rotate-z":ye()}],scale:[{scale:be()}],"scale-x":[{"scale-x":be()}],"scale-y":[{"scale-y":be()}],"scale-z":[{"scale-z":be()}],"scale-3d":[`scale-3d`],skew:[{skew:O()}],"skew-x":[{"skew-x":O()}],"skew-y":[{"skew-y":O()}],transform:[{transform:[Z,X,``,`none`,`gpu`,`cpu`]}],"transform-origin":[{origin:x()}],"transform-style":[{transform:[`3d`,`flat`]}],translate:[{translate:xe()}],"translate-x":[{"translate-x":xe()}],"translate-y":[{"translate-y":xe()}],"translate-z":[{"translate-z":xe()}],"translate-none":[`translate-none`],zoom:[{zoom:[gv,Z,X]}],accent:[{accent:D()}],appearance:[{appearance:[`none`,`auto`]}],"caret-color":[{caret:D()}],"color-scheme":[{scheme:[`normal`,`dark`,`light`,`light-dark`,`only-dark`,`only-light`]}],cursor:[{cursor:[`auto`,`default`,`pointer`,`wait`,`text`,`move`,`help`,`not-allowed`,`none`,`context-menu`,`progress`,`cell`,`crosshair`,`vertical-text`,`alias`,`copy`,`no-drop`,`grab`,`grabbing`,`all-scroll`,`col-resize`,`row-resize`,`n-resize`,`e-resize`,`s-resize`,`w-resize`,`ne-resize`,`nw-resize`,`se-resize`,`sw-resize`,`ew-resize`,`ns-resize`,`nesw-resize`,`nwse-resize`,`zoom-in`,`zoom-out`,Z,X]}],"field-sizing":[{"field-sizing":[`fixed`,`content`]}],"pointer-events":[{"pointer-events":[`auto`,`none`]}],resize:[{resize:[`none`,``,`y`,`x`]}],"scroll-behavior":[{scroll:[`auto`,`smooth`]}],"scrollbar-thumb-color":[{"scrollbar-thumb":D()}],"scrollbar-track-color":[{"scrollbar-track":D()}],"scrollbar-gutter":[{"scrollbar-gutter":[`auto`,`stable`,`both`]}],"scrollbar-w":[{scrollbar:[`auto`,`thin`,`none`]}],"scroll-m":[{"scroll-m":w()}],"scroll-mx":[{"scroll-mx":w()}],"scroll-my":[{"scroll-my":w()}],"scroll-ms":[{"scroll-ms":w()}],"scroll-me":[{"scroll-me":w()}],"scroll-mbs":[{"scroll-mbs":w()}],"scroll-mbe":[{"scroll-mbe":w()}],"scroll-mt":[{"scroll-mt":w()}],"scroll-mr":[{"scroll-mr":w()}],"scroll-mb":[{"scroll-mb":w()}],"scroll-ml":[{"scroll-ml":w()}],"scroll-p":[{"scroll-p":w()}],"scroll-px":[{"scroll-px":w()}],"scroll-py":[{"scroll-py":w()}],"scroll-ps":[{"scroll-ps":w()}],"scroll-pe":[{"scroll-pe":w()}],"scroll-pbs":[{"scroll-pbs":w()}],"scroll-pbe":[{"scroll-pbe":w()}],"scroll-pt":[{"scroll-pt":w()}],"scroll-pr":[{"scroll-pr":w()}],"scroll-pb":[{"scroll-pb":w()}],"scroll-pl":[{"scroll-pl":w()}],"snap-align":[{snap:[`start`,`end`,`center`,`align-none`]}],"snap-stop":[{snap:[`normal`,`always`]}],"snap-type":[{snap:[`none`,`x`,`y`,`both`]}],"snap-strictness":[{snap:[`mandatory`,`proximity`]}],touch:[{touch:[`auto`,`none`,`manipulation`]}],"touch-x":[{"touch-pan":[`x`,`left`,`right`]}],"touch-y":[{"touch-pan":[`y`,`up`,`down`]}],"touch-pz":[`touch-pinch-zoom`],select:[{select:[`none`,`text`,`all`,`auto`]}],"will-change":[{"will-change":[`auto`,`scroll`,`contents`,`transform`,Z,X]}],fill:[{fill:[`none`,...D()]}],"stroke-w":[{stroke:[Y,Pv,Dv,Ov]}],stroke:[{stroke:[`none`,...D()]}],"forced-color-adjust":[{"forced-color-adjust":[`auto`,`none`]}]},conflictingClassGroups:{"container-named":[`container-type`],overflow:[`overflow-x`,`overflow-y`],overscroll:[`overscroll-x`,`overscroll-y`],inset:[`inset-x`,`inset-y`,`inset-bs`,`inset-be`,`start`,`end`,`top`,`right`,`bottom`,`left`],"inset-x":[`right`,`left`],"inset-y":[`top`,`bottom`],flex:[`basis`,`grow`,`shrink`],gap:[`gap-x`,`gap-y`],p:[`px`,`py`,`ps`,`pe`,`pbs`,`pbe`,`pt`,`pr`,`pb`,`pl`],px:[`pr`,`pl`],py:[`pt`,`pb`],m:[`mx`,`my`,`ms`,`me`,`mbs`,`mbe`,`mt`,`mr`,`mb`,`ml`],mx:[`mr`,`ml`],my:[`mt`,`mb`],size:[`w`,`h`],"font-size":[`leading`],"fvn-normal":[`fvn-ordinal`,`fvn-slashed-zero`,`fvn-figure`,`fvn-spacing`,`fvn-fraction`],"fvn-ordinal":[`fvn-normal`],"fvn-slashed-zero":[`fvn-normal`],"fvn-figure":[`fvn-normal`],"fvn-spacing":[`fvn-normal`],"fvn-fraction":[`fvn-normal`],"line-clamp":[`display`,`overflow`],rounded:[`rounded-s`,`rounded-e`,`rounded-t`,`rounded-r`,`rounded-b`,`rounded-l`,`rounded-ss`,`rounded-se`,`rounded-ee`,`rounded-es`,`rounded-tl`,`rounded-tr`,`rounded-br`,`rounded-bl`],"rounded-s":[`rounded-ss`,`rounded-es`],"rounded-e":[`rounded-se`,`rounded-ee`],"rounded-t":[`rounded-tl`,`rounded-tr`],"rounded-r":[`rounded-tr`,`rounded-br`],"rounded-b":[`rounded-br`,`rounded-bl`],"rounded-l":[`rounded-tl`,`rounded-bl`],"border-spacing":[`border-spacing-x`,`border-spacing-y`],"border-w":[`border-w-x`,`border-w-y`,`border-w-s`,`border-w-e`,`border-w-bs`,`border-w-be`,`border-w-t`,`border-w-r`,`border-w-b`,`border-w-l`],"border-w-x":[`border-w-r`,`border-w-l`],"border-w-y":[`border-w-t`,`border-w-b`],"border-color":[`border-color-x`,`border-color-y`,`border-color-s`,`border-color-e`,`border-color-bs`,`border-color-be`,`border-color-t`,`border-color-r`,`border-color-b`,`border-color-l`],"border-color-x":[`border-color-r`,`border-color-l`],"border-color-y":[`border-color-t`,`border-color-b`],translate:[`translate-x`,`translate-y`,`translate-none`],"translate-none":[`translate`,`translate-x`,`translate-y`,`translate-z`],"scroll-m":[`scroll-mx`,`scroll-my`,`scroll-ms`,`scroll-me`,`scroll-mbs`,`scroll-mbe`,`scroll-mt`,`scroll-mr`,`scroll-mb`,`scroll-ml`],"scroll-mx":[`scroll-mr`,`scroll-ml`],"scroll-my":[`scroll-mt`,`scroll-mb`],"scroll-p":[`scroll-px`,`scroll-py`,`scroll-ps`,`scroll-pe`,`scroll-pbs`,`scroll-pbe`,`scroll-pt`,`scroll-pr`,`scroll-pb`,`scroll-pl`],"scroll-px":[`scroll-pr`,`scroll-pl`],"scroll-py":[`scroll-pt`,`scroll-pb`],touch:[`touch-x`,`touch-y`,`touch-pz`],"touch-x":[`touch`],"touch-y":[`touch`],"touch-pz":[`touch`]},conflictingClassGroupModifiers:{"font-size":[`leading`]},postfixLookupClassGroups:[`container-type`],orderSensitiveModifiers:[`*`,`**`,`after`,`backdrop`,`before`,`details-content`,`file`,`first-letter`,`first-line`,`marker`,`placeholder`,`selection`]}});function Qv(...e){return Zv(C_(e))}var $v=P({__name:`Alert`,props:{class:{type:[Boolean,null,String,Object,Array]},variant:{}},setup(e){let t=e;return(n,r)=>(L(),R(`div`,{"data-slot":`alert`,class:O(M(Qv)(M(ny)({variant:e.variant}),t.class)),role:`alert`},[F(n.$slots,`default`)],2))}}),ey=P({__name:`AlertDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`div`,{"data-slot":`alert-description`,class:O(M(Qv)(`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))},[F(e.$slots,`default`)],2))}}),ty=P({__name:`AlertTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`div`,{"data-slot":`alert-title`,class:O(M(Qv)(`font-medium group-has-[>svg]/alert:col-start-2 font-heading [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[F(e.$slots,`default`)],2))}}),ny=E_(`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 ry(e){return typeof e==`string`?`'${e}'`:new sy().serialize(e)}var iy=` _-,;:!?.'"()[]{}@*/\\&#%\`^+<=>|~$0123456789abcdefghijklmnopqrstuvwxyz`,ay=(function(){let e=new Uint8Array(128);for(let t=0;t<69;t++)e[iy.charCodeAt(t)]=t+1;for(let t=65;t<=90;t++)e[t]=e[t+32];return e})();function oy(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&&ay[n]?ay[n]:n+128,s=a<128&&ay[a]?ay[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 sy=(function(){class e{#e=new Map;compare(e,t){let n=typeof e,r=typeof t;return n===`string`&&r===`string`?oy(e,t):n===`number`&&r===`number`?e-t:oy(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(oy),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 cy(e,t){return e===t||ry(e)===ry(t)}function ly(e,t=-1/0,n=1/0){return Math.min(n,Math.max(t,e))}function uy(e,t){let n=typeof e==`string`&&!t?`${e}Context`:t,r=Symbol(n);return[t=>{let n=br(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=>(yr(r,e),e)]}function dy(){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 fy(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 py(e){return e==null}function my(e,t){return py(e)?!1:Array.isArray(e)?e.some(e=>cy(e,t)):cy(e,t)}function hy(e,t){return Fe()?(Ie(e,t),!0):!1}function gy(e){let t=!1,n,r=Pe(!0);return((...i)=>(t||=(n=r.run(()=>e(...i)),!0),n))}var _y=typeof window<`u`&&typeof document<`u`;typeof WorkerGlobalScope<`u`&&globalThis instanceof WorkerGlobalScope;var vy=e=>e!==void 0,yy=Object.prototype.toString,by=e=>yy.call(e)===`[object Object]`,xy=Sy();function Sy(){var e,t;return _y&&!!((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 Cy(e){return Array.isArray(e)?e:[e]}function wy(e){return e||Fs()}function Ty(e){if(!_y)return e;let t=0,n,r,i=()=>{--t,r&&t<=0&&(r.stop(),n=void 0,r=void 0)};return((...a)=>(t+=1,r||(r=Pe(!0),n=r.run(()=>e(...a))),hy(i),n))}function Ey(e){return Zt(un(e)?new Proxy({},{get(t,n,r){return M(Reflect.get(e.value,n,r))},set(t,n,r){return un(e.value[n])&&!un(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 Dy(e){return Ey(W(e))}function Oy(e,...t){let n=t.flat(),r=n[0];return Dy(()=>Object.fromEntries(typeof r==`function`?Object.entries(bn(e)).filter(([e,t])=>!r(hn(t),e)):Object.entries(bn(e)).filter(e=>!n.includes(e[0]))))}function ky(e,t=1e4){return yn((n,r)=>{let i=hn(e),a,o=()=>setTimeout(()=>{i=hn(e),r()},hn(t));return hy(()=>{clearTimeout(a)}),{get(){return n(),i},set(e){i=e,r(),clearTimeout(a),a=o()}}})}function Ay(e,t){wy(t)&&ta(e,t)}function jy(e,t,n){return Dr(e,t,{...n,immediate:!0})}var My=_y?window:void 0;_y&&window.document,_y&&window.navigator,_y&&window.location;function Ny(e){let t=hn(e);return t?.$el??t}function Py(...e){let t=(e,t,n,r)=>(e.addEventListener(t,n,r),()=>e.removeEventListener(t,n,r)),n=W(()=>{let t=Cy(hn(e[0])).filter(e=>e!=null);return t.every(e=>typeof e!=`string`)?t:void 0});return jy(()=>[n.value?.map(e=>Ny(e))??[My].filter(e=>e!=null),Cy(hn(n.value?e[1]:e[0])),Cy(M(n.value?e[2]:e[1])),hn(n.value?e[3]:e[2])],([e,n,r,i],a,o)=>{if(!e?.length||!n?.length||!r?.length)return;let s=by(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 Fy(){let e=dn(!1),t=Fs();return t&&Qi(()=>{e.value=!0},t),e}function Iy(e){let t=Fy();return W(()=>(t.value,!!e()))}function Ly(e){return typeof e==`function`?e:typeof e==`string`?t=>t.key===e:Array.isArray(e)?t=>e.includes(t.key):()=>!0}function Ry(...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=My,eventName:a=`keydown`,passive:o=!1,dedupe:s=!1}=r,c=Ly(t);return Py(i,a,e=>{e.repeat&&hn(s)||c(e)&&n(e)},o)}function zy(e){return JSON.parse(JSON.stringify(e))}function By(e,t,n={}){let{window:r=My,...i}=n,a,o=Iy(()=>r&&`ResizeObserver`in r),s=()=>{a&&=(a.disconnect(),void 0)},c=Dr(W(()=>{let t=hn(e);return Array.isArray(t)?t.map(e=>Ny(e)):[Ny(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 hy(l),{isSupported:o,stop:l}}function Vy(e,t,n,r={}){var i,a;let{clone:o=!1,passive:s=!1,eventName:c,deep:l=!1,defaultValue:u,shouldEmit:d}=r,f=Fs(),p=n||f?.emit||(f==null||(i=f.$emit)==null?void 0:i.bind(f))||(f==null||(a=f.proxy)==null||(a=a.$emit)==null?void 0:a.bind(f?.proxy)),m=c;t||=`modelValue`,m||=`update:${t.toString()}`;let h=e=>o?typeof o==`function`?o(e):zy(e):e,g=()=>vy(e[t])?h(e[t]):u,_=e=>{d?d(e)&&p(m,e):p(m,e)};if(s){let n=j(g()),r=!1;return Dr(()=>e[t],e=>{r||(r=!0,n.value=h(e),$n(()=>r=!1))}),Dr(n,n=>{!r&&(n!==e[t]||l)&&_(n)},{deep:l}),n}return W({get(){return g()},set(e){_(e)}})}function Hy(e){return e?e.flatMap(e=>e.type===I?Hy(e.children):[e]):[]}var Uy=[`INPUT`,`TEXTAREA`];function Wy(e,t,n,r={}){if(!t||r.enableIgnoredElement&&Uy.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=Gy(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 Gy(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`?Gy(e,o,n,r):o:null}var[Ky,qy]=uy(`ConfigProvider`),Jy=Zt({layersRoot:new Set,layersWithOutsidePointerEventsDisabled:new Set,originalBodyPointerEvents:void 0,branches:new Set});function Yy(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 Xy(e,t,n=`.`,r){if(!Yy(t))return Xy(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]]:Yy(a)&&Yy(i[t])?Xy(a,i[t],(n?`${n}.`:``)+t.toString(),r):a))}return i}function Zy(e){return(...t)=>t.reduce((t,n)=>Xy(t,n,``,e),{})}var Qy=Zy(),$y=Ty(()=>{let e=j(new Map),t=j(),n=W(()=>{for(let t of e.value.values())if(t)return!0;return!1}),r=Ky({scrollBody:j(!0)}),i=null,a=()=>{document.body.style.paddingRight=``,document.body.style.marginRight=``,Jy.layersWithOutsidePointerEventsDisabled.size===0&&(document.body.style.pointerEvents=``),document.documentElement.style.removeProperty(`--scrollbar-width`),document.body.style.overflow=t.value??``,xy&&i?.(),t.value=void 0};return Dr(n,(e,o)=>{if(!_y)return;if(!e){o&&a();return}t.value===void 0&&(t.value=document.body.style.overflow);let s=window.innerWidth-document.documentElement.clientWidth,c={padding:s,margin:0},l=r.scrollBody?.value?typeof r.scrollBody.value==`object`?Qy({padding:r.scrollBody.value.padding===!0?s:r.scrollBody.value.padding,margin:r.scrollBody.value.margin===!0?s:r.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`),xy&&(i=Py(document,`touchmove`,e=>nb(e),{passive:!1})),$n(()=>{n.value&&(document.body.style.pointerEvents=`none`,document.body.style.overflow=`hidden`)})},{immediate:!0,flush:`sync`}),e});function eb(e){let t=Math.random().toString(36).substring(2,7),n=$y();n.value.set(t,e??!1);let r=W({get:()=>n.value.get(t)??!1,set:e=>n.value.set(t,e)});return Ay(()=>{n.value.delete(t)}),r}function tb(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:tb(t)}}function nb(e){let t=e||window.event,n=t.target;return n instanceof Element&&tb(n)?!1:t.touches.length>1||(t.preventDefault&&t.cancelable&&t.preventDefault(),!1)}function rb(e){let t=Ky({dir:j(`ltr`)});return W(()=>e?.value||t.dir?.value||`ltr`)}function ib(e){let t=Fs(),n=t?.type.emits,r={};return n?.length||console.warn(`No emitted event found. Please check component: ${t?.type.__name}`),n?.forEach(t=>{r[ce(E(t))]=(...n)=>e(t,...n)}),r}var ab=0;function ob(){wr(e=>{if(!_y)return;let t=document.querySelectorAll(`[data-reka-focus-guard]`);document.body.insertAdjacentElement(`afterbegin`,t[0]??sb()),document.body.insertAdjacentElement(`beforeend`,t[1]??sb()),ab++,e(()=>{ab===1&&document.querySelectorAll(`[data-reka-focus-guard]`).forEach(e=>e.remove()),ab--})})}function sb(){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 cb(e){return W(()=>!hn(e)||!!Ny(e)?.closest(`form`))}function lb(){let e=Fs(),t=j(),n=W(()=>r());ea(()=>{n.value!==r()&&mn(t)});function r(){return t.value&&`$el`in t.value&&[`#text`,`#comment`].includes(t.value.$el.nodeName)?t.value.$el.nextElementSibling:Ny(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 ub(e){let t=Fs(),n=Object.keys(t?.type.props??{}).reduce((e,n)=>{let r=(t?.type.props[n]).default;return r!==void 0&&(e[n]=r),e},{}),r=Cn(e);return W(()=>{let e={},i=t?.vnode.props??{};return Object.keys(i).forEach(t=>{e[E(t)]=i[t]}),Object.keys({...n,...e}).reduce((e,t)=>(r.value[t]!==void 0&&(e[t]=r.value[t]),e),{})})}function db(e,t){let n=ub(e),r=t?ib(t):{};return W(()=>({...n.value,...r}))}var fb=function(e){return typeof document>`u`?null:(Array.isArray(e)?e[0]:e).ownerDocument.body},pb=new WeakMap,mb=new WeakMap,hb={},gb=0,_b=function(e){return e&&(e.host||_b(e.parentNode))},vb=function(e,t){return t.map(function(t){if(e.contains(t))return t;var n=_b(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})},yb=function(e,t,n,r){var i=vb(t,Array.isArray(e)?e:[e]);hb[n]||(hb[n]=new WeakMap);var a=hb[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=(pb.get(e)||0)+1,l=(a.get(e)||0)+1;pb.set(e,c),a.set(e,l),o.push(e),c===1&&i&&mb.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(),gb++,function(){o.forEach(function(e){var t=pb.get(e)-1,i=a.get(e)-1;pb.set(e,t),a.set(e,i),t||(mb.has(e)||e.removeAttribute(r),mb.delete(e)),i||e.removeAttribute(n)}),gb--,gb||(pb=new WeakMap,pb=new WeakMap,mb=new WeakMap,hb={})}},bb=function(e,t,n){n===void 0&&(n=`data-aria-hidden`);var r=Array.from(Array.isArray(e)?e:[e]),i=t||fb(e);return i?(r.push.apply(r,Array.from(i.querySelectorAll(`[aria-live], script`))),yb(r,i,n,`aria-hidden`)):function(){return null}};function xb(e){let t;Dr(()=>Ny(e),e=>{let n=!1;try{n=!!e?.closest(`[popover]:not(:popover-open)`)}catch{}e&&!n?t=bb(e):t&&t()}),na(()=>{t&&t()})}var Sb=0;function Cb(e,t=`reka`){if(e)return e;let n,r=Ky({useId:void 0});return n=r.useId?r.useId():`useId`in bu?oi?.():`${++Sb}`,t?`${t}-${n}`:n}function wb(e){let t=j(),n=W(()=>t.value?.width??0),r=W(()=>t.value?.height??0),i;return Qi(()=>{let n=Ny(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}),na(()=>{i?.disconnect(),i=void 0}),{width:n,height:r}}function Tb(e,t){let n=j(e);function r(e){return t[n.value][e]??n.value}return{state:n,dispatch:e=>{n.value=r(e)}}}function Eb(e){let t=ky(``,1e3);return{search:t,handleTypeaheadSearch:(n,r)=>{if(t.value+=n,e)e(n);else{let e=dy(),n=r.map(e=>({...e,textValue:e.value?.textValue??e.ref.textContent?.trim()??``})),i=n.find(t=>t.ref===e),a=Ob(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 Db(e,t){return e.map((n,r)=>e[(t+r)%e.length])}function Ob(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=Db(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 kb(e,t){let n=j({}),r=j(`none`),i=j(e),a=e.value?`mounted`:`unmounted`,o,s=t.value?.ownerDocument.defaultView??My,{state:c,dispatch:l}=Tb(a,{mounted:{UNMOUNT:`unmounted`,ANIMATION_OUT:`unmountSuspended`},unmountSuspended:{MOUNT:`mounted`,ANIMATION_END:`unmounted`},unmounted:{MOUNT:`mounted`}}),u=e=>{if(_y){let n=new CustomEvent(e,{bubbles:!1,cancelable:!1});t.value?.dispatchEvent(n)}};Dr(e,async(e,i)=>{let a=i!==e;if(await $n(),a){let a=r.value,o=Ab(t.value);e?(l(`MOUNT`),u(`enter`),o===`none`&&u(`after-enter`)):o===`none`||o===`undefined`||n.value?.display===`none`?(l(`UNMOUNT`),u(`leave`),u(`after-leave`)):i&&a!==o?(l(`ANIMATION_OUT`),u(`leave`)):(l(`UNMOUNT`),u(`after-leave`))}},{immediate:!0});let d=e=>{if(e.target!==t.value)return;let n=Ab(t.value),r=n.includes(CSS.escape(e.animationName)),a=c.value===`mounted`?`enter`:`leave`;if(r&&(u(`after-${a}`),l(`ANIMATION_END`),!i.value)){let e=t.value.style.animationFillMode;t.value.style.animationFillMode=`forwards`,o=s?.setTimeout(()=>{t.value?.style.animationFillMode===`forwards`&&(t.value.style.animationFillMode=e)})}n===`none`&&l(`ANIMATION_END`)},f=e=>{e.target===t.value&&(r.value=Ab(t.value))},p=Dr(t,(e,t)=>{e?(n.value=getComputedStyle(e),e.addEventListener(`animationstart`,f),e.addEventListener(`animationcancel`,d),e.addEventListener(`animationend`,d)):(l(`ANIMATION_END`),o!==void 0&&s?.clearTimeout(o),t?.removeEventListener(`animationstart`,f),t?.removeEventListener(`animationcancel`,d),t?.removeEventListener(`animationend`,d))},{immediate:!0}),m=Dr(c,()=>{let e=Ab(t.value);r.value=c.value===`mounted`?e:`none`});return na(()=>{p(),m(),t.value&&(t.value.removeEventListener(`animationstart`,f),t.value.removeEventListener(`animationcancel`,d),t.value.removeEventListener(`animationend`,d)),o!==void 0&&s?.clearTimeout(o)}),{isPresent:W(()=>[`mounted`,`unmountSuspended`].includes(c.value))}}function Ab(e){return e&&getComputedStyle(e).animationName||`none`}var jb=P({name:`Presence`,props:{present:{type:Boolean,required:!0},forceMount:{type:Boolean}},slots:{},setup(e,{slots:t,expose:n}){let{present:r,forceMount:i}=bn(e),a=j(),{isPresent:o}=kb(r,a);n({present:o});let s=t.default({present:o.value});s=Hy(s||[]);let c=Fs();if(s&&s?.length>1){let e=c?.parent?.type.name?`<${c.parent.type.name} />`:`component`;throw Error([`Detected an invalid children for \`${e}\` for  \`Presence\` component.`,``,"Note: Presence works similarly to `v-if` directly, but it waits for animation/transition to finished before unmounting. So it expect only one direct child of valid VNode type.",`You can apply a few solutions:`,["Provide a single child element so that `presence` directive attach correctly.",`Ensure the first child is an actual element instead of a raw text node or comment node.`].map(e=>`  - ${e}`).join(`
`)].join(`
`))}return()=>i.value||r.value||o.value?G(t.default({present:o.value})[0],{ref:e=>{let t=Ny(e);return t?.hasAttribute===void 0||(t?.hasAttribute(`data-reka-popper-content-wrapper`)?a.value=t.firstElementChild:a.value=t),t}}):null}}),Mb=P({name:`PrimitiveSlot`,inheritAttrs:!1,setup(e,{attrs:t,slots:n}){return()=>{if(!n.default)return null;let e=Hy(n.default()),r=e.findIndex(e=>e.type!==ls);if(r===-1)return e;let i=e[r];delete i.props?.ref;let a=i.props?ks(t,i.props):t,o=ws({...i,props:{}},a);return e.length===1?o:(e[r]=o,e)}}}),Nb=[`area`,`img`,`input`],Pb=P({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`&&Nb.includes(r)?()=>G(r,t):r===`template`?()=>G(Mb,t,{default:n.default}):()=>G(e.as,t,{default:n.default})}});function Fb(){let e=j();return{primitiveElement:e,currentElement:W(()=>[`#text`,`#comment`].includes(e.value?.$el.nodeName)?e.value?.$el.nextElementSibling:Ny(e))}}var[Ib,Lb]=uy(`CollapsibleRoot`),Rb=P({__name:`CollapsibleRoot`,props:{defaultOpen:{type:Boolean,required:!1,default:!1},open:{type:Boolean,required:!1,default:void 0},disabled:{type:Boolean,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:open`],setup(e,{expose:t,emit:n}){let r=e,i=Vy(r,`open`,n,{defaultValue:r.defaultOpen,passive:r.open===void 0}),{disabled:a,unmountOnHide:o}=bn(r);return Lb({contentId:``,disabled:a,open:i,unmountOnHide:o,onOpenToggle:()=>{a.value||(i.value=!i.value)}}),t({open:i}),lb(),(e,t)=>(L(),z(M(Pb),{as:e.as,"as-child":r.asChild,"data-state":M(i)?`open`:`closed`,"data-disabled":M(a)?``:void 0},{default:N(()=>[F(e.$slots,`default`,{open:M(i)})]),_:3},8,[`as`,`as-child`,`data-state`,`data-disabled`]))}}),zb=P({inheritAttrs:!1,__name:`CollapsibleContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`contentFound`],setup(e,{emit:t}){let n=e,r=t,i=Ib();i.contentId||=Cb(void 0,`reka-collapsible-content`);let a=j(),{forwardRef:o,currentElement:s}=lb(),c=j(0),l=j(0),u=W(()=>i.open.value),d=j(u.value),f=j();Dr(()=>[u.value,a.value?.present],async()=>{await $n();let e=s.value;if(!e)return;f.value=f.value||{transitionDuration:e.style.transitionDuration,animationName:e.style.animationName},e.style.transitionDuration=`0s`,e.style.animationName=`none`;let t=e.getBoundingClientRect();l.value=t.height,c.value=t.width,d.value||(e.style.transitionDuration=f.value.transitionDuration,e.style.animationName=f.value.animationName)},{immediate:!0});let p=W(()=>d.value&&i.open.value);return Qi(()=>{requestAnimationFrame(()=>{d.value=!1})}),Py(s,`beforematch`,e=>{requestAnimationFrame(()=>{i.onOpenToggle(),r(`contentFound`)})}),(e,t)=>(L(),z(M(jb),{ref_key:`presentRef`,ref:a,present:e.forceMount||M(i).open.value,"force-mount":!0},{default:N(({present:t})=>[V(M(Pb),ks(e.$attrs,{id:M(i).contentId,ref:M(o),"as-child":n.asChild,as:e.as,hidden:t?void 0:M(i).unmountOnHide.value?``:`until-found`,"data-state":p.value?void 0:M(i).open.value?`open`:`closed`,"data-disabled":M(i).disabled?.value?``:void 0,style:{"--reka-collapsible-content-height":`${l.value}px`,"--reka-collapsible-content-width":`${c.value}px`}}),{default:N(()=>[!M(i).unmountOnHide.value||t?F(e.$slots,`default`,{key:0}):U(`v-if`,!0)]),_:2},1040,[`id`,`as-child`,`as`,`hidden`,`data-state`,`data-disabled`,`style`])]),_:3},8,[`present`]))}}),Bb=P({__name:`CollapsibleTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e;lb();let n=Ib();return(e,r)=>(L(),z(M(Pb),{type:e.as===`button`?`button`:void 0,as:e.as,"as-child":t.asChild,"aria-controls":M(n).contentId,"aria-expanded":M(n).open.value,"data-state":M(n).open.value?`open`:`closed`,"data-disabled":M(n).disabled?.value?``:void 0,disabled:M(n).disabled?.value,onClick:M(n).onOpenToggle},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`type`,`as`,`as-child`,`aria-controls`,`aria-expanded`,`data-state`,`data-disabled`,`disabled`,`onClick`]))}});function Vb({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 Hb({type:e,defaultValue:t,modelValue:n}){return e||Vb({type:e,defaultValue:t,modelValue:n})}function Ub({type:e,defaultValue:t}){return t===void 0?e===`single`?void 0:[]:t}function Wb(e,t){let n=W(()=>Hb(e)),r=Vy(e,`modelValue`,t,{defaultValue:Ub(e),passive:e.modelValue===void 0,deep:!0});function i(e){if(n.value===`single`)r.value=cy(e,r.value)?void 0:e;else{let t=Array.isArray(r.value)?[...r.value||[]]:[r.value].filter(Boolean);if(my(t,e)){let n=t.findIndex(t=>cy(t,e));t.splice(n,1)}else t.push(e);r.value=t}}return{modelValue:r,changeModelValue:i,isSingle:W(()=>n.value===`single`)}}var[Gb,Kb]=uy(`AccordionRoot`),qb=P({__name:`AccordionRoot`,props:{collapsible:{type:Boolean,required:!1,default:!1},disabled:{type:Boolean,required:!1,default:!1},dir:{type:String,required:!1},orientation:{type:String,required:!1,default:`vertical`},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},type:{type:String,required:!1},modelValue:{type:null,required:!1},defaultValue:{type:null,required:!1}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,{dir:i,disabled:a,unmountOnHide:o}=bn(n),s=rb(i),{modelValue:c,changeModelValue:l,isSingle:u}=Wb(n,r),{forwardRef:d,currentElement:f}=lb();return Kb({disabled:a,direction:s,orientation:n.orientation,parentElement:f,isSingle:u,collapsible:n.collapsible,modelValue:c,changeModelValue:l,unmountOnHide:o}),(e,t)=>(L(),z(M(Pb),{ref:M(d),"as-child":e.asChild,as:e.as},{default:N(()=>[F(e.$slots,`default`,{modelValue:M(c)})]),_:3},8,[`as-child`,`as`]))}}),Jb=function(e){return e.Open=`open`,e.Closed=`closed`,e}(Jb||{}),[Yb,Xb]=uy(`AccordionItem`),Zb=P({__name:`AccordionItem`,props:{disabled:{type:Boolean,required:!1},value:{type:String,required:!0},unmountOnHide:{type:Boolean,required:!1,default:void 0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e,{expose:t}){let n=e,r=Gb(),i=W(()=>r.isSingle.value?n.value===r.modelValue.value:Array.isArray(r.modelValue.value)&&r.modelValue.value.includes(n.value)),a=W(()=>r.disabled.value||n.disabled),o=W(()=>a.value?``:void 0),s=W(()=>i.value?Jb.Open:Jb.Closed);t({open:i,dataDisabled:o});let{currentRef:c,currentElement:l}=lb();Xb({open:i,dataState:s,disabled:a,dataDisabled:o,triggerId:``,currentRef:c,currentElement:l,value:W(()=>n.value)});function u(e){let t=e.target;if(Array.from(r.parentElement.value?.querySelectorAll(`[data-reka-collection-item]`)??[]).findIndex(e=>e===t)===-1)return null;Wy(e,t,r.parentElement.value,{arrowKeyOptions:r.orientation,dir:r.direction.value,focus:!0})}return(e,t)=>(L(),z(M(Rb),{"data-orientation":M(r).orientation,"data-disabled":o.value,"data-state":s.value,disabled:a.value,open:i.value,as:n.as,"as-child":n.asChild,"unmount-on-hide":n.unmountOnHide??M(r).unmountOnHide.value,onKeydown:ou(u,[`up`,`down`,`left`,`right`,`home`,`end`])},{default:N(()=>[F(e.$slots,`default`,{open:i.value})]),_:3},8,[`data-orientation`,`data-disabled`,`data-state`,`disabled`,`open`,`as`,`as-child`,`unmount-on-hide`]))}}),Qb=P({__name:`AccordionContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=Gb(),r=Yb();return lb(),(e,i)=>(L(),z(M(zb),{role:`region`,"as-child":t.asChild,as:e.as,"force-mount":t.forceMount,"aria-labelledby":M(r).triggerId,"data-state":M(r).dataState.value,"data-disabled":M(r).dataDisabled.value,"data-orientation":M(n).orientation,style:{"--reka-accordion-content-width":`var(--reka-collapsible-content-width)`,"--reka-accordion-content-height":`var(--reka-collapsible-content-height)`},onContentFound:i[0]||=e=>M(n).changeModelValue(M(r).value.value)},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`force-mount`,`aria-labelledby`,`data-state`,`data-disabled`,`data-orientation`]))}}),$b=P({__name:`AccordionHeader`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`h3`}},setup(e){let t=e,n=Gb(),r=Yb();return lb(),(e,i)=>(L(),z(M(Pb),{as:t.as,"as-child":t.asChild,"data-orientation":M(n).orientation,"data-state":M(r).dataState.value,"data-disabled":M(r).dataDisabled.value},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`data-orientation`,`data-state`,`data-disabled`]))}}),ex=P({__name:`AccordionTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=Gb(),r=Yb();r.triggerId||=Cb(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)=>(L(),z(M(Bb),{id:M(r).triggerId,ref:M(r).currentRef,"data-reka-collection-item":``,as:t.as,"as-child":t.asChild,"aria-disabled":M(r).disabled.value||void 0,"aria-expanded":M(r).open.value||!1,"data-disabled":M(r).dataDisabled.value,"data-orientation":M(n).orientation,"data-state":M(r).dataState.value,disabled:M(r).disabled.value,onClick:i},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`id`,`as`,`as-child`,`aria-disabled`,`aria-expanded`,`data-disabled`,`data-orientation`,`data-state`,`disabled`]))}}),tx=`dismissableLayer.pointerDownOutside`,nx=`dismissableLayer.focusOutside`;function rx(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 ix(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=j(!1),a=j(()=>{});return wr(o=>{if(!_y||!hn(n))return;let s=async n=>{let o=n.target;if(!(!t?.value||!o)){if(rx(t.value,o)){i.value=!1;return}if(n.target&&!i.value){let t={originalEvent:n};function i(){fy(tx,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:()=>{hn(n)&&(i.value=!0)}}}function ax(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=j(!1);return wr(a=>{if(!_y||!hn(n))return;let o=async n=>{if(!t?.value)return;await $n(),await $n();let r=n.target;!t.value||!r||rx(t.value,r)||n.target&&!i.value&&fy(nx,e,{originalEvent:n})};r.addEventListener(`focusin`,o),a(()=>r.removeEventListener(`focusin`,o))}),{onFocusCapture:()=>{hn(n)&&(i.value=!0)},onBlurCapture:()=>{hn(n)&&(i.value=!1)}}}var ox=P({__name:`DismissableLayer`,props:{disableOutsidePointerEvents:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},present:{type:Boolean,required:!1,default:!0}},emits:[`escapeKeyDown`,`pointerDownOutside`,`focusOutside`,`interactOutside`,`dismiss`],setup(e,{emit:t}){let n=e,r=t,{forwardRef:i,currentElement:a}=lb(),o=W(()=>a.value?.ownerDocument??globalThis.document),s=W(()=>Jy.layersRoot),c=W(()=>a.value?Array.from(s.value).indexOf(a.value):-1),l=W(()=>Jy.layersWithOutsidePointerEventsDisabled.size>0),u=W(()=>{let e=Array.from(s.value),[t]=[...Jy.layersWithOutsidePointerEventsDisabled].slice(-1),n=e.indexOf(t);return c.value>=n}),d=ix(async e=>{let t=[...Jy.branches].some(t=>t?.contains(e.target));!n.present||!u.value||t||(r(`pointerDownOutside`,e),r(`interactOutside`,e),await $n(),e.defaultPrevented||r(`dismiss`))},a),f=ax(e=>{let t=[...Jy.branches].some(t=>t?.contains(e.target));!n.present||t||(r(`focusOutside`,e),r(`interactOutside`,e),e.defaultPrevented||r(`dismiss`))},a);return Ry(`Escape`,e=>{n.present&&c.value===s.value.size-1&&(r(`escapeKeyDown`,e),e.defaultPrevented||r(`dismiss`))}),Dr([a,()=>n.disableOutsidePointerEvents,()=>n.present],([e,t,n],r,i)=>{!e||!n||t&&(Jy.layersWithOutsidePointerEventsDisabled.size===0&&(Jy.originalBodyPointerEvents=o.value.body.style.pointerEvents,o.value.body.style.pointerEvents=`none`),Jy.layersWithOutsidePointerEventsDisabled.add(e),i(()=>{Jy.layersWithOutsidePointerEventsDisabled.delete(e),Jy.layersWithOutsidePointerEventsDisabled.size===0&&!py(Jy.originalBodyPointerEvents)&&(o.value.body.style.pointerEvents=Jy.originalBodyPointerEvents)}))},{immediate:!0}),Dr([a,()=>n.present],([e,t],n,r)=>{!e||!t||(s.value.add(e),r(()=>{s.value.delete(e)}))},{immediate:!0}),wr(e=>{e(()=>{a.value&&(s.value.delete(a.value),Jy.layersWithOutsidePointerEventsDisabled.delete(a.value))})}),(e,t)=>(L(),z(M(Pb),{ref:M(i),"as-child":e.asChild,as:e.as,"data-dismissable-layer":``,style:ge({pointerEvents:l.value?u.value?`auto`:`none`:void 0}),onFocusCapture:M(f).onFocusCapture,onBlurCapture:M(f).onBlurCapture,onPointerdownCapture:M(d).onPointerDownCapture},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`style`,`onFocusCapture`,`onBlurCapture`,`onPointerdownCapture`]))}}),sx=gy(()=>j([]));function cx(){let e=sx();return{add(t){let n=e.value[0];t!==n&&n?.pause(),e.value=lx(e.value,t),e.value.unshift(t)},remove(t){e.value=lx(e.value,t),e.value[0]?.resume()}}}function lx(e,t){let n=[...e],r=n.indexOf(t);return r!==-1&&n.splice(r,1),n}var ux=`focusScope.autoFocusOnMount`,dx=`focusScope.autoFocusOnUnmount`,fx={bubbles:!1,cancelable:!0};function px(e,{select:t=!1}={}){let n=dy();for(let r of e)if(yx(r,{select:t}),dy()!==n)return!0}function mx(e){let t=hx(e);return[gx(t,e),gx(t.reverse(),e)]}function hx(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 gx(e,t){for(let n of e)if(!_x(n,{upTo:t}))return n}function _x(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 vx(e){return e instanceof HTMLInputElement&&`select`in e}function yx(e,{select:t=!1}={}){if(e&&e.focus){let n=dy();e.focus({preventScroll:!0}),e!==n&&vx(e)&&t&&e.select()}}var bx=P({__name:`FocusScope`,props:{loop:{type:Boolean,required:!1,default:!1},trapped:{type:Boolean,required:!1,default:!1},present:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`mountAutoFocus`,`unmountAutoFocus`],setup(e,{emit:t}){let n=e,r=t,{currentRef:i,currentElement:a}=lb(),o=j(null),s=cx(),c=Zt({paused:!1,pause(){this.paused=!0},resume(){this.paused=!1}});wr(e=>{if(!_y)return;let t=a.value;if(!n.trapped)return;function r(e){if(c.paused||!t)return;let n=e.target;t.contains(n)?o.value=n:yx(o.value,{select:!0})}function i(e){if(c.paused||!t)return;let n=e.relatedTarget;n!==null&&(t.contains(n)||yx(o.value,{select:!0}))}function s(e){let n=o.value;n!==null&&e.some(e=>e.removedNodes.length>0)&&(t.contains(n)||yx(t))}document.addEventListener(`focusin`,r),document.addEventListener(`focusout`,i);let l=new MutationObserver(s);t&&l.observe(t,{childList:!0,subtree:!0}),e(()=>{document.removeEventListener(`focusin`,r),document.removeEventListener(`focusout`,i),l.disconnect()})});function l(e,t){let n=new CustomEvent(ux,fx),i=e=>r(`mountAutoFocus`,e);e.addEventListener(ux,i),e.dispatchEvent(n),e.removeEventListener(ux,i),n.defaultPrevented||(px(hx(e),{select:!0}),dy()===t&&yx(e))}wr(async e=>{let t=a.value;if(await $n(),!t)return;n.present!==!1&&s.add(c);let i=dy();!t.contains(i)&&n.present!==!1&&l(t,i),e(()=>{let e=new CustomEvent(dx,fx),n=e=>{r(`unmountAutoFocus`,e)};t.addEventListener(dx,n),t.dispatchEvent(e),t.setAttribute(`data-focus-scope-unmounting`,``),setTimeout(()=>{e.defaultPrevented||yx(i??document.body,{select:!0}),t.removeEventListener(dx,n),s.remove(c),t.removeAttribute(`data-focus-scope-unmounting`)},0)})}),Dr(()=>n.present,async(e,t)=>{if(!_y)return;if(e===!1&&t===!0){s.remove(c);return}if(e!==!0||t!==!1)return;s.add(c),await $n();let n=a.value;if(!n)return;let r=dy();n.contains(r)||l(n,r)});function u(e){if(!n.loop&&!n.trapped||c.paused)return;let t=e.key===`Tab`&&!e.altKey&&!e.ctrlKey&&!e.metaKey,r=dy();if(t&&r){let t=e.currentTarget,[i,a]=mx(t);i&&a?!e.shiftKey&&r===a?(e.preventDefault(),n.loop&&yx(i,{select:!0})):e.shiftKey&&r===i&&(e.preventDefault(),n.loop&&yx(a,{select:!0})):r===t&&e.preventDefault()}}return(e,t)=>(L(),z(M(Pb),{ref_key:`currentRef`,ref:i,tabindex:`-1`,"as-child":e.asChild,as:e.as,onKeydown:u},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`as-child`,`as`]))}}),xx=[`Enter`,` `],Sx=[`ArrowDown`,`PageUp`,`Home`],Cx=[`ArrowUp`,`PageDown`,`End`];[...Sx,...Cx],[...xx],[...xx];function wx(e){let t=dy();for(let n of e)if(n===t||(n.focus(),dy()!==t))return}var Tx=P({__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=Ky({}),r=W(()=>t.to??n.teleportTo?.value??`body`),i=Fy();return(e,t)=>M(i)||e.forceMount?(L(),z(Hr,{key:0,to:r.value,disabled:e.disabled,defer:e.defer},[F(e.$slots,`default`)],8,[`to`,`disabled`,`defer`])):U(`v-if`,!0)}}),Ex=`data-reka-collection-item`;function Dx(e={}){let{key:t=``,isProvider:n=!1}=e,r=`${t}CollectionProvider`,i;n?(i={collectionRef:j(),itemMap:j(new Map)},yr(r,i)):i=br(r);let a=(e=!1)=>{let t=i.collectionRef.value;if(!t)return[];let n=Array.from(t.querySelectorAll(`[${Ex}]`)),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=P({name:`CollectionSlot`,inheritAttrs:!1,setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=Fb();return Dr(a,()=>{i.collectionRef.value=a.value}),()=>G(Mb,{ref:r,...n},t)}}),s=P({name:`CollectionItem`,inheritAttrs:!1,props:{value:{validator:()=>!0}},setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=Fb();return wr(t=>{if(a.value){let n=sn(a.value);i.itemMap.value.set(n,{ref:a.value,value:e.value}),t(()=>i.itemMap.value.delete(n))}}),()=>G(Mb,{...n,[Ex]:``,ref:r},t)}});return{getItems:a,reactiveItems:W(()=>Array.from(i.itemMap.value.values())),itemMapSize:W(()=>i.itemMap.value.size),CollectionSlot:o,CollectionItem:s}}var Ox=P({__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)=>(L(),z(M(Pb),{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:N(()=>[F(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`aria-hidden`,`data-hidden`,`tabindex`]))}}),kx=`rovingFocusGroup.onEntryFocus`,Ax={bubbles:!1,cancelable:!0},jx={ArrowLeft:`prev`,ArrowUp:`prev`,ArrowRight:`next`,ArrowDown:`next`,PageUp:`first`,Home:`first`,PageDown:`last`,End:`last`};function Mx(e,t){return t===`rtl`?e===`ArrowLeft`?`ArrowRight`:e===`ArrowRight`?`ArrowLeft`:e:e}function Nx(e,t,n){let r=Mx(e.key,n);if(!(t===`vertical`&&[`ArrowLeft`,`ArrowRight`].includes(r))&&!(t===`horizontal`&&[`ArrowUp`,`ArrowDown`].includes(r)))return jx[r]}function Px(e,t=!1){let n=dy();for(let r of e)if(r===n||(r.focus({preventScroll:t}),dy()!==n))return}function Fx(e,t){return e.map((n,r)=>e[(t+r)%e.length])}var[Ix,Lx]=uy(`PopperRoot`),Rx=P({inheritAttrs:!1,__name:`PopperRoot`,setup(e){let t=j();return Lx({anchor:t,onAnchorChange:e=>t.value=e}),(e,t)=>F(e.$slots,`default`)}}),zx=P({__name:`PopperAnchor`,props:{reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{forwardRef:n,currentElement:r}=lb(),i=Ix();return Tr(()=>{i.onAnchorChange(t.reference??r.value)}),(e,t)=>(L(),z(M(Pb),{ref:M(n),as:e.as,"as-child":e.asChild},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`as`,`as-child`]))}});function Bx(e){return e!==null}function Vx(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]=Hx(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 Hx(e){let[t,n=`center`]=e.split(`-`);return[t,n]}var Ux=[`top`,`right`,`bottom`,`left`],Wx=Math.min,Gx=Math.max,Kx=Math.round,qx=Math.floor,Jx=e=>({x:e,y:e}),Yx={left:`right`,right:`left`,bottom:`top`,top:`bottom`};function Xx(e,t,n){return Gx(e,Wx(t,n))}function Zx(e,t){return typeof e==`function`?e(t):e}function Qx(e){return e.split(`-`)[0]}function $x(e){return e.split(`-`)[1]}function eS(e){return e===`x`?`y`:`x`}function tS(e){return e===`y`?`height`:`width`}function nS(e){let t=e[0];return t===`t`||t===`b`?`y`:`x`}function rS(e){return eS(nS(e))}function iS(e,t,n){n===void 0&&(n=!1);let r=$x(e),i=rS(e),a=tS(i),o=i===`x`?r===(n?`end`:`start`)?`right`:`left`:r===`start`?`bottom`:`top`;return t.reference[a]>t.floating[a]&&(o=pS(o)),[o,pS(o)]}function aS(e){let t=pS(e);return[oS(e),t,oS(t)]}function oS(e){return e.includes(`start`)?e.replace(`start`,`end`):e.replace(`end`,`start`)}var sS=[`left`,`right`],cS=[`right`,`left`],lS=[`top`,`bottom`],uS=[`bottom`,`top`];function dS(e,t,n){switch(e){case`top`:case`bottom`:return n?t?cS:sS:t?sS:cS;case`left`:case`right`:return t?lS:uS;default:return[]}}function fS(e,t,n,r){let i=$x(e),a=dS(Qx(e),n===`start`,r);return i&&(a=a.map(e=>e+`-`+i),t&&(a=a.concat(a.map(oS)))),a}function pS(e){let t=Qx(e);return Yx[t]+e.slice(t.length)}function mS(e){return{top:e.top??0,right:e.right??0,bottom:e.bottom??0,left:e.left??0}}function hS(e){return typeof e==`number`?{top:e,right:e,bottom:e,left:e}:mS(e)}function gS(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 _S(e,t,n){let{reference:r,floating:i}=e,a=nS(t),o=rS(t),s=tS(o),c=Qx(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=$x(t);return m&&(p[o]+=f*(m===`end`?1:-1)*(n&&l?-1:1)),p}async function vS(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}=Zx(t,e),p=hS(f),m=o[d?u===`floating`?`reference`:`floating`:u],h=gS(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=gS(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 yS=50,bS=async(e,t,n)=>{let{placement:r=`bottom`,strategy:i=`absolute`,middleware:a=[],platform:o}=n,s=o.detectOverflow?o:{...o,detectOverflow:vS},c=await(o.isRTL==null?void 0:o.isRTL(t)),l=await o.getElementRects({reference:e,floating:t,strategy:i}),{x:u,y:d}=_S(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<yS&&(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}=_S(l,f,c)),n=-1)}return{x:u,y:d,placement:f,strategy:i,middlewareData:m}},xS=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}=Zx(e,t)||{};if(l==null)return{};let d=hS(u),f={x:n,y:r},p=rS(i),m=tS(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,ee=C/2-h[m]/2-1,te=Wx(d[_],ee),T=Wx(d[v],ee),ne=C-h[m]-T,re=C/2-h[m]/2+w,ie=Xx(te,re,ne),E=!c.arrow&&$x(i)!=null&&re!==ie&&a.reference[m]/2-(re<te?te:T)-h[m]/2<0,ae=E?re<te?re-te:re-ne:0;return{[p]:f[p]+ae,data:{[p]:ie,centerOffset:re-ie-ae,...E&&{alignmentOffset:ae}},reset:E}}}),SS=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}=Zx(e,t);if((n=i.arrow)!=null&&n.alignmentOffset)return{};let g=Qx(r),_=nS(o),v=Qx(o)===o,y=await(s.isRTL==null?void 0:s.isRTL(c.floating)),b=d||(v||!m?[pS(o)]:aS(o)),x=p!==`none`;!d&&x&&b.push(...fS(o,m,p,y));let S=[o,...b],C=await s.detectOverflow(t,h),w=[],ee=i.flip?.overflows||[];if(l&&w.push(C[g]),u){let e=iS(r,a,y);w.push(C[e[0]],C[e[1]])}if(ee=[...ee,{placement:r,overflows:w}],!w.every(e=>e<=0)){let e=(i.flip?.index||0)+1,t=S[e];if(t&&(u!==`alignment`||_===nS(t)||ee.every(e=>nS(e.placement)!==_||e.overflows[0]>0)))return{data:{index:e,overflows:ee},reset:{placement:t}};let n=ee.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=ee.filter(e=>{if(x){let t=nS(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 CS(e,t){return{top:e.top-t.height,right:e.right-t.width,bottom:e.bottom-t.height,left:e.left-t.width}}function wS(e){return Ux.some(t=>e[t]>=0)}var TS=function(e){return e===void 0&&(e={}),{name:`hide`,options:e,async fn(t){let{rects:n,platform:r}=t,{strategy:i=`referenceHidden`,...a}=Zx(e,t);switch(i){case`referenceHidden`:{let e=CS(await r.detectOverflow(t,{...a,elementContext:`reference`}),n.reference);return{data:{referenceHiddenOffsets:e,referenceHidden:wS(e)}}}case`escaped`:{let e=CS(await r.detectOverflow(t,{...a,altBoundary:!0}),n.floating);return{data:{escapedOffsets:e,escaped:wS(e)}}}default:return{}}}}},ES=new Set([`left`,`top`]);async function DS(e,t){let{placement:n,platform:r,elements:i}=e,a=await(r.isRTL==null?void 0:r.isRTL(i.floating)),o=Qx(n),s=$x(n),c=nS(n)===`y`,l=ES.has(o)?-1:1,u=a&&c?-1:1,d=Zx(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 OS=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 DS(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}}}}},kS=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}=Zx(e,t),u={x:n,y:r},d=await a.detectOverflow(t,l),f=nS(i),p=eS(f),m=u[p],h=u[f],g=(e,t)=>Xx(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}}}}}},AS=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}=Zx(e,t),u={x:n,y:r},d=nS(i),f=eS(d),p=u[f],m=u[d],h=Zx(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=ES.has(Qx(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}}}},jS=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}=Zx(e,t),c=await i.detectOverflow(t,s),l=Qx(n),u=$x(n),d=nS(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=Wx(p-c[m],g),y=Wx(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*Gx(c.left,c.right):S=p-2*Gx(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 MS(){return typeof window<`u`}function NS(e){return IS(e)?(e.nodeName||``).toLowerCase():`#document`}function PS(e){var t;return(e==null||(t=e.ownerDocument)==null?void 0:t.defaultView)||window}function FS(e){return((IS(e)?e.ownerDocument:e.document)||window.document)?.documentElement}function IS(e){return MS()?e instanceof Node||e instanceof PS(e).Node:!1}function LS(e){return MS()?e instanceof Element||e instanceof PS(e).Element:!1}function RS(e){return MS()?e instanceof HTMLElement||e instanceof PS(e).HTMLElement:!1}function zS(e){return!MS()||typeof ShadowRoot>`u`?!1:e instanceof ShadowRoot||e instanceof PS(e).ShadowRoot}function BS(e){let{overflow:t,overflowX:n,overflowY:r,display:i}=ZS(e);return/auto|scroll|overlay|hidden|clip/.test(t+r+n)&&i!==`inline`&&i!==`contents`}function VS(e){return/^(table|td|th)$/.test(NS(e))}function HS(e){try{if(e.matches(`:popover-open`))return!0}catch{}try{return e.matches(`:modal`)}catch{return!1}}var US=/transform|translate|scale|rotate|perspective|filter/,WS=/paint|layout|strict|content/,GS=e=>!!e&&e!==`none`,KS;function qS(e){let t=LS(e)?ZS(e):e;return GS(t.transform)||GS(t.translate)||GS(t.scale)||GS(t.rotate)||GS(t.perspective)||!YS()&&(GS(t.backdropFilter)||GS(t.filter))||US.test(t.willChange||``)||WS.test(t.contain||``)}function JS(e){let t=$S(e);for(;RS(t)&&!XS(t);){if(qS(t))return t;if(HS(t))return null;t=$S(t)}return null}function YS(){return KS??=typeof CSS<`u`&&CSS.supports&&CSS.supports(`-webkit-backdrop-filter`,`none`),KS}function XS(e){return/^(html|body|#document)$/.test(NS(e))}function ZS(e){return PS(e).getComputedStyle(e)}function QS(e){return LS(e)?{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}:{scrollLeft:e.scrollX,scrollTop:e.scrollY}}function $S(e){if(NS(e)===`html`)return e;let t=e.assignedSlot||e.parentNode||zS(e)&&e.host||FS(e);return zS(t)?t.host:t}function eC(e){let t=$S(e);return XS(t)?(e.ownerDocument||e).body:RS(t)&&BS(t)?t:eC(t)}function tC(e,t,n){t===void 0&&(t=[]),n===void 0&&(n=!0);let r=eC(e),i=r===e.ownerDocument?.body,a=PS(r);if(i){let e=nC(a);return t.concat(a,a.visualViewport||[],BS(r)?r:[],e&&n?tC(e):[])}return t.concat(r,tC(r,[],n))}function nC(e){return e.parent&&Object.getPrototypeOf(e.parent)?e.frameElement:null}function rC(e){let t=ZS(e),n=parseFloat(t.width)||0,r=parseFloat(t.height)||0,i=RS(e),a=i?e.offsetWidth:n,o=i?e.offsetHeight:r,s=Kx(n)!==a||Kx(r)!==o;return s&&(n=a,r=o),{width:n,height:r,$:s}}function iC(e){return LS(e)?e:e.contextElement}function aC(e){let t=iC(e);if(!RS(t))return Jx(1);let n=t.getBoundingClientRect(),{width:r,height:i,$:a}=rC(t),o=(a?Kx(n.width):n.width)/r,s=(a?Kx(n.height):n.height)/i;return(!o||!Number.isFinite(o))&&(o=1),(!s||!Number.isFinite(s))&&(s=1),{x:o,y:s}}var oC=Jx(0);function sC(e){let t=PS(e);return!YS()||!t.visualViewport?oC:{x:t.visualViewport.offsetLeft,y:t.visualViewport.offsetTop}}function cC(e,t,n){return t===void 0&&(t=!1),!!n&&t&&n===PS(e)}function lC(e,t,n,r){t===void 0&&(t=!1),n===void 0&&(n=!1);let i=e.getBoundingClientRect(),a=iC(e),o=Jx(1);t&&(r?LS(r)&&(o=aC(r)):o=aC(e));let s=cC(a,n,r)?sC(a):Jx(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=PS(a),t=LS(r)?PS(r):r,n=e,i=nC(n);for(;i&&t!==n;){let e=aC(i),t=i.getBoundingClientRect(),r=ZS(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=PS(i),i=nC(n)}}return gS({width:u,height:d,x:c,y:l})}function uC(e,t){let n=QS(e).scrollLeft;return t?t.left+n:lC(FS(e)).left+n}function dC(e,t){let n=e.getBoundingClientRect();return{x:n.left+t.scrollLeft-uC(e,n),y:n.top+t.scrollTop}}function fC(e){let{elements:t,rect:n,offsetParent:r,strategy:i}=e,a=i===`fixed`,o=FS(r),s=t?HS(t.floating):!1;if(r===o||s&&a)return n;let c={scrollLeft:0,scrollTop:0},l=Jx(1),u=Jx(0),d=RS(r);if((d||!a)&&((NS(r)!==`body`||BS(o))&&(c=QS(r)),d)){let e=lC(r);l=aC(r),u.x=e.x+r.clientLeft,u.y=e.y+r.clientTop}let f=o&&!d&&!a?dC(o,c):Jx(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 pC(e){return e.getClientRects?Array.from(e.getClientRects()):[]}function mC(e){let t=QS(e),n=e.ownerDocument.body,r=Gx(e.scrollWidth,e.clientWidth,n.scrollWidth,n.clientWidth),i=Gx(e.scrollHeight,e.clientHeight,n.scrollHeight,n.clientHeight),a=-t.scrollLeft+uC(e),o=-t.scrollTop;return ZS(n).direction===`rtl`&&(a+=Gx(e.clientWidth,n.clientWidth)-r),{width:r,height:i,x:a,y:o}}var hC=25;function gC(e,t,n){n===void 0&&(n=`viewport`);let r=n===`layoutViewport`,i=PS(e),a=FS(e),o=i.visualViewport,s=a.clientWidth,c=a.clientHeight,l=0,u=0;if(o){let e=!YS()||t===`fixed`;r?e||(l=-o.offsetLeft,u=-o.offsetTop):(s=o.width,c=o.height,e&&(l=o.offsetLeft,u=o.offsetTop))}if(uC(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<=hC&&(s-=o)}return{width:s,height:c,x:l,y:u}}function _C(e,t){let n=lC(e,!0,t===`fixed`),r=n.top+e.clientTop,i=n.left+e.clientLeft,a=aC(e);return{width:e.clientWidth*a.x,height:e.clientHeight*a.y,x:i*a.x,y:r*a.y}}function vC(e,t,n){let r;if(t===`viewport`||t===`layoutViewport`)r=gC(e,n,t);else if(t===`document`)r=mC(FS(e));else if(LS(t))r=_C(t,n);else{let n=sC(e);r={x:t.x-n.x,y:t.y-n.y,width:t.width,height:t.height}}return gS(r)}function yC(e,t){let n=t.get(e);if(n)return n;let r=tC(e,[],!1).filter(e=>LS(e)&&NS(e)!==`body`),i=null,a=ZS(e).position===`fixed`,o=a?$S(e):e;for(;LS(o)&&!XS(o);){let e=ZS(o),t=qS(o),n=i?i.position:a?`fixed`:``;!t&&(n===`fixed`||n===`absolute`&&e.position===`static`)?r=r.filter(e=>e!==o):i=e,o=$S(o)}return t.set(e,r),r}function bC(e){let{element:t,boundary:n,rootBoundary:r,strategy:i}=e,a=[...n===`clippingAncestors`?HS(t)?[]:yC(t,this._c):[].concat(n),r],o=vC(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=vC(t,a[e],i);s=Gx(n.top,s),c=Wx(n.right,c),l=Wx(n.bottom,l),u=Gx(n.left,u)}return{width:c-u,height:l-s,x:u,y:s}}function xC(e){let{width:t,height:n}=rC(e);return{width:t,height:n}}function SC(e,t,n){let r=RS(t),i=FS(t),a=n===`fixed`,o=lC(e,!0,a,t),s={scrollLeft:0,scrollTop:0},c=Jx(0);if((r||!a)&&((NS(t)!==`body`||BS(i))&&(s=QS(t)),r)){let e=lC(t,!0,a,t);c.x=e.x+t.clientLeft,c.y=e.y+t.clientTop}!r&&i&&(c.x=uC(i));let l=i&&!r&&!a?dC(i,s):Jx(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 CC(e){return ZS(e).position===`static`}function wC(e,t){if(!RS(e)||ZS(e).position===`fixed`)return null;if(t)return t(e);let n=e.offsetParent;return FS(e)===n&&(n=n.ownerDocument.body),n}function TC(e,t){let n=PS(e);if(HS(e))return n;if(!RS(e)){let t=$S(e);for(;t&&!XS(t);){if(LS(t)&&!CC(t))return t;t=$S(t)}return n}let r=wC(e,t);for(;r&&VS(r)&&CC(r);)r=wC(r,t);return r&&XS(r)&&CC(r)&&!qS(r)?n:r||JS(e)||n}var EC=async function(e){let t=this.getOffsetParent||TC,n=this.getDimensions,r=await n(e.floating);return{reference:SC(e.reference,await t(e.floating),e.strategy),floating:{x:0,y:0,width:r.width,height:r.height}}};function DC(e){return ZS(e).direction===`rtl`}var OC={convertOffsetParentRelativeRectToViewportRelativeRect:fC,getDocumentElement:FS,getClippingRect:bC,getOffsetParent:TC,getElementRects:EC,getClientRects:pC,getDimensions:xC,getScale:aC,isElement:LS,isRTL:DC};function kC(e,t){return e.x===t.x&&e.y===t.y&&e.width===t.width&&e.height===t.height}function AC(e,t,n){let r=null,i,a=FS(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=qx(d),h=qx(a.clientWidth-(u+f)),g=qx(a.clientHeight-(d+p)),_=qx(u),v={rootMargin:-m+`px `+-h+`px `+-g+`px `+-_+`px`,threshold:Gx(0,Wx(1,c))||1},y=!0;function b(t){let n=t[0].intersectionRatio;if(!kC(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=PS(e),l=()=>s(n);return c.addEventListener(`resize`,l),s(!0),()=>{c.removeEventListener(`resize`,l),o()}}function jC(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=iC(e),u=i||a?[...l?tC(l):[],...t?tC(t):[]]:[];u.forEach(e=>{i&&e.addEventListener(`scroll`,n),a&&e.addEventListener(`resize`,n)});let d=l&&s?AC(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?lC(e):null;c&&g();function g(){let t=lC(e);h&&!kC(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 MC=OS,NC=kS,PC=SS,FC=jS,IC=TS,LC=xS,RC=AS,zC=(e,t,n)=>{let r=new Map,i=n??{},a={...OC,...i.platform,_c:r};return bS(e,t,{...i,platform:a})};function BC(e){return typeof e==`object`&&!!e&&`$el`in e}function VC(e){if(BC(e)){let t=e.$el;return IS(t)&&NS(t)===`#comment`?null:t}return e}function HC(e){return typeof e==`function`?e():M(e)}function UC(e){return{name:`arrow`,options:e,fn(t){let n=VC(HC(e.element));return n==null?{}:LC({element:n,padding:e.padding}).fn(t)}}}function WC(e){return typeof window>`u`?1:(e.ownerDocument.defaultView||window).devicePixelRatio||1}function GC(e,t){let n=WC(e);return Math.round(t*n)/n}function KC(e,t,n){n===void 0&&(n={});let r=n.whileElementsMounted,i=W(()=>HC(n.open)??!0),a=W(()=>HC(n.middleware)),o=W(()=>HC(n.placement)??`bottom`),s=W(()=>HC(n.strategy)??`absolute`),c=W(()=>HC(n.transform)??!0),l=W(()=>VC(e.value)),u=W(()=>VC(t.value)),d=j(0),f=j(0),p=j(s.value),m=j(o.value),h=dn({}),g=j(!1),_=W(()=>{let e={position:p.value,left:`0`,top:`0`};if(!u.value)return e;let t=GC(u.value,d.value),n=GC(u.value,f.value);return c.value?{...e,transform:`translate(`+t+`px, `+n+`px)`,...WC(u.value)>=1.5&&{willChange:`transform`}}:{position:p.value,left:t+`px`,top:n+`px`}}),v;function y(){if(l.value==null||u.value==null)return;let e=i.value;zC(l.value,u.value,{middleware:a.value,placement:o.value,strategy:s.value}).then(t=>{d.value=t.x,f.value=t.y,p.value=t.strategy,m.value=t.placement,h.value=t.middlewareData,g.value=e!==!1})}function b(){typeof v==`function`&&(v(),v=void 0)}function x(){if(b(),r===void 0){y();return}if(l.value!=null&&u.value!=null){v=r(l.value,u.value,y);return}}function S(){i.value||(g.value=!1)}return Dr([a,o,s,i],y,{flush:`sync`}),Dr([l,u],x,{flush:`sync`}),Dr(i,S,{flush:`sync`}),Fe()&&Ie(b),{x:en(d),y:en(f),strategy:en(p),placement:en(m),middlewareData:en(h),isPositioned:en(g),floatingStyles:_,update:y}}var qC=[`dir`],JC={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},[YC,XC]=uy(`PopperContent`),ZC=P({inheritAttrs:!1,__name:`PopperContent`,props:Fa({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}},{...JC}),emits:[`placed`],setup(e,{emit:t}){let n=e,r=t,i=Ix(),{forwardRef:a,currentElement:o}=lb(),s=rb(W(()=>n.dir)),c=j(),l=j(),{width:u,height:d}=wb(l),f=W(()=>n.side+(n.align===`center`?``:`-${n.align}`)),p=W(()=>typeof n.collisionPadding==`number`?n.collisionPadding:{top:0,right:0,bottom:0,left:0,...n.collisionPadding}),m=W(()=>Array.isArray(n.collisionBoundary)?n.collisionBoundary:[n.collisionBoundary]),h=W(()=>({padding:p.value,boundary:m.value.filter(Bx),altBoundary:m.value.length>0})),g=W(()=>({mainAxis:n.sideFlip,crossAxis:n.alignFlip})),_=W(()=>[MC({mainAxis:n.sideOffset+d.value,alignmentAxis:n.alignOffset}),n.prioritizePosition&&n.avoidCollisions&&PC({...h.value,...g.value}),n.avoidCollisions&&NC({mainAxis:!0,crossAxis:!!n.prioritizePosition,limiter:n.sticky===`partial`?RC():void 0,...h.value}),!n.prioritizePosition&&n.avoidCollisions&&PC({...h.value,...g.value}),FC({...h.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`)}}),l.value&&UC({element:l.value,padding:n.arrowPadding}),Vx({arrowWidth:u.value,arrowHeight:d.value,dir:s.value}),n.hideWhenDetached&&IC({strategy:`referenceHidden`,...h.value})]),{floatingStyles:v,placement:y,isPositioned:b,middlewareData:x,update:S}=KC(W(()=>n.reference??i.anchor.value),c,{strategy:n.positionStrategy,placement:f,whileElementsMounted:(...e)=>jC(...e,{layoutShift:!n.disableUpdateOnLayoutShift,animationFrame:n.updatePositionStrategy===`always`}),middleware:_}),C=W(()=>Hx(y.value)[0]),w=W(()=>Hx(y.value)[1]);Tr(()=>{b.value&&r(`placed`)});let ee=W(()=>{let e=x.value.arrow?.centerOffset!==0;return n.hideShiftedArrow&&e}),te=j(``);return wr(()=>{o.value&&(te.value=window.getComputedStyle(o.value).zIndex)}),XC({placedSide:C,onArrowChange:e=>l.value=e,arrowX:W(()=>x.value.arrow?.x??0),arrowY:W(()=>x.value.arrow?.y??0),shouldHideArrow:ee}),(e,t)=>(L(),R(`div`,{ref_key:`floatingRef`,ref:c,"data-reka-popper-content-wrapper":``,dir:M(s),style:ge({...M(v),transform:M(b)?M(v).transform:`translate(0, -200%)`,minWidth:`max-content`,zIndex:te.value,"--reka-popper-transform-origin":[M(x).transformOrigin?.x,M(x).transformOrigin?.y].join(` `),...M(x).hide?.referenceHidden&&{visibility:`hidden`,pointerEvents:`none`}})},[n.memoDependencies?nc([n.asChild,n.as,C.value,w.value,M(b),...Object.values(e.$attrs),...n.memoDependencies],()=>(L(),z(M(Pb),ks({key:0,ref:M(a)},e.$attrs,{"as-child":n.asChild,as:n.as,"data-side":C.value,"data-align":w.value,style:{animation:M(b)?void 0:`none`}}),{default:N(()=>[F(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`style`])),t,0):(L(),z(M(Pb),ks({key:1,ref:M(a)},e.$attrs,{"as-child":n.asChild,as:n.as,"data-side":C.value,"data-align":w.value,dir:M(s),style:{animation:M(b)?void 0:`none`}}),{default:N(()=>[F(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`dir`,`style`]))],12,qC))}});function QC(e){let t=Ky({nonce:j()});return W(()=>e?.value||t.nonce?.value)}var[$C,ew]=uy(`RovingFocusGroup`),tw=P({__name:`RovingFocusGroup`,props:{orientation:{type:String,required:!1,default:void 0},dir:{type:String,required:!1},loop:{type:Boolean,required:!1,default:!1},currentTabStopId:{type:[String,null],required:!1},defaultCurrentTabStopId:{type:String,required:!1},preventScrollOnEntryFocus:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`entryFocus`,`update:currentTabStopId`],setup(e,{expose:t,emit:n}){let r=e,i=n,{loop:a,orientation:o,dir:s}=bn(r),c=rb(s),l=Vy(r,`currentTabStopId`,i,{defaultValue:r.defaultCurrentTabStopId,passive:r.currentTabStopId===void 0}),u=j(!1),d=j(!1),f=j(0),{getItems:p,CollectionSlot:m}=Dx({isProvider:!0});function h(e){let t=!d.value;if(e.currentTarget&&e.target===e.currentTarget&&t&&!u.value){let t=new CustomEvent(kx,Ax);if(e.currentTarget.dispatchEvent(t),i(`entryFocus`,t),!t.defaultPrevented){let e=p().map(e=>e.ref).filter(e=>e.dataset.disabled!==``);Px([e.find(e=>e.getAttribute(`data-active`)===``),e.find(e=>e.getAttribute(`data-highlighted`)===``),e.find(e=>e.id===l.value),...e].filter(Boolean),r.preventScrollOnEntryFocus)}}d.value=!1}function g(){setTimeout(()=>{d.value=!1},1)}return t({getItems:p}),ew({loop:a,dir:c,orientation:o,currentTabStopId:l,onItemFocus:e=>{l.value=e},onItemShiftTab:()=>{u.value=!0},onFocusableItemAdd:()=>{f.value++},onFocusableItemRemove:()=>{f.value--}}),(e,t)=>(L(),z(M(m),null,{default:N(()=>[V(M(Pb),{tabindex:u.value||f.value===0?-1:0,"data-orientation":M(o),as:e.as,"as-child":e.asChild,dir:M(c),style:{outline:`none`},onMousedown:t[0]||=e=>d.value=!0,onMouseup:g,onFocus:h,onBlur:t[1]||=e=>u.value=!1},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`as`,`as-child`,`dir`])]),_:3}))}}),nw=P({__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=$C(),r=Cb(),i=W(()=>t.tabStopId||r),a=W(()=>n.currentTabStopId.value===i.value),{getItems:o,CollectionItem:s}=Dx();Qi(()=>{t.focusable&&n.onFocusableItemAdd()}),na(()=>{t.focusable&&n.onFocusableItemRemove()}),Dr(()=>t.focusable,(e,t)=>{e!==t&&(e?n.onFocusableItemAdd():n.onFocusableItemRemove())});function c(e){if(e.key===`Tab`&&e.shiftKey){n.onItemShiftTab();return}if(e.target!==e.currentTarget)return;let r=Nx(e,n.orientation.value,n.dir.value);if(r!==void 0){if(e.metaKey||e.ctrlKey||e.altKey||!t.allowShiftKey&&e.shiftKey)return;e.preventDefault();let i=[...o().map(e=>e.ref).filter(e=>e.dataset.disabled!==``)];if(r===`last`)i.reverse();else if(r===`prev`||r===`next`){r===`prev`&&i.reverse();let t=i.indexOf(e.currentTarget);i=n.loop.value?Fx(i,t+1):i.slice(t+1)}$n(()=>Px(i))}}return(e,t)=>(L(),z(M(s),null,{default:N(()=>[V(M(Pb),{tabindex:a.value?0:-1,"data-orientation":M(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?M(n).onItemFocus(i.value):t.preventDefault()},onFocus:t[1]||=e=>M(n).onItemFocus(i.value),onKeydown:c},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`data-active`,`data-disabled`,`as`,`as-child`])]),_:3}))}}),rw=[` `,`Enter`,`ArrowUp`,`ArrowDown`],iw=[` `,`Enter`];function aw(e,t,n){return e===void 0?!1:Array.isArray(e)?e.some(e=>ow(e,t,n)):ow(e,t,n)}function ow(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]:cy(e,t)}function sw(e){return e==null||e===``||Array.isArray(e)&&e.length===0}var cw=[`value`],[lw,uw]=uy(`SelectRoot`),dw=P({inheritAttrs:!1,__name:`SelectRoot`,props:{open:{type:Boolean,required:!1,default:void 0},defaultOpen:{type:Boolean,required:!1},defaultValue:{type:null,required:!1},modelValue:{type:null,required:!1,default:void 0},nullableValue:{type:String,required:!1,default:``},by:{type:[String,Function],required:!1},dir:{type:String,required:!1},multiple:{type:Boolean,required:!1},autocomplete:{type:String,required:!1},disabled:{type:Boolean,required:!1},name:{type:String,required:!1},required:{type:Boolean,required:!1}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=e,r=t,{required:i,disabled:a,multiple:o,dir:s}=bn(n),c=Vy(n,`modelValue`,r,{defaultValue:n.defaultValue??(o.value?[]:void 0),passive:n.modelValue===void 0,deep:!0}),l=Vy(n,`open`,r,{defaultValue:n.defaultOpen,passive:n.open===void 0}),u=j(),d=j(),f=j({x:0,y:0}),p=W(()=>o.value&&Array.isArray(c.value)?c.value?.length===0:py(c.value));Dx({isProvider:!0});let m=rb(s),h=cb(u),g=j(new Set),_=W(()=>Array.from(g.value).map(e=>e.value).join(`;`));function v(e){if(o.value){let t=Array.isArray(c.value)?[...c.value]:[],r=t.findIndex(t=>ow(t,e,n.by));r===-1?t.push(e):t.splice(r,1),c.value=[...t]}else c.value=e}function y(e){return Array.from(g.value).find(t=>aw(e,t.value,n.by))}return uw({triggerElement:u,onTriggerChange:e=>{u.value=e},valueElement:d,onValueElementChange:e=>{d.value=e},contentId:``,modelValue:c,onValueChange:v,by:n.by,open:l,multiple:o,required:i,onOpenChange:e=>{l.value=e},dir:m,triggerPointerDownPosRef:f,disabled:a,isEmptyModelValue:p,optionsSet:g,onOptionAdd:e=>{let t=y(e.value);t&&g.value.delete(t),g.value.add(e)},onOptionRemove:e=>{let t=y(e.value);t&&g.value.delete(t)}}),(e,t)=>(L(),z(M(Rx),null,{default:N(()=>[F(e.$slots,`default`,{modelValue:M(c),open:M(l)}),M(h)&&e.name?(L(),z(fw,{key:_.value,"aria-hidden":`true`,tabindex:`-1`,multiple:M(o),required:M(i),name:e.name,autocomplete:e.autocomplete,disabled:M(a),value:M(c)},{default:N(()=>[M(py)(M(c))?(L(),R(`option`,{key:0,value:e.nullableValue},null,8,cw)):U(`v-if`,!0),(L(!0),R(I,null,ha(Array.from(g.value),e=>(L(),R(`option`,ks({key:e.value??``},{ref_for:!0},e),null,16))),128))]),_:1},8,[`multiple`,`required`,`name`,`autocomplete`,`disabled`,`value`])):U(`v-if`,!0)]),_:3}))}}),fw=P({__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=j(),r=lw();Dr(()=>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)=>(L(),z(M(Ox),{"as-child":``},{default:N(()=>[B(`select`,ks({ref_key:`selectElement`,ref:n},t,{onInput:i}),[F(e.$slots,`default`)],16)]),_:3}))}}),pw=P({__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=ub(e);return(e,n)=>(L(),z(M(ZC),ks(M(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:N(()=>[F(e.$slots,`default`)]),_:3},16))}}),mw={onViewportChange:()=>{},itemTextRefCallback:()=>{},itemRefCallback:()=>{}},[hw,gw]=uy(`SelectContent`),_w=P({__name:`SelectContentImpl`,props:{position:{type:String,required:!1,default:`item-aligned`},bodyLock:{type:Boolean,required:!1,default:!0},memoDependencies:{type:Array,required:!1},side:{type:null,required:!1},sideOffset:{type:Number,required:!1},sideFlip:{type:Boolean,required:!1},align:{type:null,required:!1,default:`start`},alignOffset:{type:Number,required:!1},alignFlip:{type:Boolean,required:!1},avoidCollisions:{type:Boolean,required:!1},collisionBoundary:{type:null,required:!1},collisionPadding:{type:[Number,Object],required:!1},arrowPadding:{type:Number,required:!1},hideShiftedArrow:{type:Boolean,required:!1},sticky:{type:String,required:!1},hideWhenDetached:{type:Boolean,required:!1},positionStrategy:{type:String,required:!1},updatePositionStrategy:{type:String,required:!1},disableUpdateOnLayoutShift:{type:Boolean,required:!1},prioritizePosition:{type:Boolean,required:!1},reference:{type:null,required:!1},dir:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},disableOutsidePointerEvents:{type:Boolean,required:!1,default:!0}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=lw();ob(),eb(n.bodyLock);let{CollectionSlot:a,getItems:o}=Dx(),s=j();xb(s);let{search:c,handleTypeaheadSearch:l}=Eb(),u=j(),d=j(),f=j(),p=j(!1),m=j(!1),h=j(!1);function g(){d.value&&s.value&&wx([d.value,s.value])}Dr(p,()=>{g()});let{onOpenChange:_,triggerPointerDownPosRef:v}=i;wr(e=>{if(!s.value)return;let t={x:0,y:0},n=e=>{t={x:Math.abs(Math.round(e.pageX)-(v.value?.x??0)),y:Math.abs(Math.round(e.pageY)-(v.value?.y??0))}},r=e=>{e.pointerType!==`touch`&&(t.x<=10&&t.y<=10?e.preventDefault():s.value?.contains(e.target)||_(!1),document.removeEventListener(`pointermove`,n),v.value=null)};v.value!==null&&(document.addEventListener(`pointermove`,n),document.addEventListener(`pointerup`,r,{capture:!0,once:!0})),e(()=>{document.removeEventListener(`pointermove`,n),document.removeEventListener(`pointerup`,r,{capture:!0})})});function y(e){let t=e.ctrlKey||e.altKey||e.metaKey;if(e.key===`Tab`&&e.preventDefault(),!t&&e.key.length===1&&l(e.key,o()),[`ArrowUp`,`ArrowDown`,`Home`,`End`].includes(e.key)){let t=[...o().map(e=>e.ref)];if([`ArrowUp`,`End`].includes(e.key)&&(t=t.slice().reverse()),[`ArrowUp`,`ArrowDown`].includes(e.key)){let n=e.target,r=t.indexOf(n);t=t.slice(r+1)}setTimeout(()=>wx(t)),e.preventDefault()}}let b=ub(W(()=>n.position===`popper`?n:{}).value);return gw({content:s,viewport:u,onViewportChange:e=>{u.value=e},itemRefCallback:(e,t,n)=>{let r=!m.value&&!n,a=aw(i.modelValue.value,t,i.by);if(i.multiple.value){if(h.value)return;(a||r)&&(d.value=e,a&&(h.value=!0))}else(a||r)&&(d.value=e);r&&(m.value=!0)},selectedItem:d,selectedItemText:f,onItemLeave:()=>{s.value?.focus()},itemTextRefCallback:(e,t,n)=>{let r=!m.value&&!n;(aw(i.modelValue.value,t,i.by)||r)&&(f.value=e)},focusSelectedItem:g,position:n.position,isPositioned:p,searchRef:c}),(e,t)=>(L(),z(M(a),null,{default:N(()=>[V(M(bx),{"as-child":``,onMountAutoFocus:t[6]||=iu(()=>{},[`prevent`]),onUnmountAutoFocus:t[7]||=e=>{r(`closeAutoFocus`,e),!e.defaultPrevented&&(M(i).triggerElement.value?.focus({preventScroll:!0}),e.preventDefault())}},{default:N(()=>[V(M(ox),{"as-child":``,"disable-outside-pointer-events":e.disableOutsidePointerEvents,onFocusOutside:t[2]||=iu(()=>{},[`prevent`]),onDismiss:t[3]||=e=>M(i).onOpenChange(!1),onEscapeKeyDown:t[4]||=e=>r(`escapeKeyDown`,e),onPointerDownOutside:t[5]||=e=>r(`pointerDownOutside`,e)},{default:N(()=>[(L(),z(da(e.position===`popper`?pw:bw),ks({...e.$attrs,...M(b)},{id:M(i).contentId,ref:e=>{if(!e)return;let t=M(Ny)(e);t?.hasAttribute(`data-reka-popper-content-wrapper`)?s.value=t.firstElementChild:s.value=t},role:`listbox`,"data-state":M(i).open.value?`open`:`closed`,dir:M(i).dir.value,style:{display:`flex`,flexDirection:`column`,outline:`none`},onContextmenu:t[0]||=iu(()=>{},[`prevent`]),onPlaced:t[1]||=e=>p.value=!0,onKeydown:y}),{default:N(()=>[F(e.$slots,`default`)]),_:3},16,[`id`,`data-state`,`dir`,`onKeydown`]))]),_:3},8,[`disable-outside-pointer-events`])]),_:3})]),_:3}))}}),[vw,yw]=uy(`SelectItemAlignedPosition`),bw=P({inheritAttrs:!1,__name:`SelectItemAlignedPosition`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`placed`],setup(e,{emit:t}){let n=e,r=t,{getItems:i}=Dx(),a=lw(),o=hw(),s=j(!1),c=j(!0),l=j(),{forwardRef:u,currentElement:d}=lb(),{viewport:f,selectedItem:p,selectedItemText:m,focusSelectedItem:h}=o;function g(){if(a.triggerElement.value&&a.valueElement.value&&l.value&&d.value&&f?.value&&p?.value&&m?.value){let e=a.triggerElement.value.getBoundingClientRect(),t=d.value.getBoundingClientRect(),n=a.valueElement.value.getBoundingClientRect(),o=m.value.getBoundingClientRect();if(a.dir.value!==`rtl`){let r=o.left-t.left,i=n.left-r,a=e.left-i,s=e.width+a,c=Math.max(s,t.width),u=window.innerWidth-10,d=ly(i,10,Math.max(10,u-c));l.value.style.minWidth=`${s}px`,l.value.style.left=`${d}px`}else{let r=t.right-o.right,i=window.innerWidth-n.right-r,a=window.innerWidth-e.right-i,s=e.width+a,c=Math.max(s,t.width),u=window.innerWidth-10,d=ly(i,10,Math.max(10,u-c));l.value.style.minWidth=`${s}px`,l.value.style.right=`${d}px`}let c=i().map(e=>e.ref),u=window.innerHeight-20,h=f.value.scrollHeight,g=window.getComputedStyle(d.value),_=Number.parseInt(g.borderTopWidth,10),v=Number.parseInt(g.paddingTop,10),y=Number.parseInt(g.borderBottomWidth,10),b=Number.parseInt(g.paddingBottom,10),x=_+v+h+b+y,S=Math.min(p.value.offsetHeight*5,x),C=window.getComputedStyle(f.value),w=Number.parseInt(C.paddingTop,10),ee=Number.parseInt(C.paddingBottom,10),te=e.top+e.height/2-10,T=u-te,ne=p.value.offsetHeight/2,re=p.value.offsetTop+ne,ie=_+v+re,E=x-ie;if(ie<=te){let e=p.value===c.at(-1);l.value.style.bottom=`0px`;let t=d.value.clientHeight-f.value.offsetTop-f.value.offsetHeight,n=ie+Math.max(T,ne+(e?ee:0)+t+y);l.value.style.height=`${n}px`}else{let e=p.value===c[0];l.value.style.top=`0px`;let t=Math.max(te,_+f.value.offsetTop+(e?w:0)+ne)+E;l.value.style.height=`${t}px`,f.value.scrollTop=ie-te+f.value.offsetTop}l.value.style.margin=`10px 0`,l.value.style.minHeight=`${S}px`,l.value.style.maxHeight=`${u}px`,r(`placed`),requestAnimationFrame(()=>s.value=!0)}}let _=j(``);Qi(async()=>{await $n(),g(),d.value&&(_.value=window.getComputedStyle(d.value).zIndex)});function v(e){e&&c.value===!0&&(g(),h?.(),c.value=!1)}return By(a.triggerElement,()=>{g()}),yw({contentWrapper:l,shouldExpandOnScrollRef:s,onScrollButtonChange:v}),(e,t)=>(L(),R(`div`,{ref_key:`contentWrapperElement`,ref:l,style:ge({display:`flex`,flexDirection:`column`,position:`fixed`,zIndex:_.value})},[V(M(Pb),ks({ref:M(u),style:{boxSizing:`border-box`,maxHeight:`100%`}},{...e.$attrs,...n}),{default:N(()=>[F(e.$slots,`default`)]),_:3},16)],4))}}),xw=P({inheritAttrs:!1,__name:`SelectProvider`,props:{context:{type:Object,required:!0}},setup(e){return uw(e.context),gw(mw),(e,t)=>F(e.$slots,`default`)}}),Sw={key:1},Cw=P({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 n=e,r=db(n,t),i=lw(),a=j();Qi(()=>{a.value=new DocumentFragment});let o=j(),s=W(()=>n.forceMount||i.open.value),c=j(s.value),l;function u(){l&&=(clearTimeout(l),void 0)}return Dr(s,(e,t,n)=>{u(),l=setTimeout(()=>{c.value=s.value,l=void 0}),n(u)}),na(u),(e,t)=>s.value||c.value||o.value?.present?(L(),z(M(jb),{key:0,ref_key:`presenceRef`,ref:o,present:s.value},{default:N(()=>[V(_w,xe(Cs({...M(r),...e.$attrs})),{default:N(()=>[F(e.$slots,`default`)]),_:3},16)]),_:3},8,[`present`])):a.value?(L(),R(`div`,Sw,[(L(),z(Hr,{to:a.value},[V(xw,{context:M(i)},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`context`])],8,[`to`]))])):U(`v-if`,!0)}}),ww=P({__name:`SelectIcon`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(L(),z(M(Pb),{"aria-hidden":`true`,as:e.as,"as-child":e.asChild},{default:N(()=>[F(e.$slots,`default`,{},()=>[t[0]||=H(`▼`)])]),_:3},8,[`as`,`as-child`]))}}),[Tw,Ew]=uy(`SelectItem`),Dw=P({__name:`SelectItem`,props:{value:{type:null,required:!0},disabled:{type:Boolean,required:!1},textValue:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`select`],setup(e,{emit:t}){let n=e,r=t,{disabled:i}=bn(n),a=lw(),o=hw(),{forwardRef:s,currentElement:c}=lb(),{CollectionItem:l}=Dx(),u=W(()=>aw(a.modelValue?.value,n.value,a.by)),d=j(!1),f=j(n.textValue??``),p=Cb(void 0,`reka-select-item-text`);async function m(e){e.defaultPrevented||fy(`select.select`,h,{originalEvent:e,value:n.value})}async function h(e){await $n(),r(`select`,e),!e.defaultPrevented&&(i.value||(a.onValueChange(n.value),a.multiple.value||a.onOpenChange(!1)))}async function g(e){await $n(),!e.defaultPrevented&&(i.value?o.onItemLeave?.():e.currentTarget?.focus({preventScroll:!0}))}async function _(e){await $n(),!e.defaultPrevented&&e.currentTarget===dy()&&o.onItemLeave?.()}async function v(e){await $n(),!e.defaultPrevented&&(o.searchRef?.value===``||e.key!==` `)&&(iw.includes(e.key)&&m(e),e.key===` `&&e.preventDefault())}if(n.value===``)throw Error(`A <SelectItem /> must have a value prop that is not an empty string. This is because the Select value can be set to an empty string to clear the selection and show the placeholder.`);return Qi(()=>{c.value&&o.itemRefCallback(c.value,n.value,n.disabled)}),Ew({value:n.value,disabled:i,textId:p,isSelected:u,onItemTextChange:e=>{f.value=((f.value||e?.textContent)??``).trim()}}),(e,t)=>(L(),z(M(l),{value:{textValue:f.value}},{default:N(()=>[V(M(Pb),{ref:M(s),role:`option`,"aria-labelledby":M(p),"data-highlighted":d.value?``:void 0,"aria-selected":u.value,"data-state":u.value?`checked`:`unchecked`,"aria-disabled":M(i)||void 0,"data-disabled":M(i)?``:void 0,tabindex:M(i)?void 0:-1,as:e.as,"as-child":e.asChild,onFocus:t[0]||=e=>d.value=!0,onBlur:t[1]||=e=>d.value=!1,onPointerup:m,onPointerdown:t[2]||=e=>{e.currentTarget.focus({preventScroll:!0})},onTouchend:t[3]||=iu(()=>{},[`prevent`,`stop`]),onPointermove:g,onPointerleave:_,onKeydown:v},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`aria-labelledby`,`data-highlighted`,`aria-selected`,`data-state`,`aria-disabled`,`data-disabled`,`tabindex`,`as`,`as-child`])]),_:3},8,[`value`]))}}),Ow=P({__name:`SelectItemIndicator`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=Tw();return(e,r)=>M(n).isSelected.value?(L(),z(M(Pb),ks({key:0,"aria-hidden":`true`},t),{default:N(()=>[F(e.$slots,`default`)]),_:3},16)):U(`v-if`,!0)}}),kw=P({inheritAttrs:!1,__name:`SelectItemText`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=lw(),r=hw(),i=Tw(),{forwardRef:a,currentElement:o}=lb(),s=W(()=>({value:i.value,disabled:i.disabled.value,textContent:o.value?.textContent??i.value?.toString()??``}));return Qi(()=>{o.value&&(i.onItemTextChange(o.value),r.itemTextRefCallback(o.value,i.value,i.disabled.value),n.onOptionAdd(s.value))}),na(()=>{n.onOptionRemove(s.value)}),(e,n)=>(L(),z(M(Pb),ks({id:M(i).textId,ref:M(a)},{...t,...e.$attrs}),{default:N(()=>[F(e.$slots,`default`)]),_:3},16,[`id`]))}}),Aw=P({__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)=>(L(),z(M(Tx),xe(Cs(t)),{default:N(()=>[F(e.$slots,`default`)]),_:3},16))}}),jw=P({__name:`SelectScrollButtonImpl`,emits:[`autoScroll`],setup(e,{emit:t}){let n=t,{getItems:r}=Dx(),i=hw(),a=j(null);function o(){a.value!==null&&(window.clearInterval(a.value),a.value=null)}wr(()=>{r().map(e=>e.ref).find(e=>e===dy())?.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 ta(()=>o()),(e,t)=>(L(),z(M(Pb),ks({"aria-hidden":`true`,style:{flexShrink:0}},e.$parent?.$props,{onPointerdown:s,onPointermove:c,onPointerleave:t[0]||=()=>{o()}}),{default:N(()=>[F(e.$slots,`default`)]),_:3},16))}}),Mw=P({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=hw(),n=t.position===`item-aligned`?vw():void 0,{forwardRef:r,currentElement:i}=lb(),a=j(!1);return wr(e=>{if(t.viewport?.value&&t.isPositioned?.value){let n=t.viewport.value;function r(){let e=n.scrollHeight-n.clientHeight;a.value=Math.ceil(n.scrollTop)<e}r(),n.addEventListener(`scroll`,r),e(()=>n.removeEventListener(`scroll`,r))}}),Dr(i,()=>{i.value&&n?.onScrollButtonChange(i.value)}),(e,n)=>a.value?(L(),z(jw,{key:0,ref:M(r),onAutoScroll:n[0]||=()=>{let{viewport:e,selectedItem:n}=M(t);e?.value&&n?.value&&(e.value.scrollTop=e.value.scrollTop+n.value.offsetHeight)}},{default:N(()=>[F(e.$slots,`default`)]),_:3},512)):U(`v-if`,!0)}}),Nw=P({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=hw(),n=t.position===`item-aligned`?vw():void 0,{forwardRef:r,currentElement:i}=lb(),a=j(!1);return wr(e=>{if(t.viewport?.value&&t.isPositioned?.value){let n=t.viewport.value;function r(){a.value=n.scrollTop>0}r(),n.addEventListener(`scroll`,r),e(()=>n.removeEventListener(`scroll`,r))}}),Dr(i,()=>{i.value&&n?.onScrollButtonChange(i.value)}),(e,n)=>a.value?(L(),z(jw,{key:0,ref:M(r),onAutoScroll:n[0]||=()=>{let{viewport:e,selectedItem:n}=M(t);e?.value&&n?.value&&(e.value.scrollTop=e.value.scrollTop-n.value.offsetHeight)}},{default:N(()=>[F(e.$slots,`default`)]),_:3},512)):U(`v-if`,!0)}}),Pw=P({__name:`SelectTrigger`,props:{disabled:{type:Boolean,required:!1},reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e,n=lw(),{forwardRef:r,currentElement:i}=lb(),a=W(()=>n.disabled?.value||t.disabled);n.contentId||=Cb(void 0,`reka-select-content`),Qi(()=>{n.onTriggerChange(i.value)});let{getItems:o}=Dx(),{search:s,handleTypeaheadSearch:c,resetTypeahead:l}=Eb();function u(){a.value||(n.onOpenChange(!0),l())}function d(e){u(),n.triggerPointerDownPosRef.value={x:Math.round(e.pageX),y:Math.round(e.pageY)}}function f(e){return e.button===0&&e.ctrlKey===!1}let p=!1;function m(e){if(e.pointerType===`touch`)return e.preventDefault();let t=e.target;t.hasPointerCapture(e.pointerId)&&t.releasePointerCapture(e.pointerId),f(e)&&(d(e),p=!0)}function h(e){f(e)&&e.preventDefault()}function g(e){p||e.currentTarget?.focus(),p=!1}return(e,t)=>(L(),z(M(zx),{"as-child":``,reference:e.reference},{default:N(()=>[V(M(Pb),{ref:M(r),role:`combobox`,type:e.as===`button`?`button`:void 0,"aria-controls":M(n).contentId,"aria-expanded":M(n).open.value||!1,"aria-required":M(n).required?.value,"aria-autocomplete":`none`,disabled:a.value,dir:M(n)?.dir.value,"data-state":M(n)?.open.value?`open`:`closed`,"data-disabled":a.value?``:void 0,"data-placeholder":M(sw)(M(n).modelValue?.value)?``:void 0,"as-child":e.asChild,as:e.as,onClick:g,onPointerdown:m,onMousedown:h,onPointerup:t[0]||=iu(e=>{e.pointerType===`touch`&&d(e)},[`prevent`]),onKeydown:t[1]||=e=>{let t=M(s)!==``;!(e.ctrlKey||e.altKey||e.metaKey)&&e.key.length===1&&t&&e.key===` `||(M(c)(e.key,M(o)()),M(rw).includes(e.key)&&(u(),e.preventDefault()))}},{default:N(()=>[F(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`]))}}),Fw=P({__name:`SelectValue`,props:{placeholder:{type:String,required:!1,default:``},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,{forwardRef:n,currentElement:r}=lb(),i=lw();Qi(()=>{i.valueElement=r});let a=W(()=>{let e=[],t=Array.from(i.optionsSet.value),n=e=>t.find(t=>aw(e,t.value,i.by));return e=Array.isArray(i.modelValue.value)?i.modelValue.value.map(e=>n(e)?.textContent??``):[n(i.modelValue.value)?.textContent??``],e.filter(Boolean)}),o=W(()=>a.value.length?a.value.join(`, `):t.placeholder);return(e,r)=>(L(),z(M(Pb),{ref:M(n),as:e.as,"as-child":e.asChild,style:{pointerEvents:`none`},"data-placeholder":a.value.length?void 0:t.placeholder},{default:N(()=>[F(e.$slots,`default`,{selectedLabel:a.value,modelValue:M(i).modelValue.value},()=>[H(k(o.value),1)])]),_:3},8,[`as`,`as-child`,`data-placeholder`]))}}),Iw=P({__name:`SelectViewport`,props:{nonce:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{nonce:n}=bn(t),r=QC(n),i=hw(),a=i.position===`item-aligned`?vw():void 0,{forwardRef:o,currentElement:s}=lb();Qi(()=>{i?.onViewportChange(s.value)});let c=j(0);function l(e){let t=e.currentTarget,{shouldExpandOnScrollRef:n,contentWrapper:r}=a??{};if(n?.value&&r?.value){let e=Math.abs(c.value-t.scrollTop);if(e>0){let n=window.innerHeight-20,i=Number.parseFloat(r.value.style.minHeight),a=Number.parseFloat(r.value.style.height),o=Math.max(i,a);if(o<n){let i=o+e,a=Math.min(n,i),s=i-a;r.value.style.height=`${a}px`,r.value.style.bottom===`0px`&&(t.scrollTop=s>0?s:0,r.value.style.justifyContent=`flex-end`)}}}c.value=t.scrollTop}return(e,n)=>(L(),R(I,null,[V(M(Pb),ks({ref:M(o),"data-reka-select-viewport":``,role:`presentation`},{...e.$attrs,...t},{style:{position:`relative`,flex:1,overflow:`hidden auto`},onScroll:l}),{default:N(()=>[F(e.$slots,`default`)]),_:3},16),V(M(Pb),{as:`style`,nonce:M(r)},{default:N(()=>n[0]||=[H(` /* 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))}}),[Lw,Rw]=uy(`TabsRoot`),zw=P({__name:`TabsRoot`,props:{defaultValue:{type:null,required:!1},orientation:{type:String,required:!1,default:`horizontal`},dir:{type:String,required:!1},activationMode:{type:String,required:!1,default:`automatic`},modelValue:{type:null,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,{orientation:i,unmountOnHide:a,dir:o}=bn(n),s=rb(o);lb();let c=Vy(n,`modelValue`,r,{defaultValue:n.defaultValue,passive:n.modelValue===void 0}),l=j(),u=dn(new Set);return Rw({modelValue:c,changeModelValue:e=>{c.value=e},orientation:i,dir:s,unmountOnHide:a,activationMode:n.activationMode,baseId:Cb(void 0,`reka-tabs`),tabsList:l,contentIds:u,registerContent:e=>{u.value=new Set([...u.value,e])},unregisterContent:e=>{let t=new Set(u.value);t.delete(e),u.value=t}}),(e,t)=>(L(),z(M(Pb),{dir:M(s),"data-orientation":M(i),"as-child":e.asChild,as:e.as},{default:N(()=>[F(e.$slots,`default`,{modelValue:M(c)})]),_:3},8,[`dir`,`data-orientation`,`as-child`,`as`]))}});function Bw(e,t){return`${e}-trigger-${t}`}function Vw(e,t){return`${e}-content-${t}`}var Hw=P({__name:`TabsContent`,props:{value:{type:[String,Number],required:!0},forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,{forwardRef:n}=lb(),r=Lw(),i=W(()=>Bw(r.baseId,t.value)),a=W(()=>Vw(r.baseId,t.value)),o=W(()=>t.value===r.modelValue.value),s=j(o.value);return Qi(()=>{r.registerContent(t.value),requestAnimationFrame(()=>{s.value=!1})}),ta(()=>{r.unregisterContent(t.value)}),(e,t)=>(L(),z(M(jb),{present:e.forceMount||o.value,"force-mount":``},{default:N(({present:t})=>[V(M(Pb),{id:a.value,ref:M(n),"as-child":e.asChild,as:e.as,role:`tabpanel`,"data-state":o.value?`active`:`inactive`,"data-orientation":M(r).orientation.value,"aria-labelledby":i.value,hidden:!t,tabindex:`0`,style:ge({animationDuration:s.value?`0s`:void 0})},{default:N(()=>[!M(r).unmountOnHide.value||t?F(e.$slots,`default`,{key:0}):U(`v-if`,!0)]),_:2},1032,[`id`,`as-child`,`as`,`data-state`,`data-orientation`,`aria-labelledby`,`hidden`,`style`])]),_:3},8,[`present`]))}}),Uw=P({__name:`TabsList`,props:{loop:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let{loop:t}=bn(e),{forwardRef:n,currentElement:r}=lb(),i=Lw();return i.tabsList=r,(e,r)=>(L(),z(M(tw),{"as-child":``,orientation:M(i).orientation.value,dir:M(i).dir.value,loop:M(t)},{default:N(()=>[V(M(Pb),{ref:M(n),role:`tablist`,"as-child":e.asChild,as:e.as,"aria-orientation":M(i).orientation.value},{default:N(()=>[F(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`aria-orientation`])]),_:3},8,[`orientation`,`dir`,`loop`]))}}),Ww=P({__name:`TabsTrigger`,props:{value:{type:[String,Number],required:!0},disabled:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(e){let t=e,{forwardRef:n}=lb(),r=Lw(),i=W(()=>Bw(r.baseId,t.value)),a=W(()=>r.contentIds.value.has(t.value)?Vw(r.baseId,t.value):void 0),o=W(()=>t.value===r.modelValue.value);return(e,t)=>(L(),z(M(nw),{"as-child":``,focusable:!e.disabled,active:o.value},{default:N(()=>[V(M(Pb),{id:i.value,ref:M(n),role:`tab`,type:e.as===`button`?`button`:void 0,as:e.as,"as-child":e.asChild,"aria-selected":o.value?`true`:`false`,"aria-controls":a.value,"data-state":o.value?`active`:`inactive`,disabled:e.disabled,"data-disabled":e.disabled?``:void 0,"data-orientation":M(r).orientation.value,onMousedown:t[0]||=iu(t=>{!e.disabled&&t.ctrlKey===!1?M(r).changeModelValue(e.value):t.preventDefault()},[`left`]),onKeydown:t[1]||=ou(t=>M(r).changeModelValue(e.value),[`enter`,`space`]),onFocus:t[2]||=()=>{let t=M(r).activationMode!==`manual`;!o.value&&!e.disabled&&t&&M(r).changeModelValue(e.value)}},{default:N(()=>[F(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`]))}}),Gw=P({__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)=>(L(),z(M(Pb),{"data-slot":`button`,"data-variant":e.variant,"data-size":e.size,as:e.as,"as-child":e.asChild,class:O(M(Qv)(M(Kw)({variant:e.variant,size:e.size}),t.class))},{default:N(()=>[F(n.$slots,`default`)]),_:3},8,[`data-variant`,`data-size`,`as`,`as-child`,`class`]))}}),Kw=E_(`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`}}),qw=[`data-size`],Jw=P({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e;return(n,r)=>(L(),R(`div`,{"data-slot":`card`,"data-size":e.size,class:O(M(Qv)(`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))},[F(n.$slots,`default`)],10,qw))}}),Yw=P({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`div`,{"data-slot":`card-content`,class:O(M(Qv)(`px-4 group-data-[size=sm]/card:px-3`,t.class))},[F(e.$slots,`default`)],2))}}),Xw=P({__name:`CardDescription`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`div`,{"data-slot":`card-description`,class:O(M(Qv)(`text-muted-foreground text-sm`,t.class))},[F(e.$slots,`default`)],2))}}),Zw=P({__name:`CardHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`div`,{"data-slot":`card-header`,class:O(M(Qv)(`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))},[F(e.$slots,`default`)],2))}}),Qw=P({__name:`CardTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`div`,{"data-slot":`card-title`,class:O(M(Qv)(`text-base leading-snug font-medium group-data-[size=sm]/card:text-sm font-heading`,t.class))},[F(e.$slots,`default`)],2))}}),$w=P({__name:`Input`,props:{defaultValue:{},modelValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=Vy(n,`modelValue`,t,{passive:!0,defaultValue:n.defaultValue});return(e,t)=>_r((L(),R(`input`,{"onUpdate:modelValue":t[0]||=e=>un(r)?r.value=e:null,"data-slot":`input`,class:O(M(Qv)(`dark:bg-input/30 border-input focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive dark:aria-invalid:border-destructive/50 disabled:bg-input/50 dark:disabled:bg-input/80 h-8 rounded-lg border bg-transparent px-2.5 py-1 text-base transition-colors file:h-6 file:text-sm file:font-medium focus-visible:ring-3 aria-invalid:ring-3 md:text-sm w-full min-w-0 outline-none file:inline-flex file:border-0 file:bg-transparent file:text-foreground placeholder:text-muted-foreground disabled:pointer-events-none disabled:cursor-not-allowed disabled:opacity-50`,n.class))},null,2)),[[Wl,M(r)]])}}),eT=`llmgwAdminKey`;function tT(){try{return sessionStorage.getItem(eT)??``}catch{return``}}function nT(e){try{sessionStorage.setItem(eT,e)}catch{}}function rT(){try{sessionStorage.removeItem(eT)}catch{}}var iT=t_(`auth`,{state:()=>({apiKey:tT(),error:``}),getters:{isAuthenticated:e=>e.apiKey!==``},actions:{submit(e){e&&(this.apiKey=e,this.error=``,nT(e))},reject(e){this.apiKey=``,this.error=e,rT()}}}),aT=class extends Error{status;constructor(e,t){super(e),this.name=`AdminApiError`,this.status=t}};async function oT(e,t){let n=`${t}: HTTP ${e.status}`;try{return(await e.json()).error?.message||n}catch{return n}}async function sT(e){let t=iT(),n=t.apiKey,r=await fetch(e,{credentials:`same-origin`,headers:n?{"x-api-key":n}:{}});if(!r.ok){let i=await oT(r,e);throw(r.status===401||r.status===403)&&t.apiKey===n&&t.reject(`invalid key, or not an admin`),new aT(i,r.status)}return await r.json()}function cT(e){return e||(typeof document>`u`?void 0:document)}function lT({intervalMs:e,tick:t,doc:n}){let r=cT(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 uT=5e3,dT=t_(`dashboard`,{state:()=>({overview:null,usage:null,targets:null,lastUpdated:null,error:``,poller:void 0,refreshing:!1}),actions:{async refresh(){if(iT().isAuthenticated&&!this.refreshing){this.refreshing=!0;try{await this.doRefresh()}finally{this.refreshing=!1}}},async doRefresh(){let[e,t,n]=await Promise.allSettled([sT(`/admin/api/overview`),sT(`/admin/api/usage`),sT(`/admin/api/targets`)]);e.status===`fulfilled`&&(this.overview=e.value),t.status===`fulfilled`&&(this.usage=t.value),n.status===`fulfilled`&&(this.targets=n.value);let r=[];if(e.status===`rejected`&&r.push({label:`overview`,reason:e.reason}),t.status===`rejected`&&r.push({label:`usage`,reason:t.reason}),n.status===`rejected`&&r.push({label:`targets`,reason:n.reason}),r.length===0){this.lastUpdated=new Date,this.error=``;return}r.some(({reason:e})=>e instanceof aT&&(e.status===401||e.status===403))||(r.length<3&&(this.lastUpdated=new Date),this.error=r.map(({label:e,reason:t})=>`${e}: ${t instanceof Error?t.message:String(t)}`).join(`; `))},startPolling(){this.poller||(this.poller=lT({intervalMs:uT,tick:()=>void this.refresh()}),this.poller.start())}}}),fT={class:`mx-auto flex min-h-[70vh] max-w-md flex-col justify-center px-4`},pT={class:`flex size-12 items-center justify-center rounded-full bg-primary/10 text-primary`},mT={class:`flex flex-col items-center gap-1`},hT={"aria-labelledby":`authgate-security-heading`,class:`flex flex-col gap-1.5 text-xs text-muted-foreground`},gT={class:`flex items-start gap-1.5`},_T={class:`flex items-start gap-1.5`},vT={class:`flex items-start gap-1.5`},yT={class:`relative`},bT=((e,t)=>{let n=e.__vccOpts||e;for(let[e,r]of t)n[e]=r;return n})(P({__name:`AuthGate`,setup(e){let t=iT(),n=dT(),r=j(``),i=j(!1),a=j(null),o=W(()=>r.value.trim()!==``);function s(){let e=r.value;r.value=``,t.submit(e),n.refresh()}function c(){$n(()=>a.value?.$el?.focus())}return Qi(c),Dr(()=>t.error,e=>{e&&c()}),(e,n)=>{let c=la(`FontAwesomeIcon`);return L(),R(`div`,fT,[V(M(Jw),null,{default:N(()=>[V(M(Zw),{class:`flex flex-col items-center gap-3 text-center`},{default:N(()=>[B(`div`,pT,[V(c,{icon:M(a_),class:`size-5`,"aria-hidden":`true`},null,8,[`icon`])]),B(`div`,mT,[n[3]||=B(`span`,{class:`text-xs font-medium text-muted-foreground`},`LLM Gateway`,-1),V(M(Qw),{class:`text-lg font-semibold`},{default:N(()=>[...n[2]||=[H(`Admin key required`,-1)]]),_:1})]),V(M(Xw),null,{default:N(()=>[...n[4]||=[H(`Enter an admin API key to continue.`,-1)]]),_:1})]),_:1}),V(M(Yw),{class:`flex flex-col gap-4`},{default:N(()=>[n[10]||=B(`h2`,{id:`authgate-security-heading`,class:`sr-only`},` How this key is handled `,-1),B(`ul`,hT,[B(`li`,gT,[V(c,{icon:M(f_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[5]||=B(`span`,null,`Kept only in this tab's session storage`,-1)]),B(`li`,_T,[V(c,{icon:M(f_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[6]||=B(`span`,null,`Never written to disk`,-1)]),B(`li`,vT,[V(c,{icon:M(f_),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[7]||=B(`span`,null,`Sent only to this page's own /admin/api/* requests`,-1)])]),B(`form`,{class:`flex flex-col gap-3`,onSubmit:iu(s,[`prevent`])},[B(`div`,yT,[V(M($w),{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":!!M(t).error,"aria-describedby":M(t).error?`authgate-error`:void 0,class:O([`h-10 pr-10`,{"authgate-shake":M(t).error}])},null,8,[`modelValue`,`type`,`aria-invalid`,`aria-describedby`,`class`]),V(M(Gw),{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:N(()=>[V(c,{icon:i.value?M(b_):M(s_),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`aria-label`])]),V(M(Gw),{type:`submit`,class:`w-full`,disabled:!o.value},{default:N(()=>[...n[8]||=[H(` Continue `,-1)]]),_:1},8,[`disabled`])],32),M(t).error?(L(),z(M($v),{key:0,id:`authgate-error`,variant:`destructive`},{default:N(()=>[V(M(ty),null,{default:N(()=>[...n[9]||=[H(`Authentication failed`,-1)]]),_:1}),V(M(ey),null,{default:N(()=>[H(k(M(t).error),1)]),_:1})]),_:1})):U(``,!0)]),_:1})]),_:1})])}}}),[[`__scopeId`,`data-v-4be6bc09`]]),xT={class:`mt-1 list-disc space-y-0.5 pl-4 font-mono text-xs`},ST={key:0,class:`mt-1 text-xs`},CT=P({__name:`ConfigWarningsBanner`,props:{warnings:{},warningsDropped:{}},setup(e){let t=e,n=j(!1);function r(){n.value=!n.value}return(e,i)=>{let a=la(`FontAwesomeIcon`);return t.warnings.length>0?(L(),z(M($v),{key:0,variant:`warn`},{default:N(()=>[V(a,{icon:M(v_),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`]),V(M(ty),{class:`flex items-center justify-between gap-2`},{default:N(()=>[B(`span`,null,k(t.warnings.length)+` configuration `+k(t.warnings.length===1?`warning`:`warnings`),1),V(M(Gw),{type:`button`,variant:`ghost`,size:`xs`,"aria-expanded":n.value,"aria-label":`${n.value?`Hide`:`Show`} configuration warning details`,onClick:r},{default:N(()=>[H(k(n.value?`Hide`:`Show`),1)]),_:1},8,[`aria-expanded`,`aria-label`])]),_:1}),n.value?(L(),z(M(ey),{key:0},{default:N(()=>[B(`ul`,xT,[(L(!0),R(I,null,ha(t.warnings,(e,t)=>(L(),R(`li`,{key:t},k(e),1))),128))]),t.warningsDropped?(L(),R(`p`,ST,`and `+k(t.warningsDropped)+` more were not kept`,1)):U(``,!0)]),_:1})):U(``,!0)]),_:1})):U(``,!0)}}});function wT(e,t){return typeof e==`function`?e(t):e}function TT(e,t){return n=>{t.setState(t=>({...t,[e]:wT(n,t[e])}))}}function ET(e){return e instanceof Function}function DT(e){return Array.isArray(e)&&e.every(e=>typeof e==`number`)}function OT(e,t){let n=[],r=e=>{e.forEach(e=>{n.push(e);let i=t(e);i!=null&&i.length&&r(i)})};return r(e),n}function Q(e,t,n){let r=[],i;return a=>{let o;n.key&&n.debug&&(o=Date.now());let s=e(a);if(!(s.length!==r.length||s.some((e,t)=>r[t]!==e)))return i;r=s;let c;if(n.key&&n.debug&&(c=Date.now()),i=t(...s),n==null||n.onChange==null||n.onChange(i),n.key&&n.debug&&n!=null&&n.debug()){let e=Math.round((Date.now()-o)*100)/100,t=Math.round((Date.now()-c)*100)/100,r=t/16,i=(e,t)=>{for(e=String(e);e.length<t;)e=` `+e;return e};console.info(`%c⏱ ${i(t,5)} /${i(e,5)} ms`,`
            font-size: .6rem;
            font-weight: bold;
            color: hsl(${Math.max(0,Math.min(120-120*r,120))}deg 100% 31%);`,n?.key)}return i}}function $(e,t,n,r){return{debug:()=>e?.debugAll??e[t],key:!1,onChange:r}}function kT(e,t,n,r){let i={id:`${t.id}_${n.id}`,row:t,column:n,getValue:()=>t.getValue(r),renderValue:()=>i.getValue()??e.options.renderFallbackValue,getContext:Q(()=>[e,n,t,i],(e,t,n,r)=>({table:e,column:t,row:n,cell:r,getValue:r.getValue,renderValue:r.renderValue}),$(e.options,`debugCells`,`cell.getContext`))};return e._features.forEach(r=>{r.createCell==null||r.createCell(i,n,t,e)},{}),i}function AT(e,t,n,r){let i={...e._getDefaultColumnDef(),...t},a=i.accessorKey,o=i.id??(a?typeof String.prototype.replaceAll==`function`?a.replaceAll(`.`,`_`):a.replace(/\./g,`_`):void 0)??(typeof i.header==`string`?i.header:void 0),s;if(i.accessorFn?s=i.accessorFn:a&&(s=a.includes(`.`)?e=>{let t=e;for(let e of a.split(`.`))t=t?.[e];return t}:e=>e[i.accessorKey]),!o)throw Error();let c={id:`${String(o)}`,accessorFn:s,parent:r,depth:n,columnDef:i,columns:[],getFlatColumns:Q(()=>[!0],()=>[c,...c.columns?.flatMap(e=>e.getFlatColumns())],$(e.options,`debugColumns`,`column.getFlatColumns`)),getLeafColumns:Q(()=>[e._getOrderColumnsFn()],e=>{var t;return(t=c.columns)!=null&&t.length?e(c.columns.flatMap(e=>e.getLeafColumns())):[c]},$(e.options,`debugColumns`,`column.getLeafColumns`))};for(let t of e._features)t.createColumn==null||t.createColumn(c,e);return c}var jT=`debugHeaders`;function MT(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 NT={createTable:e=>{e.getHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(t,n,r,i)=>{let a=r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],o=i?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],s=n.filter(e=>!(r!=null&&r.includes(e.id))&&!(i!=null&&i.includes(e.id)));return PT(t,[...a,...s,...o],e)},$(e.options,jT,`getHeaderGroups`)),e.getCenterHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(t,n,r,i)=>(n=n.filter(e=>!(r!=null&&r.includes(e.id))&&!(i!=null&&i.includes(e.id))),PT(t,n,e,`center`)),$(e.options,jT,`getCenterHeaderGroups`)),e.getLeftHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left],(t,n,r)=>PT(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`left`),$(e.options,jT,`getLeftHeaderGroups`)),e.getRightHeaderGroups=Q(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.right],(t,n,r)=>PT(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`right`),$(e.options,jT,`getRightHeaderGroups`)),e.getFooterGroups=Q(()=>[e.getHeaderGroups()],e=>[...e].reverse(),$(e.options,jT,`getFooterGroups`)),e.getLeftFooterGroups=Q(()=>[e.getLeftHeaderGroups()],e=>[...e].reverse(),$(e.options,jT,`getLeftFooterGroups`)),e.getCenterFooterGroups=Q(()=>[e.getCenterHeaderGroups()],e=>[...e].reverse(),$(e.options,jT,`getCenterFooterGroups`)),e.getRightFooterGroups=Q(()=>[e.getRightHeaderGroups()],e=>[...e].reverse(),$(e.options,jT,`getRightFooterGroups`)),e.getFlatHeaders=Q(()=>[e.getHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,jT,`getFlatHeaders`)),e.getLeftFlatHeaders=Q(()=>[e.getLeftHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,jT,`getLeftFlatHeaders`)),e.getCenterFlatHeaders=Q(()=>[e.getCenterHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,jT,`getCenterFlatHeaders`)),e.getRightFlatHeaders=Q(()=>[e.getRightHeaderGroups()],e=>e.map(e=>e.headers).flat(),$(e.options,jT,`getRightFlatHeaders`)),e.getCenterLeafHeaders=Q(()=>[e.getCenterFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,jT,`getCenterLeafHeaders`)),e.getLeftLeafHeaders=Q(()=>[e.getLeftFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,jT,`getLeftLeafHeaders`)),e.getRightLeafHeaders=Q(()=>[e.getRightFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),$(e.options,jT,`getRightLeafHeaders`)),e.getLeafHeaders=Q(()=>[e.getLeftHeaderGroups(),e.getCenterHeaderGroups(),e.getRightHeaderGroups()],(e,t,n)=>[...e[0]?.headers??[],...t[0]?.headers??[],...n[0]?.headers??[]].map(e=>e.getLeafHeaders()).flat(),$(e.options,jT,`getLeafHeaders`))}};function PT(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=MT(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)=>MT(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 FT=(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:()=>OT(s.subRows,e=>e.subRows),getParentRow:()=>s.parentId?e.getRow(s.parentId,!0):void 0,getParentRows:()=>{let e=[],t=s;for(;;){let n=t.getParentRow();if(!n)break;e.push(n),t=n}return e.reverse()},getAllCells:Q(()=>[e.getAllLeafColumns()],t=>t.map(t=>kT(e,s,t,t.id)),$(e.options,`debugRows`,`getAllCells`)),_getAllCellsByColumnId:Q(()=>[s.getAllCells()],e=>e.reduce((e,t)=>(e[t.column.id]=t,e),{}),$(e.options,`debugRows`,`getAllCellsByColumnId`))};for(let t=0;t<e._features.length;t++){let n=e._features[t];n==null||n.createRow==null||n.createRow(s,e)}return s},IT={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()}}},LT=(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))};LT.autoRemove=e=>qT(e);var RT=(e,t,n)=>{var r;return!!((r=e.getValue(t))!=null&&(r=r.toString())!=null&&r.includes(n))};RT.autoRemove=e=>qT(e);var zT=(e,t,n)=>{var r;return((r=e.getValue(t))==null||(r=r.toString())==null?void 0:r.toLowerCase())===n?.toLowerCase()};zT.autoRemove=e=>qT(e);var BT=(e,t,n)=>e.getValue(t)?.includes(n);BT.autoRemove=e=>qT(e);var VT=(e,t,n)=>!n.some(n=>{var r;return!((r=e.getValue(t))!=null&&r.includes(n))});VT.autoRemove=e=>qT(e)||!(e!=null&&e.length);var HT=(e,t,n)=>n.some(n=>e.getValue(t)?.includes(n));HT.autoRemove=e=>qT(e)||!(e!=null&&e.length);var UT=(e,t,n)=>e.getValue(t)===n;UT.autoRemove=e=>qT(e);var WT=(e,t,n)=>e.getValue(t)==n;WT.autoRemove=e=>qT(e);var GT=(e,t,n)=>{let[r,i]=n,a=e.getValue(t);return a>=r&&a<=i};GT.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]},GT.autoRemove=e=>qT(e)||qT(e[0])&&qT(e[1]);var KT={includesString:LT,includesStringSensitive:RT,equalsString:zT,arrIncludes:BT,arrIncludesAll:VT,arrIncludesSome:HT,equals:UT,weakEquals:WT,inNumberRange:GT};function qT(e){return e==null||e===``}var JT={getDefaultColumnDef:()=>({filterFn:`auto`}),getInitialState:e=>({columnFilters:[],...e}),getDefaultOptions:e=>({onColumnFiltersChange:TT(`columnFilters`,e),filterFromLeafRows:!1,maxLeafRowFilterDepth:100}),createColumn:(e,t)=>{e.getAutoFilterFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);return typeof n==`string`?KT.includesString:typeof n==`number`?KT.inNumberRange:typeof n==`boolean`||typeof n==`object`&&n?KT.equals:Array.isArray(n)?KT.arrIncludes:KT.weakEquals},e.getFilterFn=()=>ET(e.columnDef.filterFn)?e.columnDef.filterFn:e.columnDef.filterFn===`auto`?e.getAutoFilterFn():t.options.filterFns?.[e.columnDef.filterFn]??KT[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=wT(n,i?i.value:void 0);if(YT(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=>wT(t,e)?.filter(e=>{let t=n.find(t=>t.id===e.id);return!(t&&YT(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 YT(e,t,n){return(e&&e.autoRemove?e.autoRemove(t,n):!1)||t===void 0||typeof t==`string`&&!t}var XT={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(!DT(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},ZT={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:TT(`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 XT.sum;if(Object.prototype.toString.call(n)===`[object Date]`)return XT.extent},e.getAggregationFn=()=>{if(!e)throw Error();return ET(e.columnDef.aggregationFn)?e.columnDef.aggregationFn:e.columnDef.aggregationFn===`auto`?e.getAutoAggregationFn():t.options.aggregationFns?.[e.columnDef.aggregationFn]??XT[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 QT(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 $T={getInitialState:e=>({columnOrder:[],...e}),getDefaultOptions:e=>({onColumnOrderChange:TT(`columnOrder`,e)}),createColumn:(e,t)=>{e.getIndex=Q(e=>[uE(t,e)],t=>t.findIndex(t=>t.id===e.id),$(t.options,`debugColumns`,`getIndex`)),e.getIsFirstColumn=n=>uE(t,n)[0]?.id===e.id,e.getIsLastColumn=n=>{let r=uE(t,n);return r[r.length-1]?.id===e.id}},createTable:e=>{e.setColumnOrder=t=>e.options.onColumnOrderChange==null?void 0:e.options.onColumnOrderChange(t),e.resetColumnOrder=t=>{e.setColumnOrder(t?[]:e.initialState.columnOrder??[])},e._getOrderColumnsFn=Q(()=>[e.getState().columnOrder,e.getState().grouping,e.options.groupedColumnMode],(e,t,n)=>r=>{let i=[];if(!(e!=null&&e.length))i=r;else{let t=[...e],n=[...r];for(;n.length&&t.length;){let e=t.shift(),r=n.findIndex(t=>t.id===e);r>-1&&i.push(n.splice(r,1)[0])}i=[...i,...n]}return QT(i,t,n)},$(e.options,`debugTable`,`_getOrderColumnsFn`))}},eE=()=>({left:[],right:[]}),tE={getInitialState:e=>({columnPinning:eE(),...e}),getDefaultOptions:e=>({onColumnPinningChange:TT(`columnPinning`,e)}),createColumn:(e,t)=>{e.pin=n=>{let r=e.getLeafColumns().map(e=>e.id).filter(Boolean);t.setColumnPinning(e=>n===`right`?{left:(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),right:[...(e?.right??[]).filter(e=>!(r!=null&&r.includes(e))),...r]}:n===`left`?{left:[...(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),...r],right:(e?.right??[]).filter(e=>!(r!=null&&r.includes(e)))}:{left:(e?.left??[]).filter(e=>!(r!=null&&r.includes(e))),right:(e?.right??[]).filter(e=>!(r!=null&&r.includes(e)))})},e.getCanPin=()=>e.getLeafColumns().some(e=>(e.columnDef.enablePinning??!0)&&(t.options.enableColumnPinning??t.options.enablePinning??!0)),e.getIsPinned=()=>{let n=e.getLeafColumns().map(e=>e.id),{left:r,right:i}=t.getState().columnPinning,a=n.some(e=>r?.includes(e)),o=n.some(e=>i?.includes(e));return a?`left`:o?`right`:!1},e.getPinnedIndex=()=>{var n;let r=e.getIsPinned();return r?((n=t.getState().columnPinning)==null||(n=n[r])==null?void 0:n.indexOf(e.id))??-1:0}},createRow:(e,t)=>{e.getCenterVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.left,t.getState().columnPinning.right],(e,t,n)=>{let r=[...t??[],...n??[]];return e.filter(e=>!r.includes(e.column.id))},$(t.options,`debugRows`,`getCenterVisibleCells`)),e.getLeftVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.column.id===t)).filter(Boolean).map(e=>({...e,position:`left`})),$(t.options,`debugRows`,`getLeftVisibleCells`)),e.getRightVisibleCells=Q(()=>[e._getAllVisibleCells(),t.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.column.id===t)).filter(Boolean).map(e=>({...e,position:`right`})),$(t.options,`debugRows`,`getRightVisibleCells`))},createTable:e=>{e.setColumnPinning=t=>e.options.onColumnPinningChange==null?void 0:e.options.onColumnPinningChange(t),e.resetColumnPinning=t=>e.setColumnPinning(t?eE():e.initialState?.columnPinning??eE()),e.getIsSomeColumnsPinned=t=>{let n=e.getState().columnPinning;return t?!!n[t]?.length:!!(n.left?.length||n.right?.length)},e.getLeftLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),$(e.options,`debugColumns`,`getLeftLeafColumns`)),e.getRightLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),$(e.options,`debugColumns`,`getRightLeafColumns`)),e.getCenterLeafColumns=Q(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left,e.getState().columnPinning.right],(e,t,n)=>{let r=[...t??[],...n??[]];return e.filter(e=>!r.includes(e.id))},$(e.options,`debugColumns`,`getCenterLeafColumns`))}};function nE(e){return e||(typeof document<`u`?document:null)}var rE={size:150,minSize:20,maxSize:2**53-1},iE=()=>({startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,isResizingColumn:!1,columnSizingStart:[]}),aE={getDefaultColumnDef:()=>rE,getInitialState:e=>({columnSizing:{},columnSizingInfo:iE(),...e}),getDefaultOptions:e=>({columnResizeMode:`onEnd`,columnResizeDirection:`ltr`,onColumnSizingChange:TT(`columnSizing`,e),onColumnSizingInfoChange:TT(`columnSizingInfo`,e)}),createColumn:(e,t)=>{e.getSize=()=>{let n=t.getState().columnSizing[e.id];return Math.min(Math.max(e.columnDef.minSize??rE.minSize,n??e.columnDef.size??rE.size),e.columnDef.maxSize??rE.maxSize)},e.getStart=Q(e=>[e,uE(t,e),t.getState().columnSizing],(t,n)=>n.slice(0,e.getIndex(t)).reduce((e,t)=>e+t.getSize(),0),$(t.options,`debugColumns`,`getStart`)),e.getAfter=Q(e=>[e,uE(t,e),t.getState().columnSizing],(t,n)=>n.slice(e.getIndex(t)+1).reduce((e,t)=>e+t.getSize(),0),$(t.options,`debugColumns`,`getAfter`)),e.resetSize=()=>{t.setColumnSizing(t=>{let{[e.id]:n,...r}=t;return r})},e.getCanResize=()=>(e.columnDef.enableResizing??!0)&&(t.options.enableColumnResizing??!0),e.getIsResizing=()=>t.getState().columnSizingInfo.isResizingColumn===e.id},createHeader:(e,t)=>{e.getSize=()=>{let t=0,n=e=>{e.subHeaders.length?e.subHeaders.forEach(n):t+=e.column.getSize()??0};return n(e),t},e.getStart=()=>{if(e.index>0){let t=e.headerGroup.headers[e.index-1];return t.getStart()+t.getSize()}return 0},e.getResizeHandler=n=>{let r=t.getColumn(e.column.id),i=r?.getCanResize();return a=>{if(!r||!i||(a.persist==null||a.persist(),cE(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=cE(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=nE(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=sE()?{passive:!1}:!1;cE(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?iE():e.initialState.columnSizingInfo??iE())},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}},oE=null;function sE(){if(typeof oE==`boolean`)return oE;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 oE=e,oE}function cE(e){return e.type===`touchstart`}var lE={getInitialState:e=>({columnVisibility:{},...e}),getDefaultOptions:e=>({onColumnVisibilityChange:TT(`columnVisibility`,e)}),createColumn:(e,t)=>{e.toggleVisibility=n=>{e.getCanHide()&&t.setColumnVisibility(t=>({...t,[e.id]:n??!e.getIsVisible()}))},e.getIsVisible=()=>{let n=e.columns;return(n.length?n.some(e=>e.getIsVisible()):t.getState().columnVisibility?.[e.id])??!0},e.getCanHide=()=>(e.columnDef.enableHiding??!0)&&(t.options.enableHiding??!0),e.getToggleVisibilityHandler=()=>t=>{e.toggleVisibility==null||e.toggleVisibility(t.target.checked)}},createRow:(e,t)=>{e._getAllVisibleCells=Q(()=>[e.getAllCells(),t.getState().columnVisibility],e=>e.filter(e=>e.column.getIsVisible()),$(t.options,`debugRows`,`_getAllVisibleCells`)),e.getVisibleCells=Q(()=>[e.getLeftVisibleCells(),e.getCenterVisibleCells(),e.getRightVisibleCells()],(e,t,n)=>[...e,...t,...n],$(t.options,`debugRows`,`getVisibleCells`))},createTable:e=>{let t=(t,n)=>Q(()=>[n(),n().filter(e=>e.getIsVisible()).map(e=>e.id).join(`_`)],e=>e.filter(e=>e.getIsVisible==null?void 0:e.getIsVisible()),$(e.options,`debugColumns`,t));e.getVisibleFlatColumns=t(`getVisibleFlatColumns`,()=>e.getAllFlatColumns()),e.getVisibleLeafColumns=t(`getVisibleLeafColumns`,()=>e.getAllLeafColumns()),e.getLeftVisibleLeafColumns=t(`getLeftVisibleLeafColumns`,()=>e.getLeftLeafColumns()),e.getRightVisibleLeafColumns=t(`getRightVisibleLeafColumns`,()=>e.getRightLeafColumns()),e.getCenterVisibleLeafColumns=t(`getCenterVisibleLeafColumns`,()=>e.getCenterLeafColumns()),e.setColumnVisibility=t=>e.options.onColumnVisibilityChange==null?void 0:e.options.onColumnVisibilityChange(t),e.resetColumnVisibility=t=>{e.setColumnVisibility(t?{}:e.initialState.columnVisibility??{})},e.toggleAllColumnsVisible=t=>{t??=!e.getIsAllColumnsVisible(),e.setColumnVisibility(e.getAllLeafColumns().reduce((e,n)=>({...e,[n.id]:t||!(n.getCanHide!=null&&n.getCanHide())}),{}))},e.getIsAllColumnsVisible=()=>!e.getAllLeafColumns().some(e=>!(e.getIsVisible!=null&&e.getIsVisible())),e.getIsSomeColumnsVisible=()=>e.getAllLeafColumns().some(e=>e.getIsVisible==null?void 0:e.getIsVisible()),e.getToggleAllColumnsVisibilityHandler=()=>t=>{e.toggleAllColumnsVisible(t.target?.checked)}}};function uE(e,t){return t?t===`center`?e.getCenterVisibleLeafColumns():t===`left`?e.getLeftVisibleLeafColumns():e.getRightVisibleLeafColumns():e.getVisibleLeafColumns()}var dE={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()}}},fE={getInitialState:e=>({globalFilter:void 0,...e}),getDefaultOptions:e=>({onGlobalFilterChange:TT(`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=()=>KT.includesString,e.getGlobalFilterFn=()=>{let{globalFilterFn:t}=e.options;return ET(t)?t:t===`auto`?e.getGlobalAutoFilterFn():e.options.filterFns?.[t]??KT[t]},e.setGlobalFilter=t=>{e.options.onGlobalFilterChange==null||e.options.onGlobalFilterChange(t)},e.resetGlobalFilter=t=>{e.setGlobalFilter(t?void 0:e.initialState.globalFilter)}}},pE={getInitialState:e=>({expanded:{},...e}),getDefaultOptions:e=>({onExpandedChange:TT(`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()}}}},mE=0,hE=10,gE=()=>({pageIndex:mE,pageSize:hE}),_E={getInitialState:e=>({...e,pagination:{...gE(),...e?.pagination}}),getDefaultOptions:e=>({onPaginationChange:TT(`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=>wT(t,e)),e.resetPagination=t=>{e.setPagination(t?gE():e.initialState.pagination??gE())},e.setPageIndex=t=>{e.setPagination(n=>{let r=wT(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?mE:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageIndex)??mE)},e.resetPageSize=t=>{var n;e.setPageSize(t?hE:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageSize)??hE)},e.setPageSize=t=>{e.setPagination(e=>{let n=Math.max(1,wT(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=wT(t,e.options.pageCount??-1);return typeof r==`number`&&(r=Math.max(-1,r)),{...n,pageCount:r}}),e.getPageOptions=Q(()=>[e.getPageCount()],e=>{let t=[];return e&&e>0&&(t=[...Array(e)].fill(null).map((e,t)=>t)),t},$(e.options,`debugTable`,`getPageOptions`)),e.getCanPreviousPage=()=>e.getState().pagination.pageIndex>0,e.getCanNextPage=()=>{let{pageIndex:t}=e.getState().pagination,n=e.getPageCount();return n===-1||n!==0&&t<n-1},e.previousPage=()=>e.setPageIndex(e=>e-1),e.nextPage=()=>e.setPageIndex(e=>e+1),e.firstPage=()=>e.setPageIndex(0),e.lastPage=()=>e.setPageIndex(e.getPageCount()-1),e.getPrePaginationRowModel=()=>e.getExpandedRowModel(),e.getPaginationRowModel=()=>(!e._getPaginationRowModel&&e.options.getPaginationRowModel&&(e._getPaginationRowModel=e.options.getPaginationRowModel(e)),e.options.manualPagination||!e._getPaginationRowModel?e.getPrePaginationRowModel():e._getPaginationRowModel()),e.getPageCount=()=>e.options.pageCount??Math.ceil(e.getRowCount()/e.getState().pagination.pageSize),e.getRowCount=()=>e.options.rowCount??e.getPrePaginationRowModel().rows.length}},vE=()=>({top:[],bottom:[]}),yE={getInitialState:e=>({rowPinning:vE(),...e}),getDefaultOptions:e=>({onRowPinningChange:TT(`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?vE():e.initialState?.rowPinning??vE()),e.getIsSomeRowsPinned=t=>{let n=e.getState().rowPinning;return t?!!n[t]?.length:!!(n.top?.length||n.bottom?.length)},e._getPinnedRows=(t,n,r)=>(e.options.keepPinnedRows??!0?(n??[]).map(t=>{let n=e.getRow(t,!0);return n.getIsAllParentsExpanded()?n:null}):(n??[]).map(e=>t.find(t=>t.id===e))).filter(Boolean).map(e=>({...e,position:r})),e.getTopRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.top],(t,n)=>e._getPinnedRows(t,n,`top`),$(e.options,`debugRows`,`getTopRows`)),e.getBottomRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.bottom],(t,n)=>e._getPinnedRows(t,n,`bottom`),$(e.options,`debugRows`,`getBottomRows`)),e.getCenterRows=Q(()=>[e.getRowModel().rows,e.getState().rowPinning.top,e.getState().rowPinning.bottom],(e,t,n)=>{let r=new Set([...t??[],...n??[]]);return e.filter(e=>!r.has(e.id))},$(e.options,`debugRows`,`getCenterRows`))}},bE={getInitialState:e=>({rowSelection:{},...e}),getDefaultOptions:e=>({onRowSelectionChange:TT(`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=>{xE(i,t.id,r,!0,e)}),i}),e.getPreSelectedRowModel=()=>e.getCoreRowModel(),e.getSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getCoreRowModel()],(t,n)=>Object.keys(t).length?SE(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getSelectedRowModel`)),e.getFilteredSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getFilteredRowModel()],(t,n)=>Object.keys(t).length?SE(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getFilteredSelectedRowModel`)),e.getGroupedSelectedRowModel=Q(()=>[e.getState().rowSelection,e.getSortedRowModel()],(t,n)=>Object.keys(t).length?SE(e,n):{rows:[],flatRows:[],rowsById:{}},$(e.options,`debugTable`,`getGroupedSelectedRowModel`)),e.getIsAllRowsSelected=()=>{let t=e.getFilteredRowModel().flatRows,{rowSelection:n}=e.getState(),r=!!(t.length&&Object.keys(n).length);return r&&t.some(e=>e.getCanSelect()&&!n[e.id])&&(r=!1),r},e.getIsAllPageRowsSelected=()=>{let t=e.getPaginationRowModel().flatRows.filter(e=>e.getCanSelect()),{rowSelection:n}=e.getState(),r=!!t.length;return r&&t.some(e=>!n[e.id])&&(r=!1),r},e.getIsSomeRowsSelected=()=>{let t=Object.keys(e.getState().rowSelection??{}).length;return t>0&&t<e.getFilteredRowModel().flatRows.length},e.getIsSomePageRowsSelected=()=>{let t=e.getPaginationRowModel().flatRows;return!e.getIsAllPageRowsSelected()&&t.filter(e=>e.getCanSelect()).some(e=>e.getIsSelected()||e.getIsSomeSelected())},e.getToggleAllRowsSelectedHandler=()=>t=>{e.toggleAllRowsSelected(t.target.checked)},e.getToggleAllPageRowsSelectedHandler=()=>t=>{e.toggleAllPageRowsSelected(t.target.checked)}},createRow:(e,t)=>{e.toggleSelected=(n,r)=>{let i=e.getIsSelected();t.setRowSelection(a=>{if(n=n===void 0?!i:n,e.getCanSelect()&&i===n)return a;let o={...a};return xE(o,e.id,n,r?.selectChildren??!0,t),o})},e.getIsSelected=()=>{let{rowSelection:n}=t.getState();return CE(e,n)},e.getIsSomeSelected=()=>{let{rowSelection:n}=t.getState();return wE(e,n)===`some`},e.getIsAllSubRowsSelected=()=>{let{rowSelection:n}=t.getState();return wE(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)}}}},xE=(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=>xE(e,t.id,n,r,i))};function SE(e,t){let n=e.getState().rowSelection,r=[],i={},a=function(e,t){return e.map(e=>{var t;let o=CE(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 CE(e,t){return t[e.id]??!1}function wE(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()&&(CE(e,t)?a=!0:i=!1),e.subRows&&e.subRows.length)){let n=wE(e,t);n===`all`?a=!0:(n===`some`&&(a=!0),i=!1)}}),i?`all`:a?`some`:!1}var TE=/([0-9]+)/gm,EE=(e,t,n)=>PE(NE(e.getValue(n)).toLowerCase(),NE(t.getValue(n)).toLowerCase()),DE=(e,t,n)=>PE(NE(e.getValue(n)),NE(t.getValue(n))),OE=(e,t,n)=>ME(NE(e.getValue(n)).toLowerCase(),NE(t.getValue(n)).toLowerCase()),kE=(e,t,n)=>ME(NE(e.getValue(n)),NE(t.getValue(n))),AE=(e,t,n)=>{let r=e.getValue(n),i=t.getValue(n);return r>i?1:r<i?-1:0},jE=(e,t,n)=>ME(e.getValue(n),t.getValue(n));function ME(e,t){return e===t?0:e>t?1:-1}function NE(e){return typeof e==`number`?isNaN(e)||e===1/0||e===-1/0?``:String(e):typeof e==`string`?e:``}function PE(e,t){let n=e.split(TE).filter(Boolean),r=t.split(TE).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 FE={alphanumeric:EE,alphanumericCaseSensitive:DE,text:OE,textCaseSensitive:kE,datetime:AE,basic:jE},IE=[NT,lE,$T,tE,IT,JT,dE,fE,{getInitialState:e=>({sorting:[],...e}),getDefaultColumnDef:()=>({sortingFn:`auto`,sortUndefined:1}),getDefaultOptions:e=>({onSortingChange:TT(`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 FE.datetime;if(typeof n==`string`&&(r=!0,n.split(TE).length>1))return FE.alphanumeric}return r?FE.text:FE.basic},e.getAutoSortDir=()=>typeof t.getFilteredRowModel().flatRows[0]?.getValue(e.id)==`string`?`asc`:`desc`,e.getSortingFn=()=>{if(!e)throw Error();return ET(e.columnDef.sortingFn)?e.columnDef.sortingFn:e.columnDef.sortingFn===`auto`?e.getAutoSortingFn():t.options.sortingFns?.[e.columnDef.sortingFn]??FE[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())}},ZT,pE,_E,yE,bE,aE];function LE(e){let t=[...IE,...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=wT(e,n.options);n.options=i(t)},getState:()=>n.options.state,setState:e=>{n.options.onStateChange==null||n.options.onStateChange(e)},_getRowId:(e,t,r)=>(n.options.getRowId==null?void 0:n.options.getRowId(e,t,r))??`${r?[r.id,t].join(`.`):t}`,getCoreRowModel:()=>(n._getCoreRowModel||=n.options.getCoreRowModel(n),n._getCoreRowModel()),getRowModel:()=>n.getPaginationRowModel(),getRow:(e,t)=>{let r=(t?n.getPrePaginationRowModel():n.getRowModel()).rowsById[e];if(!r&&(r=n.getCoreRowModel().rowsById[e],!r))throw Error();return r},_getDefaultColumnDef:Q(()=>[n.options.defaultColumn],e=>(e??={},{header:e=>{let t=e.header.column.columnDef;return t.accessorKey?t.accessorKey:t.accessorFn?t.id:null},cell:e=>{var t;return((t=e.renderValue())==null||t.toString==null?void 0:t.toString())??null},...n._features.reduce((e,t)=>Object.assign(e,t.getDefaultColumnDef==null?void 0:t.getDefaultColumnDef()),{}),...e}),$(e,`debugColumns`,`_getDefaultColumnDef`)),_getColumnDefs:()=>n.options.columns,getAllColumns:Q(()=>[n._getColumnDefs()],e=>{let t=function(e,r,i){return i===void 0&&(i=0),e.map(e=>{let a=AT(n,e,i,r),o=e;return a.columns=o.columns?t(o.columns,a,i+1):[],a})};return t(e)},$(e,`debugColumns`,`getAllColumns`)),getAllFlatColumns:Q(()=>[n.getAllColumns()],e=>e.flatMap(e=>e.getFlatColumns()),$(e,`debugColumns`,`getAllFlatColumns`)),_getAllFlatColumnsById:Q(()=>[n.getAllFlatColumns()],e=>e.reduce((e,t)=>(e[t.id]=t,e),{}),$(e,`debugColumns`,`getAllFlatColumnsById`)),getAllLeafColumns:Q(()=>[n.getAllColumns(),n._getOrderColumnsFn()],(e,t)=>t(e.flatMap(e=>e.getLeafColumns())),$(e,`debugColumns`,`getAllLeafColumns`)),getColumn:e=>n._getAllFlatColumnsById()[e]};Object.assign(n,c);for(let e=0;e<n._features.length;e++){let t=n._features[e];t==null||t.createTable==null||t.createTable(n)}return n}function RE(){return e=>Q(()=>[e.options.data],t=>{let n={rows:[],flatRows:[],rowsById:{}},r=function(t,i,a){i===void 0&&(i=0);let o=[];for(let c=0;c<t.length;c++){let l=FT(e,e._getRowId(t[c],c,a),t[c],c,i,void 0,a?.id);if(n.flatRows.push(l),n.rowsById[l.id]=l,o.push(l),e.options.getSubRows){var s;l.originalSubRows=e.options.getSubRows(t[c],c),(s=l.originalSubRows)!=null&&s.length&&(l.subRows=r(l.originalSubRows,i+1,l))}}return o};return n.rows=r(t),n},$(e.options,`debugTable`,`getRowModel`,()=>e._autoResetPageIndex()))}function zE(){return e=>Q(()=>[e.getState().sorting,e.getPreSortedRowModel()],(t,n)=>{if(!n.rows.length||!(t!=null&&t.length))return n;let r=e.getState().sorting,i=[],a=r.filter(t=>e.getColumn(t.id)?.getCanSort()),o={};a.forEach(t=>{let n=e.getColumn(t.id);n&&(o[t.id]={sortUndefined:n.columnDef.sortUndefined,invertSorting:n.columnDef.invertSorting,sortingFn:n.getSortingFn()})});let s=e=>{let t=e.map(e=>({...e}));return t.sort((e,t)=>{for(let n=0;n<a.length;n+=1){let r=a[n],i=o[r.id],s=i.sortUndefined,c=r?.desc??!1,l=0;if(s){let n=e.getValue(r.id),i=t.getValue(r.id),a=n===void 0,o=i===void 0;if(a||o){if(s===`first`)return a?-1:1;if(s===`last`)return a?1:-1;l=a&&o?0:a?s:-s}}if(l===0&&(l=i.sortingFn(e,t,r.id)),l!==0)return c&&(l*=-1),i.invertSorting&&(l*=-1),l}return e.index-t.index}),t.forEach(e=>{var t;i.push(e),(t=e.subRows)!=null&&t.length&&(e.subRows=s(e.subRows))}),t};return{rows:s(n.rows),flatRows:i,rowsById:n.rowsById}},$(e.options,`debugTable`,`getSortedRowModel`,()=>e._autoResetPageIndex()))}function BE(){return!0}var VE=Symbol(`merge-proxy`),HE={get(e,t,n){return t===VE?n:e.get(t)},has(e,t){return e.has(t)},set:BE,deleteProperty:BE,getOwnPropertyDescriptor(e,t){return{configurable:!0,enumerable:!0,get(){return e.get(t)},set:BE,deleteProperty:BE}},ownKeys(e){return e.keys()}};function UE(e){return`value`in e?e.value:e}function WE(){var e=[...arguments];return new Proxy({get(t){for(let n=e.length-1;n>=0;n--){let r=UE(e[n])[t];if(r!==void 0)return r}},has(t){for(let n=e.length-1;n>=0;n--)if(t in UE(e[n]))return!0;return!1},keys(){let t=[];for(let n=0;n<e.length;n++)t.push(...Object.keys(UE(e[n])));return[...Array.from(new Set(t))]}},HE)}var GE=P({props:[`render`,`props`],setup:e=>()=>typeof e.render==`function`||typeof e.render==`object`?G(e.render,e.props):e.render});function KE(e){return WE(e,{data:M(e.data)})}function qE(e){let t=un(e.data),n=LE(WE({state:{},onStateChange:()=>{},renderFallbackValue:null,mergeOptions(e,n){return t?{...e,...n}:WE(e,n)}},t?KE(e):e));if(t){let t=dn(e.data);Dr(t,()=>{n.setState(e=>({...e,data:t.value}))},{immediate:!0})}let r=j(n.initialState);return wr(()=>{n.setOptions(n=>{let i=new Proxy({},{get:(e,t)=>r.value[t]});return WE(n,t?KE(e):e,{state:WE(i,e.state??{}),onStateChange:t=>{t instanceof Function?r.value=t(r.value):r.value=t,e.onStateChange==null||e.onStateChange(t)}})})}),n}var JE=[`aria-label`],YE=P({__name:`SortHeaderButton`,props:{header:{}},setup(e){let t=e,n=W(()=>t.header.column.getIsSorted()),r=W(()=>n.value===`asc`?o_:n.value===`desc`?x_:p_),i=W(()=>{let e=t.header.column.columnDef.header;return typeof e==`string`?e:t.header.column.id}),a=W(()=>{let e=n.value===`asc`?`ascending`:n.value===`desc`?`descending`:`none`;return`Sort by ${i.value}, currently ${e}`});function o(){t.header.column.toggleSorting(n.value===`asc`)}return(t,i)=>{let s=la(`FontAwesomeIcon`);return L(),R(`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?U(``,!0):(L(),z(M(GE),{key:0,render:e.header.column.columnDef.header,props:e.header.getContext()},null,8,[`render`,`props`])),V(s,{icon:r.value,class:O([`size-3 shrink-0`,n.value?`text-foreground`:`text-muted-foreground/60`]),"aria-hidden":`true`},null,8,[`icon`,`class`])],8,JE)}}}),XE={"data-slot":`table-container`,class:`relative w-full overflow-x-auto`},ZE=P({__name:`Table`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`div`,XE,[B(`table`,{"data-slot":`table`,class:O(M(Qv)(`w-full caption-bottom text-sm`,t.class))},[F(e.$slots,`default`)],2)]))}}),QE=P({__name:`TableBody`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`tbody`,{"data-slot":`table-body`,class:O(M(Qv)(`[&_tr:last-child]:border-0`,t.class))},[F(e.$slots,`default`)],2))}}),$E=P({__name:`TableCell`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`td`,{"data-slot":`table-cell`,class:O(M(Qv)(`p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[F(e.$slots,`default`)],2))}}),eD=P({__name:`TableRow`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`tr`,{"data-slot":`table-row`,class:O(M(Qv)(`hover:bg-muted/50 data-[state=selected]:bg-muted border-b transition-colors has-aria-expanded:bg-muted/50`,t.class))},[F(e.$slots,`default`)],2))}}),tD={class:`flex items-center justify-center py-10`},nD=P({__name:`TableEmpty`,props:{class:{type:[Boolean,null,String,Object,Array]},colspan:{default:1}},setup(e){let t=e,n=Oy(t,`class`);return(e,r)=>(L(),z(eD,null,{default:N(()=>[V($E,ks({class:M(Qv)(`p-4 whitespace-nowrap align-middle text-sm text-foreground`,t.class)},M(n)),{default:N(()=>[B(`div`,tD,[F(e.$slots,`default`)])]),_:3},16,[`class`])]),_:3}))}}),rD=P({__name:`TableHead`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`th`,{"data-slot":`table-head`,class:O(M(Qv)(`text-foreground h-10 px-2 text-left align-middle font-medium whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[F(e.$slots,`default`)],2))}}),iD=P({__name:`TableHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(L(),R(`thead`,{"data-slot":`table-header`,class:O(M(Qv)(`[&_tr]:border-b`,t.class))},[F(e.$slots,`default`)],2))}});function aD(e,t){t.value=typeof e==`function`?e(t.value):e}var oD=P({__name:`DataTable`,props:{columns:{},data:{},rowClass:{type:Function},emptyMessage:{},sorting:{}},emits:[`update:sorting`],setup(e,{emit:t}){let n=e,r=t,i=j([]),a=qE({get data(){return n.data},get columns(){return n.columns},getCoreRowModel:RE(),getSortedRowModel:zE(),onSortingChange:e=>{let t=n.sorting??i.value,a=typeof e==`function`?e(t):e;n.sorting===void 0?i.value=a:r(`update:sorting`,a)},state:{get sorting(){return n.sorting??i.value}}});function o(e){if(e===`asc`)return`ascending`;if(e===`desc`)return`descending`}return(t,n)=>(L(),z(M(ZE),null,{default:N(()=>[V(M(iD),null,{default:N(()=>[(L(!0),R(I,null,ha(M(a).getHeaderGroups(),e=>(L(),z(M(eD),{key:e.id},{default:N(()=>[(L(!0),R(I,null,ha(e.headers,e=>(L(),z(M(rD),{key:e.id,class:O(e.column.columnDef.meta?.align===`right`?`text-right`:void 0),"aria-sort":e.column.getCanSort()?o(e.column.getIsSorted())??`none`:void 0},{default:N(()=>[e.column.getCanSort()?(L(),z(YE,{key:0,header:e,class:`-mx-1.5`},null,8,[`header`])):e.isPlaceholder?U(``,!0):(L(),z(M(GE),{key:1,render:e.column.columnDef.header,props:e.getContext()},null,8,[`render`,`props`]))]),_:2},1032,[`class`,`aria-sort`]))),128))]),_:2},1024))),128))]),_:1}),V(M(QE),null,{default:N(()=>[M(a).getRowModel().rows.length===0?(L(),z(M(nD),{key:0,colspan:e.columns.length,class:`text-muted-foreground`},{default:N(()=>[H(k(e.emptyMessage??`none`),1)]),_:1},8,[`colspan`])):U(``,!0),(L(!0),R(I,null,ha(M(a).getRowModel().rows,t=>(L(),z(M(eD),{key:t.id,class:O(e.rowClass?.(t.original))},{default:N(()=>[(L(!0),R(I,null,ha(t.getVisibleCells(),e=>(L(),z(M($E),{key:e.id,class:O(e.column.columnDef.meta?.align===`right`?`text-right tabular-nums`:void 0)},{default:N(()=>[V(M(GE),{render:e.column.columnDef.cell,props:e.getContext()},null,8,[`render`,`props`])]),_:2},1032,[`class`]))),128))]),_:2},1032,[`class`]))),128))]),_:1})]),_:1}))}}),sD=P({__name:`SearchInput`,props:{modelValue:{},placeholder:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=W(()=>n.modelValue.length>0);function a(e){r(`update:modelValue`,String(e))}function o(){r(`update:modelValue`,``)}return(t,r)=>{let s=la(`FontAwesomeIcon`);return L(),R(`div`,{class:O(M(Qv)(`relative`,n.class))},[V(s,{icon:M(i_),class:`pointer-events-none absolute top-1/2 left-2.5 size-3.5 -translate-y-1/2 text-muted-foreground`,"aria-hidden":`true`},null,8,[`icon`]),V(M($w),{"model-value":e.modelValue,type:`text`,placeholder:e.placeholder,"aria-label":e.placeholder,class:`pr-8 pl-8`,"onUpdate:modelValue":a},null,8,[`model-value`,`placeholder`,`aria-label`]),i.value?(L(),z(M(Gw),{key:0,type:`button`,variant:`ghost`,size:`icon-xs`,"aria-label":`Clear search`,class:`absolute top-1/2 right-1 -translate-y-1/2 text-muted-foreground hover:text-foreground`,onClick:o},{default:N(()=>[V(s,{icon:M(m_),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`])]),_:1})):U(``,!0)],2)}}}),cD=P({__name:`Select`,props:{open:{type:Boolean},defaultOpen:{type:Boolean},defaultValue:{},modelValue:{},nullableValue:{},by:{type:[String,Function]},dir:{},multiple:{type:Boolean},autocomplete:{},disabled:{type:Boolean},name:{},required:{type:Boolean}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=db(e,t);return(e,t)=>(L(),z(M(dw),ks({"data-slot":`select`},M(n)),{default:N(t=>[F(e.$slots,`default`,xe(Cs(t)))]),_:3},16))}}),lD=P({inheritAttrs:!1,__name:`SelectContent`,props:{forceMount:{type:Boolean},position:{default:`item-aligned`},bodyLock:{type:Boolean},memoDependencies:{},side:{},sideOffset:{},sideFlip:{type:Boolean},align:{default:`center`},alignOffset:{},alignFlip:{type:Boolean},avoidCollisions:{type:Boolean},collisionBoundary:{},collisionPadding:{},arrowPadding:{},hideShiftedArrow:{type:Boolean},sticky:{},hideWhenDetached:{type:Boolean},positionStrategy:{},updatePositionStrategy:{},disableUpdateOnLayoutShift:{type:Boolean},prioritizePosition:{type:Boolean},reference:{},dir:{},asChild:{type:Boolean},as:{},disableOutsidePointerEvents:{type:Boolean},class:{type:[Boolean,null,String,Object,Array]}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=db(Oy(n,`class`),r);return(t,r)=>(L(),z(M(Aw),null,{default:N(()=>[V(M(Cw),ks({"data-slot":`select-content`,"data-align-trigger":e.position===`item-aligned`},{...t.$attrs,...M(i)},{class:M(Qv)(`bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 min-w-36 rounded-lg shadow-md ring-1 duration-100 data-[side=inline-start]:slide-in-from-right-2 data-[side=inline-end]:slide-in-from-left-2 cn-menu-translucent relative z-50 max-h-(--reka-select-content-available-height) origin-(--reka-select-content-transform-origin) overflow-x-hidden overflow-y-auto data-[align-trigger=true]:animate-none`,e.position===`popper`&&`data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1`,n.class)}),{default:N(()=>[V(M(pD)),V(M(Iw),{"data-position":e.position,class:O(M(Qv)(`data-[position=popper]:h-(--reka-select-trigger-height) data-[position=popper]:w-full data-[position=popper]:min-w-(--reka-select-trigger-width)`))},{default:N(()=>[F(t.$slots,`default`)]),_:3},8,[`data-position`,`class`]),V(M(fD))]),_:3},16,[`data-align-trigger`,`class`])]),_:3}))}}),uD={class:`pointer-events-none absolute right-2 flex size-4 items-center justify-center`},dD=P({__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=ub(Oy(t,`class`));return(e,r)=>(L(),z(M(Dw),ks({"data-slot":`select-item`},M(n),{class:M(Qv)(`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:N(()=>[B(`span`,uD,[V(M(Ow),null,{default:N(()=>[F(e.$slots,`indicator-icon`,{},()=>[V(M(Cg),{icon:M(f_),class:`pointer-events-none size-3.5`},null,8,[`icon`])])]),_:3})]),V(M(kw),null,{default:N(()=>[F(e.$slots,`default`)]),_:3})]),_:3},16,[`class`]))}}),fD=P({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ub(Oy(t,`class`));return(e,r)=>(L(),z(M(Mw),ks({"data-slot":`select-scroll-down-button`},M(n),{class:M(Qv)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:N(()=>[F(e.$slots,`default`,{},()=>[V(M(Cg),{icon:M(g_),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),pD=P({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ub(Oy(t,`class`));return(e,r)=>(L(),z(M(Nw),ks({"data-slot":`select-scroll-up-button`},M(n),{class:M(Qv)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:N(()=>[F(e.$slots,`default`,{},()=>[V(M(Cg),{icon:M(c_),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),mD=P({__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=ub(Oy(t,`class`,`size`));return(r,i)=>(L(),z(M(Pw),ks({"data-slot":`select-trigger`,"data-size":e.size},M(n),{class:M(Qv)(`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:N(()=>[F(r.$slots,`default`),V(M(ww),{"as-child":``},{default:N(()=>[V(M(Cg),{icon:M(g_),class:`text-muted-foreground size-4 pointer-events-none`},null,8,[`icon`])]),_:1})]),_:3},16,[`data-size`,`class`]))}}),hD=P({__name:`SelectValue`,props:{placeholder:{},asChild:{type:Boolean},as:{}},setup(e){let t=e;return(e,n)=>(L(),z(M(Fw),ks({"data-slot":`select-value`},t),{default:N(()=>[F(e.$slots,`default`)]),_:3},16))}});function gD(e){let t=e??j(``),n=W(()=>t.value.trim().toLowerCase());return{query:t,normalized:n,hasQuery:W(()=>n.value.length>0)}}var _D=P({__name:`Badge`,props:{asChild:{type:Boolean},as:{},variant:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Oy(t,`class`);return(r,i)=>(L(),z(M(Pb),ks({"data-slot":`badge`,"data-variant":e.variant,class:M(Qv)(M(vD)({variant:e.variant}),t.class)},M(n)),{default:N(()=>[F(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),vD=E_(`h-5 gap-1 rounded-4xl border border-transparent px-2 py-0.5 text-xs font-medium transition-all has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&>svg]:size-3! group/badge inline-flex w-fit shrink-0 items-center justify-center overflow-hidden whitespace-nowrap focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 aria-invalid:border-destructive aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 [&>svg]:pointer-events-none`,{variants:{variant:{default:`bg-primary text-primary-foreground [a]:hover:bg-primary/80`,secondary:`bg-secondary text-secondary-foreground [a]:hover:bg-secondary/80`,destructive:`bg-destructive/10 [a]:hover:bg-destructive/20 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 text-destructive dark:bg-destructive/20`,outline:`border-border text-foreground [a]:hover:bg-muted [a]:hover:text-muted-foreground`,ghost:`hover:bg-muted hover:text-muted-foreground dark:hover:bg-muted/50`,link:`text-primary underline-offset-4 hover:underline`}},defaultVariants:{variant:`default`}}),yD={rate_limit:`Rate limit`,budget:`Budget`,store_down:`Store down`,upstream:`Upstream error`,timeout:`Timeout`,unpriced:`Unpriced model`,capacity:`Capacity`},bD=Object.keys(yD);function xD(e){switch(e){case`rate_limit`:case`budget`:case`capacity`:return`destructive`;case`store_down`:case`upstream`:case`timeout`:return`secondary`;default:return`outline`}}function SD(e,t){let n=t.kind,r=t.user.trim().toLowerCase();return e.filter(e=>{if(n&&e.kind!==n)return!1;if(!r)return!0;let t=e.user?.toLowerCase().includes(r)??!1,i=e.group?.toLowerCase().includes(r)??!1;return t||i})}function CD(e,t){return`${e}/${t}`}function wD(e){return`$${(e/1e6).toFixed(4)}`}function TD(e){return e.toLocaleString(`en-US`)}function ED(e){let t=Math.abs(e);if(t<1e4)return TD(e);let n=e<0?`-`:``,[r,i]=t<1e6?[1e3,`k`]:t<1e9?[1e6,`M`]:[1e9,`B`],a=t/r,o=3-(Math.floor(a)>=100?3:Math.floor(a)>=10?2:1),s=10**o,c=(Math.floor(t*s/r)/s).toFixed(o);return o>0&&(c=c.replace(/0+$/,``).replace(/\.$/,``)),`${n}${c}${i}`}function DD(e){return e>0&&!(e&e-1)}function OD(e){return e<1024?`${e}`:DD(e)?e<1048576?`${Math.round(e/1024)}k`:`${Math.round(e/1048576)}M`:e<1e6?`${Math.round(e/1e3)}k`:`${Math.round(e/1e6)}M`}function kD(e){return`$${e.toFixed(2)}`}function AD(e,t){return e===0&&t===0?`free`:`in ${kD(e)} / out ${kD(t)} per MTok`}function jD(e){return e<1e3?`${Math.round(e)}ms`:`${(e/1e3).toFixed(1)}s`}function MD(e,t){if(!e||e===`0001-01-01T00:00:00Z`)return null;let n=new Date(e).getTime();return Number.isNaN(n)?null:Math.max(0,Math.round((t-n)/1e3))}function ND(e){let t=MD(e,Date.now());return t===null?``:` (${t}s ago)`}function PD(e,t=Date.now()){let n=MD(e,t);return n===null?``:`${n}s ago`}function FD(e){if(!e||e===`0001-01-01T00:00:00Z`)return``;let t=new Date(e).getTime();if(Number.isNaN(t))return``;let n=Math.round((t-Date.now())/1e3);return n<=0?``:`in ${n}s`}function ID(e){if(!e||e===`0001-01-01T00:00:00Z`)return`never`;let t=new Date(e);return Number.isNaN(t.getTime())?e:t.toLocaleString()}function LD(e,t){return e?ND(t)?`refreshed`:`pending`:`off`}function RD(e,t){switch(LD(e,t)){case`off`:return`discovery off`;case`pending`:return`pending`;case`refreshed`:return`refreshed${ND(t)}`}}function zD(e,t){switch(LD(e,t)){case`off`:return`discovery off`;case`pending`:return`pending`;case`refreshed`:return ID(t)}}function BD(e){if(!e)return`none`;let t=[];return e.requestsPerMinute&&t.push(`req/min ${e.requestsPerMinute}`),e.requestsPerDay&&t.push(`req/day ${e.requestsPerDay}`),e.tokensPerDay&&t.push(`tok/day ${e.tokensPerDay}`),e.tokensPerMonth&&t.push(`tok/month ${e.tokensPerMonth}`),e.costPerDayUSD&&t.push(`cost/day $${e.costPerDayUSD}`),e.costPerMonthUSD&&t.push(`cost/month $${e.costPerMonthUSD}`),t.length?t.join(`, `):`none`}function VD(e,t){switch(t){case`hour`:return`${e.slice(8,10)}:00 UTC`;case`day`:{let t=Number(e.slice(0,4)),n=Number(e.slice(4,6)),r=Number(e.slice(6,8));return new Date(t,n-1,r).toLocaleDateString(void 0,{month:`short`,day:`numeric`})}case`month`:{let t=Number(e.slice(0,4)),n=Number(e.slice(4,6));return new Date(t,n-1,1).toLocaleDateString(void 0,{month:`short`,year:`numeric`})}}}function HD(e){return yD[e]??e}function UD(e){return e.user?`user:${e.user}`:e.group?`group:${e.group}`:`—`}function WD(e){let t=[e.model,e.provider].filter(e=>!!e);return t.length?t.join(` → `):`—`}function GD(){return[{id:`time`,header:`Time`,accessorFn:e=>e.time,cell:({row:e})=>G(`span`,{class:`text-muted-foreground tabular-nums`},ID(e.original.time))},{id:`kind`,header:`Kind`,accessorFn:e=>e.kind,cell:({row:e})=>G(_D,{as:`span`,variant:xD(e.original.kind),class:`font-normal`},()=>HD(e.original.kind))},{id:`route`,header:`Route`,accessorFn:e=>e.route,cell:({row:e})=>G(`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=UD(e.original);return G(`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=WD(e.original);return G(`span`,{class:t===`—`?`text-muted-foreground`:`font-mono text-xs`},t)}},{id:`replica`,header:`Replica`,accessorFn:e=>e.replica,cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},e.original.replica)},{id:`status`,header:`Status`,meta:{align:`right`},accessorFn:e=>e.status??0,cell:({row:e})=>G(`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})=>G(`span`,{class:`text-muted-foreground`},e.original.message)}]}var KD=5e3,qD=200,JD=t_(`events`,{state:()=>({events:[],source:`replica`,replica:``,capacity:0,degraded:!1,lastUpdated:null,error:``,kindFilter:``,userFilter:``,poller:void 0,refreshing:!1}),actions:{async refresh(){if(iT().isAuthenticated&&!this.refreshing){this.refreshing=!0;try{let e=await sT(`/admin/api/events?limit=${qD}`);this.events=e.events,this.source=e.source,this.replica=e.replica,this.capacity=e.capacity,this.degraded=e.degraded??!1,this.lastUpdated=new Date,this.error=``}catch(e){if(e instanceof aT&&(e.status===401||e.status===403))return;this.error=e instanceof Error?e.message:String(e)}finally{this.refreshing=!1}}},setKindFilter(e){this.kindFilter=e},setUserFilter(e){this.userFilter=e},startPolling(){this.poller||(this.poller=lT({intervalMs:KD,tick:()=>void this.refresh()}),this.poller.start())},stopPolling(){this.poller?.stop(),this.poller=void 0}}}),YD={class:`flex flex-col gap-6`},XD={class:`flex flex-wrap items-center gap-3`},ZD={key:0,class:`mb-3 text-sm text-destructive`},QD=`all`,$D=P({__name:`EventsView`,setup(e){let t=JD(),{kindFilter:n,userFilter:r}=n_(t),{normalized:i}=gD(r),a=W(()=>n.value===``?QD:n.value),o=W(()=>SD(t.events,{kind:n.value,user:i.value}));function s(e){typeof e==`string`&&t.setKindFilter(e===QD?``:e)}let c=GD(),l=W(()=>t.lastUpdated?t.events.length===0?`no events recorded`:n.value!==``||i.value?`no events match the current filter`:`none`:`loading…`),u=W(()=>t.lastUpdated?t.source===`redis`?`Fleet-wide, across every replica`:`This replica only (${t.replica||`unknown`}) — Redis is unreachable or unconfigured`:`loading…`);return Qi(()=>{t.startPolling()}),na(()=>{t.stopPolling()}),(e,n)=>{let i=la(`FontAwesomeIcon`);return L(),R(`div`,YD,[M(t).degraded?(L(),z(M($v),{key:0,variant:`destructive`},{default:N(()=>[V(i,{icon:M(v_),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`]),V(M(ty),null,{default:N(()=>[...n[1]||=[H(`Fleet-wide event log unavailable`,-1)]]),_:1}),V(M(ey),null,{default:N(()=>[...n[2]||=[H(` 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})):U(``,!0),V(M(Jw),null,{default:N(()=>[V(M(Zw),{class:`flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between`},{default:N(()=>[B(`div`,null,[V(M(Qw),null,{default:N(()=>[...n[3]||=[H(`Events`,-1)]]),_:1}),M(t).lastUpdated?(L(),z(M(Xw),{key:1},{default:N(()=>[H(k(u.value)+` — rate limit, budget, and upstream events, newest first (capacity `+k(M(t).capacity)+`). `,1)]),_:1})):(L(),z(M(Xw),{key:0},{default:N(()=>[...n[4]||=[H(`Loading…`,-1)]]),_:1}))]),B(`div`,XD,[V(sD,{modelValue:M(r),"onUpdate:modelValue":n[0]||=e=>un(r)?r.value=e:null,placeholder:`Filter by user or group`,class:`w-56`},null,8,[`modelValue`]),V(M(cD),{"model-value":a.value,"onUpdate:modelValue":s},{default:N(()=>[V(M(mD),{class:`w-44`,"aria-label":`Filter by kind`},{default:N(()=>[V(M(hD),{placeholder:`Kind`})]),_:1}),V(M(lD),null,{default:N(()=>[V(M(dD),{value:QD},{default:N(()=>[...n[5]||=[H(`All kinds`,-1)]]),_:1}),(L(!0),R(I,null,ha(M(bD),e=>(L(),z(M(dD),{key:e,value:e},{default:N(()=>[H(k(M(yD)[e]),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),_:1}),V(M(Yw),null,{default:N(()=>[M(t).error?(L(),R(`p`,ZD,k(M(t).error),1)):U(``,!0),V(oD,{columns:M(c),data:o.value,"empty-message":l.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1})])}}});async function eO(e,t){if(navigator.clipboard?.writeText)try{return await navigator.clipboard.writeText(e),`copied`}catch{}if(!t)return`failed`;let n=document.createRange();n.selectNodeContents(t);let r=window.getSelection();return r?(r.removeAllRanges(),r.addRange(n),`selected`):`failed`}var tO=P({__name:`ModelChip`,props:{id:{},contextTokens:{},inputPerMTokUsd:{},outputPerMTokUsd:{}},setup(e){let t=e,n=ci(`label`),r=j(`idle`),i;function a(){clearTimeout(i),i=setTimeout(()=>{r.value=`idle`},1500)}async function o(){let e=await eO(t.id,n.value??void 0);r.value=e,a()}let s={idle:y_,copied:f_,selected:f_,failed:v_},c=W(()=>({idle:`Copy ${t.id}`,copied:`Copied`,selected:`Selected — press Ctrl/Cmd+C`,failed:`Copy failed`})),l=W(()=>{let e=[];return t.inputPerMTokUsd!==void 0&&t.outputPerMTokUsd!==void 0&&e.push(AD(t.inputPerMTokUsd,t.outputPerMTokUsd)),t.contextTokens!==void 0&&e.push(`${OD(t.contextTokens)} context`),e.join(` · `)}),u=W(()=>{let e=c.value[r.value];return l.value?`${e} · ${l.value}`:e});return na(()=>{clearTimeout(i)}),(t,n)=>{let i=la(`FontAwesomeIcon`);return L(),z(M(_D),{as:`button`,type:`button`,variant:`secondary`,class:O([`cursor-pointer gap-1 font-mono text-xs font-normal transition-colors hover:bg-accent hover:text-accent-foreground`,r.value===`failed`?`text-destructive`:``]),title:u.value,"aria-label":u.value,onClick:o},{default:N(()=>[B(`span`,{ref:`label`,class:`select-text`},k(e.id),513),V(i,{icon:s[r.value],class:`size-2.5 shrink-0`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`class`,`title`,`aria-label`])}}});function nO(e,t){return!Number.isFinite(e)||e<=0?null:(e-(Number.isFinite(t)?t:0))/e}function rO(e){return e===null?`no-traffic`:e<.9?`severe`:e<.99?`degraded`:`healthy`}function iO(e,t){let n=nO(e,t);return n!==null&&n<.99}function aO(e){return e>=1?`100%`:`${Math.floor(e*100)}%`}function oO(e,t,n){return e===1?t:n}function sO(e,t){if(e<=0)return`no traffic in the last minute`;let n=nO(e,t),r=n===null?``:` (${aO(n)})`;return`${e} ${oO(e,`attempt`,`attempts`)}, ${t} ${oO(t,`failure`,`failures`)} in the last minute${r}`}function cO(e,t){if(e<=0)return`no traffic today`;let n=nO(e,t),r=n===null?``:` (${aO(n)})`;return`${e} ${oO(e,`attempt`,`attempts`)}, ${t} ${oO(t,`failure`,`failures`)} today${r}`}var lO={"aria-hidden":`true`},uO={class:`sr-only`},dO=P({__name:`ProviderRateBadge`,props:{attemptsDay:{},failuresDay:{},attemptsMinute:{},failuresMinute:{}},setup(e){let t=e,n=W(()=>nO(t.attemptsDay,t.failuresDay)),r=W(()=>rO(n.value)),i=W(()=>r.value===`no-traffic`?`no traffic`:aO(n.value)),a=W(()=>t.attemptsMinute===void 0||t.failuresMinute===void 0?cO(t.attemptsDay,t.failuresDay):sO(t.attemptsMinute,t.failuresMinute)),o=W(()=>r.value===`severe`?`destructive`:r.value===`healthy`?`secondary`:`outline`),s=W(()=>r.value===`degraded`?`border-status-warn/40 text-status-warn`:r.value===`no-traffic`?`text-muted-foreground`:``);return(e,t)=>(L(),z(M(_D),{as:`span`,variant:o.value,class:O([s.value,`font-normal tabular-nums`]),title:a.value},{default:N(()=>[B(`span`,lO,k(i.value),1),B(`span`,uO,k(a.value),1)]),_:1},8,[`variant`,`class`,`title`]))}}),fO={cost:`Cost`,req:`Requests`,tokin:`Tokens in`,tokout:`Tokens out`},pO=100,mO=3e4,hO={hour:24,day:30,month:12},gO={hour:`24h`,day:`30d`,month:`12mo`};function _O(e){switch(e){case`requests`:return[`req`];case`tokens`:return[`tokin`,`tokout`];case`cost`:return[`cost`];case`models`:return[]}}var vO=t_(`history`,{state:()=>({scope:`total`,window:`hour`,tab:`requests`,modelMetric:`req`,seriesByMetric:{},modelRanking:[],modelOptions:[],modelFilter:``,loading:!1,loaded:!1,error:``,poller:void 0,seriesReqId:0,optionsReqId:0}),actions:{setScope(e){e!==this.scope&&(this.scope=e,this.seriesByMetric={},this.error=``,this.loaded=!1,this.refresh())},setWindow(e){e!==this.window&&(this.window=e,this.seriesByMetric={},this.modelRanking=[],this.error=``,this.loaded=!1,this.refresh(),this.fetchModelOptions())},setTab(e){e!==this.tab&&(this.tab=e,this.seriesByMetric={},this.modelRanking=[],this.modelFilter=``,this.error=``,this.loaded=!1,this.refresh())},setModelFilter(e){e!==this.modelFilter&&(this.modelFilter=e,this.tab===`models`&&(this.modelRanking=[],this.error=``,this.loaded=!1,this.refresh()))},setSelection(e){let t=!1,n=!1;e.window!==void 0&&e.window!==this.window&&(this.window=e.window,t=!0,n=!0),e.tab!==void 0&&e.tab!==this.tab&&(this.tab=e.tab,this.modelFilter=``,t=!0),e.scope!==void 0&&e.scope!==this.scope&&(this.scope=e.scope,t=!0),e.modelMetric!==void 0&&e.modelMetric!==this.modelMetric&&(this.modelMetric=e.modelMetric,t=!0),e.modelFilter!==void 0&&e.modelFilter!==this.modelFilter&&(this.modelFilter=e.modelFilter,t=!0),t&&(this.seriesByMetric={},this.modelRanking=[],this.error=``,this.loaded=!1,this.refresh(),n&&this.fetchModelOptions())},setModelMetric(e){e!==this.modelMetric&&(this.modelMetric=e,this.modelRanking=[],this.error=``,this.loaded=!1,this.refresh())},async refresh(){await(this.tab===`models`?this.fetchModelRanking():this.fetchSeries())},async fetchSeries(){if(!iT().isAuthenticated)return;let e=++this.seriesReqId;this.loading=!0;try{let t=hO[this.window],n=_O(this.tab),r=await Promise.all(n.map(e=>sT(`/admin/api/usage/history?scope=${encodeURIComponent(this.scope)}&metric=${e}&window=${this.window}&span=${t}`)));if(e!==this.seriesReqId)return;let i={};n.forEach((e,t)=>{i[e]=r[t].points}),this.seriesByMetric=i,this.loaded=!0,this.error=``}catch(t){if(e!==this.seriesReqId||t instanceof aT&&(t.status===401||t.status===403))return;this.error=t instanceof Error?t.message:String(t)}finally{e===this.seriesReqId&&(this.loading=!1)}},async fetchModelRanking(){if(!iT().isAuthenticated)return;let e=++this.seriesReqId;this.loading=!0;try{let t=hO[this.window],n=this.modelFilter?`&prefix=${encodeURIComponent(this.modelFilter)}`:``,r=await sT(`/admin/api/usage/models?metric=${this.modelMetric}&window=${this.window}&limit=20&span=${t}${n}&detail=1`);if(e!==this.seriesReqId)return;this.modelRanking=r.models,this.loaded=!0,this.error=``}catch(t){if(e!==this.seriesReqId||t instanceof aT&&(t.status===401||t.status===403))return;this.error=t instanceof Error?t.message:String(t)}finally{e===this.seriesReqId&&(this.loading=!1)}},async fetchModelOptions(){if(!iT().isAuthenticated)return;let e=++this.optionsReqId;try{let t=hO[this.window],n=await sT(`/admin/api/usage/models?metric=req&window=${this.window}&limit=${pO}&span=${t}`);if(e!==this.optionsReqId)return;this.modelOptions=n.models}catch{}},startAutoRefresh(){this.poller||(this.poller=lT({intervalMs:mO,tick:()=>{this.loading||this.refresh()}}),this.poller.start())},stopAutoRefresh(){this.poller?.stop(),this.poller=void 0}}}),yO=t_(`nav`,{state:()=>({activeTab:`providers`,usageQuery:``}),actions:{goToCharts(e){let t=vO();t.setSelection(t.tab===`models`?{tab:`requests`,scope:e}:{scope:e}),this.activeTab=`charts`},goToModels(e){vO().setSelection({tab:`models`,modelFilter:e}),this.activeTab=`charts`}}}),bO=[`aria-label`,`title`],xO=P({__name:`ScopeLink`,props:{label:{},scope:{}},setup(e){let t=e,n=yO();function r(e){e.stopPropagation(),n.goToCharts(t.scope)}return(t,n)=>{let i=la(`FontAwesomeIcon`);return L(),R(`button`,{type:`button`,"aria-label":`View ${e.label} in Charts`,title:`View ${e.label} in Charts`,class:`inline-flex cursor-pointer items-center gap-1 rounded-sm text-inherit hover:text-primary hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50`,onClick:r},[B(`span`,null,k(e.label),1),V(i,{icon:M(d_),class:`size-3`,"aria-hidden":`true`},null,8,[`icon`])],8,bO)}}}),SO=P({__name:`Accordion`,props:{collapsible:{type:Boolean},disabled:{type:Boolean},dir:{},orientation:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},type:{},modelValue:{},defaultValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=db(Oy(n,`class`),r);return(e,t)=>(L(),z(M(qb),ks({"data-slot":`accordion`},M(i),{class:M(Qv)(`flex w-full flex-col`,n.class)}),{default:N(t=>[F(e.$slots,`default`,xe(Cs(t)))]),_:3},16,[`class`]))}}),CO=P({__name:`AccordionContent`,props:{forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Oy(t,`class`);return(e,r)=>(L(),z(M(Qb),ks({"data-slot":`accordion-content`},M(n),{class:`data-open:animate-accordion-down data-closed:animate-accordion-up text-sm overflow-hidden`}),{default:N(()=>[B(`div`,{class:O(M(Qv)(`pt-0 pb-2.5 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4`,t.class))},[F(e.$slots,`default`)],2)]),_:3},16))}}),wO=P({__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=ub(Oy(t,`class`));return(e,r)=>(L(),z(M(Zb),ks({"data-slot":`accordion-item`},M(n),{class:M(Qv)(`not-last:border-b`,t.class)}),{default:N(t=>[F(e.$slots,`default`,xe(Cs(t)))]),_:3},16,[`class`]))}}),TO=P({__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=Oy(t,`class`,`headerClass`);return(e,r)=>{let i=la(`FontAwesomeIcon`);return L(),z(M($b),{class:O(M(Qv)(`flex`,t.headerClass))},{default:N(()=>[V(M(ex),ks({"data-slot":`accordion-trigger`},M(n),{class:M(Qv)(`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:N(()=>[F(e.$slots,`default`),F(e.$slots,`icon`,{},()=>[V(i,{icon:M(g_),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden`},null,8,[`icon`]),V(i,{icon:M(c_),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none hidden shrink-0 group-aria-expanded/accordion-trigger:inline`},null,8,[`icon`])])]),_:3},16,[`class`])]),_:3},8,[`class`])}}});function EO(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 DO(e,t,n){n?(e.manuallyExpanded.delete(t),e.manuallyCollapsed.add(t)):(e.manuallyCollapsed.delete(t),e.manuallyExpanded.add(t))}function OO(e){e.manuallyCollapsed.clear()}var kO={class:`flex flex-col gap-6`},AO={class:`grid gap-4 sm:grid-cols-3`},jO={class:`font-medium`},MO={key:0,class:`flex items-start gap-1.5 text-destructive`},NO={class:`font-medium`},PO={key:0,class:`text-muted-foreground`},FO={class:`font-medium`},IO={key:0,class:`text-muted-foreground`},LO={key:0,class:`py-6 text-center text-sm text-muted-foreground`},RO={key:1,class:`py-6 text-center text-sm text-muted-foreground`},zO={class:`mb-2 text-xs text-muted-foreground`},BO={class:`flex items-center gap-2`},VO=[`aria-label`,`title`,`onClick`],HO={class:`sr-only`},UO={class:`flex flex-1 flex-wrap items-center gap-x-3 gap-y-1 pr-2 text-left`},WO={class:`text-xs text-muted-foreground tabular-nums`},GO={class:`text-xs text-muted-foreground`},KO={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-3`},qO={class:`break-all`},JO={key:0},YO={key:1},XO={class:`text-destructive`},ZO={key:0,class:`flex flex-wrap gap-1.5`},QO={key:0,title:`context window`,class:`text-xs text-muted-foreground tabular-nums`},$O={key:1,class:`text-sm text-muted-foreground`},ek={key:0,class:`text-xs text-muted-foreground`},tk=P({__name:`ProvidersView`,setup(e){let t=dT(),n=W(()=>t.overview),r=yO();function i(e){r.goToModels(`${e}/`)}let a=Zt({manuallyExpanded:new Set,manuallyCollapsed:new Set}),{query:o,normalized:s,hasQuery:c}=gD();function l(e,t){return CD(e,t).toLowerCase().includes(s.value)}function u(e){return e.models.some(t=>l(e.name,t))}function d(e){return e.alias.toLowerCase().includes(s.value)||e.target.toLowerCase().includes(s.value)}let f=W(()=>{let e=n.value?.providers??[];return c.value?e.filter(u):e}),p=W(()=>{let e=n.value?.aliases??[];return c.value?e.filter(d):e}),m=W(()=>EO(a,c.value,f.value.map(e=>e.name)));function h(e){DO(a,e,m.value.has(e))}let g=W({get:()=>Array.from(m.value),set:e=>{let t=new Set(e);for(let e of m.value)t.has(e)||h(e);for(let e of t)m.value.has(e)||h(e)}});Dr(o,e=>{e.trim()===``&&OO(a)});function _(e){return c.value?e.models.filter(t=>l(e.name,t)):e.models}let v={attemptsDay:0,failuresDay:0};function y(e,t){return e.modelRates?.[t]??v}function b(e,t){let n=y(e,t);return iO(n.attemptsDay,n.failuresDay)}let x={};function S(e,t){return e.modelMeta?.[t]??x}function C(e){switch(e){case`open`:return`destructive`;case`half-open`:return`secondary`;default:return}}function w(e){let t=FD(e.openUntil);return t?`${e.healthState} (${t})`:e.healthState}function ee(e){return e===`open`?`text-destructive`:`text-muted-foreground`}function te(e){return e.latency?.streaming}function T(e){return e.latency?.[`non-streaming`]}function ne(e){return e.count===void 0?`no observations counted`:`${e.count} ${e.count===1?`observation`:`observations`} on this replica`}function re(){let e=n.value?.replica;return`Per-replica (${e?`replica ${e}`:`this replica`}), in-process only — not a fleet-wide average across this deployment’s replicas.`}function ie(e){return`Average time to first byte, the load-sensitive reading for streaming traffic. ${ne(e)}. ${re()}`}function E(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. ${ne(e)}. ${re()}`}function ae(e){return e.provenance?.estimated}function oe(e){return e.provenance?.unbilled}function se(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. ${re()}`}function ce(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. ${re()}`}let D=[{id:`alias`,header:`Alias`,accessorFn:e=>e.alias,cell:({row:e})=>G(tO,{id:e.original.alias,contextTokens:e.original.modelMeta?.contextTokens,inputPerMTokUsd:e.original.modelMeta?.inputPerMTokUsd,outputPerMTokUsd:e.original.modelMeta?.outputPerMTokUsd})},{id:`target`,header:`Target`,accessorFn:e=>e.target,cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},e.original.target)}],le=W(()=>n.value?.aliases.length?c.value?`no aliases match "${o.value}"`:`none`:`none configured`);return(e,t)=>{let r=la(`FontAwesomeIcon`);return L(),R(`div`,kO,[B(`div`,AO,[V(M(Jw),null,{default:N(()=>[V(M(Zw),null,{default:N(()=>[V(M(Qw),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:N(()=>[V(r,{icon:n.value?.redis.configured?M(h_):M(l_),class:O([n.value?.redis.configured?`text-chart-requests`:`text-muted-foreground`,`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),t[2]||=H(` Redis `,-1)]),_:1})]),_:1}),V(M(Yw),{class:`flex flex-col gap-1 text-sm`},{default:N(()=>[B(`p`,jO,k(n.value?.redis.configured?`Configured`:`Not configured`),1),n.value?.redis.lastErr?(L(),R(`p`,MO,[V(r,{icon:M(v_),class:`mt-0.5 size-3.5 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),B(`span`,null,k(n.value.redis.lastErr)+k(M(ND)(n.value.redis.lastErrAt)),1)])):U(``,!0)]),_:1})]),_:1}),V(M(Jw),null,{default:N(()=>[V(M(Zw),null,{default:N(()=>[V(M(Qw),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:N(()=>[V(r,{icon:n.value?.cache.enabled?M(h_):M(l_),class:O([n.value?.cache.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),t[3]||=H(` Response cache `,-1)]),_:1})]),_:1}),V(M(Yw),{class:`text-sm`},{default:N(()=>[B(`p`,NO,k(n.value?.cache.enabled?`Enabled`:`Disabled`),1),n.value?.cache.enabled?(L(),R(`p`,PO,`ttl `+k(n.value.cache.ttl),1)):U(``,!0)]),_:1})]),_:1}),V(M(Jw),null,{default:N(()=>[V(M(Zw),null,{default:N(()=>[V(M(Qw),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:N(()=>[V(r,{icon:n.value?.retry.enabled?M(h_):M(l_),class:O([n.value?.retry.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),t[4]||=H(` Retry `,-1)]),_:1})]),_:1}),V(M(Yw),{class:`text-sm`},{default:N(()=>[B(`p`,FO,k(n.value?.retry.enabled?`Enabled`:`Disabled`),1),n.value?.retry.enabled?(L(),R(`p`,IO,` attempts `+k(n.value.retry.attempts)+`, backoff `+k(n.value.retry.backoff),1)):U(``,!0)]),_:1})]),_:1})]),V(M(Jw),null,{default:N(()=>[V(M(Zw),null,{default:N(()=>[V(M(Qw),null,{default:N(()=>[...t[5]||=[H(`Providers`,-1)]]),_:1}),V(M(Xw),null,{default:N(()=>[...t[6]||=[H(` Every configured upstream and its last discovery refresh. Search filters providers and aliases by model id. `,-1)]]),_:1}),V(sD,{modelValue:M(o),"onUpdate:modelValue":t[0]||=e=>un(o)?o.value=e:null,placeholder:`Search models or aliases...`,class:`mt-2 max-w-sm`},null,8,[`modelValue`])]),_:1}),V(M(Yw),null,{default:N(()=>[n.value?.providers.length?M(c)&&f.value.length===0?(L(),R(`p`,RO,` no providers match "`+k(M(o))+`" `,1)):(L(),R(I,{key:2},[B(`p`,zO,k(re()),1),V(M(SO),{modelValue:g.value,"onUpdate:modelValue":t[1]||=e=>g.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:N(()=>[(L(!0),R(I,null,ha(f.value,e=>(L(),z(M(wO),{key:e.name,value:e.name},{default:N(()=>[B(`div`,BO,[B(`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 Charts`,title:`View ${e.name}'s models in Charts`,onClick:t=>i(e.name)},k(e.name),9,VO),V(M(TO),{"header-class":`flex-1`},{default:N(()=>[B(`span`,HO,`Provider `+k(e.name)+` details`,1),B(`span`,UO,[V(M(_D),{as:`span`,variant:`secondary`,class:`font-normal`},{default:N(()=>[H(k(e.type),1)]),_:2},1024),B(`span`,WO,k(e.modelCount)+` models`,1),V(dO,{"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`?U(``,!0):(L(),z(M(_D),{key:0,as:`span`,variant:C(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:N(()=>[H(k(w(e)),1)]),_:2},1032,[`variant`,`title`])),te(e)?.avgTtfbMs===void 0?U(``,!0):(L(),z(M(_D),{key:1,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:ie(te(e))},{default:N(()=>[H(` streaming ttfb `+k(M(jD)(te(e).avgTtfbMs)),1)]),_:2},1032,[`title`])),T(e)?.avgDurationMs===void 0?U(``,!0):(L(),z(M(_D),{key:2,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:E(T(e))},{default:N(()=>[H(` non-streaming avg `+k(M(jD)(T(e).avgDurationMs)),1)]),_:2},1032,[`title`])),ae(e)?(L(),z(M(_D),{key:3,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:se(ae(e))},{default:N(()=>[H(` estimated `+k(ae(e).requests),1)]),_:2},1032,[`title`])):U(``,!0),oe(e)?(L(),z(M(_D),{key:4,as:`span`,variant:`destructive`,class:`font-normal tabular-nums`,title:ce(oe(e))},{default:N(()=>[H(` unbilled `+k(oe(e).requests),1)]),_:2},1032,[`title`])):U(``,!0),e.lastErr?(L(),z(r,{key:5,icon:M(v_),class:`size-3.5 shrink-0 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):U(``,!0),B(`span`,GO,k(M(RD)(e.discoveryEnabled,e.lastRefresh)),1)])]),_:2},1024)]),V(M(CO),null,{default:N(()=>[B(`dl`,KO,[B(`div`,null,[t[7]||=B(`dt`,{class:`text-xs text-muted-foreground`},`Base URL`,-1),B(`dd`,qO,k(e.baseUrl),1)]),B(`div`,null,[t[8]||=B(`dt`,{class:`text-xs text-muted-foreground`},`Last refresh`,-1),B(`dd`,null,k(M(zD)(e.discoveryEnabled,e.lastRefresh)),1)]),e.healthState===`closed`?U(``,!0):(L(),R(`div`,JO,[t[9]||=B(`dt`,{class:`text-xs text-muted-foreground`},`Discovery health`,-1),B(`dd`,{class:O(ee(e.healthState))},k(w(e)),3)])),e.lastErr?(L(),R(`div`,YO,[t[10]||=B(`dt`,{class:`text-xs text-muted-foreground`},`Last error`,-1),B(`dd`,XO,k(e.lastErr),1)])):U(``,!0)]),_(e).length?(L(),R(`div`,ZO,[(L(!0),R(I,null,ha(_(e),t=>(L(),R(`span`,{key:t,class:`inline-flex items-center gap-1`},[V(tO,{id:M(CD)(e.name,t),"context-tokens":S(e,t).contextTokens,"input-per-m-tok-usd":S(e,t).inputPerMTokUsd,"output-per-m-tok-usd":S(e,t).outputPerMTokUsd},null,8,[`id`,`context-tokens`,`input-per-m-tok-usd`,`output-per-m-tok-usd`]),V(xO,{label:M(CD)(e.name,t),scope:`model:${M(CD)(e.name,t)}`},null,8,[`label`,`scope`]),S(e,t).contextTokens===void 0?U(``,!0):(L(),R(`span`,QO,k(M(OD)(S(e,t).contextTokens)),1)),b(e,t)?(L(),z(dO,{key:1,"attempts-day":y(e,t).attemptsDay,"failures-day":y(e,t).failuresDay},null,8,[`attempts-day`,`failures-day`])):U(``,!0)]))),128))])):(L(),R(`p`,$O,`no models known yet`))]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])],64)):(L(),R(`p`,LO,`none`))]),_:1})]),_:1}),V(M(Jw),null,{default:N(()=>[V(M(Zw),null,{default:N(()=>[V(M(Qw),null,{default:N(()=>[...t[11]||=[H(`Model aliases`,-1)]]),_:1}),V(M(Xw),null,{default:N(()=>[...t[12]||=[H(`Operator-defined alias → target model mappings.`,-1)]]),_:1})]),_:1}),V(M(Yw),null,{default:N(()=>[V(oD,{columns:D,data:p.value,"empty-message":le.value},null,8,[`data`,`empty-message`])]),_:1})]),_:1}),n.value?.version?(L(),R(`p`,ek,`Version: `+k(n.value.version),1)):U(``,!0)])}}}),nk=[`title`],rk={"aria-hidden":`true`},ik={class:`sr-only`},ak=P({__name:`CompactNumber`,props:{value:{}},setup(e){let t=e,n=W(()=>ED(t.value)),r=W(()=>TD(t.value));return(e,t)=>(L(),R(`span`,{title:r.value},[B(`span`,rk,k(n.value),1),B(`span`,ik,k(r.value),1)],8,nk))}});function ok(e,t,n){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>G(ak,{value:n(e.original)})}}var sk=`not observed yet — no traffic and probes disabled or not yet run`;function ck(e){let t=PD(e.lastCheck);return t?`unhealthy (${t})`:`unhealthy`}function lk(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 uk(e){let t=PD(e.lastCheck);return t?e.source?`${t} via ${e.source}`:t:e.source?`via ${e.source}`:``}function dk(e){if(e.consecutiveFailures<=0&&!e.lastError)return sk;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 fk(e){if(e.state===`unhealthy`)return G(_D,{as:`span`,variant:`destructive`,class:`font-normal`,title:lk(e)},()=>ck(e));if(e.state===`healthy`){let t=e.latencyMs===void 0?``:` · ${jD(e.latencyMs)}`;return G(`span`,{class:`text-muted-foreground`,title:uk(e)},`healthy${t}`)}return G(_D,{as:`span`,variant:`outline`,class:`font-normal`,title:dk(e)},()=>`unknown`)}function pk(){return[{id:`name`,header:`Name`,accessorFn:e=>e.name,cell:({row:e})=>G(`span`,{class:`font-medium`},e.original.name)},{id:`url`,header:`URL`,accessorFn:e=>e.url,cell:({row:e})=>G(`span`,{class:`block max-w-xs truncate text-muted-foreground`,title:e.original.url},e.original.url)},{id:`health`,header:`Health`,enableSorting:!1,accessorFn:e=>e.health.state,cell:({row:e})=>fk(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?G(`span`,{class:`text-muted-foreground`},`All groups`):t.length===0?G(`span`,{class:`text-muted-foreground`},`No groups`):G(`div`,{class:`flex flex-wrap gap-1.5`},t.map(e=>G(_D,{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},()=>e)))}},ok(`reqMin`,`req/min`,e=>e.counters.requestsPerMinute),ok(`reqDay`,`req/day`,e=>e.counters.requestsPerDay),ok(`reqMonth`,`req/month`,e=>e.counters.requestsPerMonth)]}var mk={class:`flex flex-col gap-6`},hk=P({__name:`TargetsView`,setup(e){let t=dT(),n=W(()=>t.targets),{query:r,normalized:i,hasQuery:a}=gD();function o(e){return e.name.toLowerCase().includes(i.value)}let s=W(()=>{let e=n.value?.mcpServers??[];return a.value?e.filter(o):e}),c=W(()=>{let e=n.value?.agents??[];return a.value?e.filter(o):e});function l(e,t){return e?a.value&&t===0?`no targets match "${r.value}"`:`none`:`none configured`}let u=W(()=>l(n.value?.mcpServers.length??0,s.value.length)),d=W(()=>l(n.value?.agents.length??0,c.value.length)),f=pk();return(e,t)=>(L(),R(`div`,mk,[V(sD,{modelValue:M(r),"onUpdate:modelValue":t[0]||=e=>un(r)?r.value=e:null,placeholder:`Filter MCP servers or agents`,class:`max-w-sm`},null,8,[`modelValue`]),V(M(Jw),null,{default:N(()=>[V(M(Zw),null,{default:N(()=>[V(M(Qw),null,{default:N(()=>[...t[1]||=[H(`MCP servers`,-1)]]),_:1}),V(M(Xw),null,{default:N(()=>[...t[2]||=[H(`Configured MCP proxy targets, the groups allowed to reach them, and their request counters.`,-1)]]),_:1})]),_:1}),V(M(Yw),null,{default:N(()=>[V(oD,{columns:M(f),data:s.value,"empty-message":u.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1}),V(M(Jw),null,{default:N(()=>[V(M(Zw),null,{default:N(()=>[V(M(Qw),null,{default:N(()=>[...t[3]||=[H(`Agents`,-1)]]),_:1}),V(M(Xw),null,{default:N(()=>[...t[4]||=[H(`Configured A2A agent proxy targets, the groups allowed to reach them, and their request counters.`,-1)]]),_:1})]),_:1}),V(M(Yw),null,{default:N(()=>[V(oD,{columns:M(f),data:c.value,"empty-message":d.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1})]))}}),gk=P({__name:`Tabs`,props:{defaultValue:{},orientation:{},dir:{},activationMode:{},modelValue:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=db(Oy(n,`class`),r);return(e,t)=>(L(),z(M(zw),ks({"data-slot":`tabs`,"data-orientation":M(i).orientation||`horizontal`},M(i),{class:M(Qv)(`gap-2 group/tabs flex data-horizontal:flex-col`,n.class)}),{default:N(t=>[F(e.$slots,`default`,xe(Cs(t)))]),_:3},16,[`data-orientation`,`class`]))}}),_k=P({__name:`TabsContent`,props:{value:{},forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=Oy(t,`class`);return(e,r)=>(L(),z(M(Hw),ks({"data-slot":`tabs-content`,class:M(Qv)(`text-sm flex-1 outline-none`,t.class)},M(n)),{default:N(()=>[F(e.$slots,`default`)]),_:3},16,[`class`]))}}),vk=P({__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=Oy(t,`class`,`variant`);return(r,i)=>(L(),z(M(Uw),ks({"data-slot":`tabs-list`,"data-variant":e.variant},M(n),{class:M(Qv)(M(bk)({variant:e.variant}),t.class)}),{default:N(()=>[F(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),yk=P({__name:`TabsTrigger`,props:{value:{},disabled:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=ub(Oy(t,`class`));return(e,r)=>(L(),z(M(Ww),ks({"data-slot":`tabs-trigger`,class:M(Qv)(`gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg:not([class*=size-])]:size-4 has-data-[icon=inline-end]:pr-1 has-data-[icon=inline-start]:pl-1 relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center whitespace-nowrap text-foreground/60 transition-all group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 dark:text-muted-foreground dark:hover:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0`,`group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent`,`data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground`,`after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100`,t.class)},M(n)),{default:N(()=>[F(e.$slots,`default`)]),_:3},16,[`class`]))}}),bk=E_(`rounded-lg p-0.75 group-data-horizontal/tabs:h-8 data-[variant=line]:rounded-none group/tabs-list inline-flex w-fit items-center justify-center text-muted-foreground group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col`,{variants:{variant:{default:`bg-muted`,line:`gap-1 bg-transparent`}},defaultVariants:{variant:`default`}});function xk(e){return!Number.isFinite(e)||e<.8?`normal`:e<1?`amber`:`red`}var Sk=1e6,Ck={reqMin:`req/min`,reqDay:`req/day`,tokDay:`tokens (in+out)/day`,tokMonth:`tokens (in+out)/month`,costDay:`cost/day`,costMonth:`cost/month`};function wk(e,t,n){return{id:e,used:t,limit:n,ratio:t/n}}function Tk(e){let t=e.limits;if(!t||e.storeDown)return[];let n=[];if(t.requestsPerMinute&&n.push(wk(`reqMin`,e.requestsPerMinute,t.requestsPerMinute)),t.requestsPerDay&&n.push(wk(`reqDay`,e.requestsPerDay,t.requestsPerDay)),t.tokensPerDay&&n.push(wk(`tokDay`,e.tokensInPerDay+e.tokensOutPerDay,t.tokensPerDay)),t.tokensPerMonth&&n.push(wk(`tokMonth`,e.tokensInPerMonth+e.tokensOutPerMonth,t.tokensPerMonth)),t.costPerDayUSD){let r=Math.round(t.costPerDayUSD*Sk);r>0&&n.push(wk(`costDay`,e.costPerDayMicroUsd,r))}if(t.costPerMonthUSD){let r=Math.round(t.costPerMonthUSD*Sk);r>0&&n.push(wk(`costMonth`,e.costPerMonthMicroUsd,r))}return n}function Ek(e){let t=e.getUTCFullYear(),n=e.getUTCMonth(),r=Date.UTC(t,n,1),i=Date.UTC(t,n+1,1);return(e.getTime()-r)/(i-r)}function Dk(e,t){return t<.02?null:Math.round(e/t)}function Ok(e,t){if(e===null||t===void 0||t<=0)return{limitMicros:null,remainingMicros:null,willExceed:!1};let n=Math.round(t*Sk),r=n-e;return{limitMicros:n,remainingMicros:r,willExceed:r<0}}var kk={class:`text-lg font-semibold tabular-nums`},Ak={key:0,class:`text-sm text-muted-foreground`},jk=[`title`],Mk={key:0},Nk={class:`text-lg font-semibold tabular-nums`},Pk=P({__name:`CostForecastCard`,props:{mtdMicros:{},limits:{},now:{}},setup(e){let t=e,n=W(()=>Ek(t.now)),r=W(()=>Dk(t.mtdMicros,n.value)),i=W(()=>Ok(r.value,t.limits?.costPerMonthUSD));return(t,n)=>(L(),z(M(Jw),null,{default:N(()=>[V(M(Zw),null,{default:N(()=>[V(M(Qw),null,{default:N(()=>[...n[0]||=[H(`Cost forecast`,-1)]]),_:1}),V(M(Xw),null,{default:N(()=>[...n[1]||=[H(`Projected month-end spend, extrapolated from month-to-date usage (UTC calendar month).`,-1)]]),_:1})]),_:1}),V(M(Yw),{class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-3`},{default:N(()=>[B(`div`,null,[n[2]||=B(`p`,{class:`text-muted-foreground`},`Month to date`,-1),B(`p`,kk,k(M(wD)(e.mtdMicros)),1)]),B(`div`,null,[n[3]||=B(`p`,{class:`text-muted-foreground`},`Projected month-end`,-1),r.value===null?(L(),R(`p`,Ak,`not enough data yet`)):(L(),R(`p`,{key:1,class:O([`text-lg font-semibold tabular-nums`,i.value.willExceed?`text-destructive`:void 0]),title:i.value.willExceed?`Projected to exceed the configured cost/month limit`:void 0},k(M(wD)(r.value)),11,jk))]),i.value.limitMicros===null?U(``,!0):(L(),R(`div`,Mk,[n[4]||=B(`p`,{class:`text-muted-foreground`},`Limit`,-1),B(`p`,Nk,k(M(wD)(i.value.limitMicros)),1)]))]),_:1})]),_:1}))}}),Fk=`text/csv;charset=utf-8;`,Ik=1e3;async function Lk(e,t,n=Fk){if(typeof document>`u`)return`failed`;try{let r=new Blob([t],{type:n}),i=URL.createObjectURL(r),a=document.createElement(`a`);return a.href=i,a.download=e,document.body.appendChild(a),a.click(),a.remove(),setTimeout(()=>URL.revokeObjectURL(i),Ik),`downloaded`}catch{return eO(t)}}var Rk=2500,zk=P({__name:`CsvExportButton`,props:{filename:{},build:{type:Function}},setup(e){let t=e,n=j(!1),r=j(null),i,a={downloaded:`Downloaded`,copied:`Copied`,selected:`Selected — press ⌘/Ctrl+C`,failed:`Export failed`},o=W(()=>r.value?a[r.value]:`Export CSV`),s=W(()=>r.value===`failed`);function c(){i!==void 0&&clearTimeout(i),i=setTimeout(()=>{r.value=null,i=void 0},Rk)}async function l(){if(!n.value){n.value=!0;try{r.value=await Lk(t.filename,t.build()),c()}finally{n.value=!1}}}return ta(()=>{i!==void 0&&clearTimeout(i)}),(e,t)=>{let i=la(`FontAwesomeIcon`);return L(),z(M(Gw),{type:`button`,variant:`outline`,size:`sm`,disabled:n.value,onClick:l},{default:N(()=>[r.value===`failed`?(L(),z(i,{key:0,icon:M(l_),class:`size-3.5 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):r.value?(L(),z(i,{key:1,icon:M(h_),class:`size-3.5 text-chart-requests`,"aria-hidden":`true`},null,8,[`icon`])):(L(),z(i,{key:2,icon:M(__),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`])),B(`span`,{class:O(s.value?`text-destructive`:void 0)},k(o.value),3)]),_:1},8,[`disabled`])}}}),Bk=[`aria-label`,`aria-valuenow`,`aria-valuetext`,`title`],Vk=P({__name:`UsageBar`,props:{ratio:{},label:{},valueText:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=W(()=>xk(t.ratio)),r=W(()=>Math.min(100,Math.max(0,t.ratio*100))),i=W(()=>Math.round(r.value)),a={normal:`bg-primary`,amber:`bg-bar-amber`,red:`bg-destructive`};return(o,s)=>(L(),R(`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:O(M(Qv)(`relative inline-block h-1.5 w-14 shrink-0 overflow-hidden rounded-full bg-muted align-middle`,t.class))},[B(`span`,{class:O([`absolute inset-y-0 left-0 rounded-full`,a[n.value]]),style:ge({width:`${r.value}%`})},null,6)],10,Bk))}});function Hk(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 o=n(e.original),s=i?G(ak,{value:o}):r(o);if(!a)return s;let c=Tk(e.original).find(e=>e.id===a);if(!c)return s;let l=i?`${TD(c.used)} / ${TD(c.limit)}`:`${r(c.used)} / ${r(c.limit)}`;return G(`span`,{class:`inline-flex items-center justify-end gap-1.5`},[s,G(Vk,{ratio:c.ratio,label:Ck[a]??t,valueText:l})])}}}function Uk(){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 G(ak,{value:t,class:t>0?`text-destructive`:void 0})}}}function Wk(e){return{id:`costMonthProj`,header:`cost/month (proj.)`,meta:{align:`right`},accessorFn:t=>Dk(t.costPerMonthMicroUsd,e)??0,cell:({row:t})=>{if(t.original.storeDown)return`?`;let n=Dk(t.original.costPerMonthMicroUsd,e);if(n===null)return G(`span`,{class:`text-muted-foreground`},`not enough data yet`);let r=Ok(n,t.original.limits?.costPerMonthUSD);return G(`span`,{class:r.willExceed?`text-destructive`:void 0,title:r.willExceed?`Projected to exceed the configured cost/month limit`:void 0},wD(n))}}}function Gk(e,t,n,r=new Date){let i=Ek(r);return[{id:`id`,header:e,accessorFn:e=>e.id,cell:({row:e})=>G(xO,{class:`font-medium`,label:e.original.id,scope:`${e.original.kind}:${e.original.id}`})},{id:`secondary`,header:t,accessorFn:n,sortingFn:`alphanumeric`,cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},n(e.original))},{id:`limits`,header:`Limits`,accessorFn:e=>BD(e.limits),cell:({row:e})=>G(`span`,{class:`text-muted-foreground`},BD(e.original.limits))},Hk(`reqMin`,`req/min`,e=>e.requestsPerMinute,String,!0,`reqMin`),Hk(`reqDay`,`req/day`,e=>e.requestsPerDay,String,!0,`reqDay`),Uk(),Hk(`tokInDay`,`tokIn/day`,e=>e.tokensInPerDay,String,!0,`tokDay`),Hk(`tokOutDay`,`tokOut/day`,e=>e.tokensOutPerDay,String,!0,`tokDay`),Hk(`tokInMonth`,`tokIn/month`,e=>e.tokensInPerMonth,String,!0,`tokMonth`),Hk(`tokOutMonth`,`tokOut/month`,e=>e.tokensOutPerMonth,String,!0,`tokMonth`),Hk(`costDay`,`cost/day`,e=>e.costPerDayMicroUsd,wD,!1,`costDay`),Hk(`costMonth`,`cost/month`,e=>e.costPerMonthMicroUsd,wD,!1,`costMonth`),Wk(i)]}var Kk=P({__name:`UsageTable`,props:{idLabel:{},entries:{},secondaryColumnLabel:{},secondaryValue:{type:Function},emptyMessage:{},now:{},sorting:{}},emits:[`update:sorting`],setup(e,{emit:t}){let n=e,r=t,i=W(()=>Gk(n.idLabel,n.secondaryColumnLabel,n.secondaryValue,n.now));return(t,n)=>(L(),z(oD,{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`]))}}),qk=6e4;function Jk(e=qk){let t=j(new Date),n;function r(){n||(n=lT({intervalMs:e,tick:()=>{t.value=new Date}}),n.start())}function i(){n?.stop(),n=void 0}return{now:t,start:r,stop:i}}var Yk=`\r
`,Xk=/[",\r\n]/,Zk=/^[=+\-@\t\r]/;function Qk(e){let t=e==null?``:String(e);return Zk.test(t)&&(t=`'${t}`),Xk.test(t)?`"${t.replace(/"/g,`""`)}"`:t}function $k(e,t){return[e,...t].map(e=>e.map(Qk).join(`,`)).join(Yk)+Yk}var eA={users:`Group`,groups:`Members`};function tA(e){return(e/Sk).toFixed(6)}function nA(e,t,n,r=new Date){let i=Ek(r);return $k([`Name`,eA[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)`],e.map(e=>{let t=e.storeDown,r=t?null:Dk(e.costPerMonthMicroUsd,i);return[e.id,n(e),BD(e.limits),t?`?`:e.requestsPerMinute,t?`?`:e.requestsPerDay,t?`?`:e.rejectionsPerDay,t?`?`:e.tokensInPerDay,t?`?`:e.tokensOutPerDay,t?`?`:e.tokensInPerMonth,t?`?`:e.tokensOutPerMonth,t?`?`:tA(e.costPerDayMicroUsd),t?`?`:tA(e.costPerMonthMicroUsd),t?`?`:r===null?`not enough data yet`:tA(r)]}))}function rA(e,t,n){return $k([`Model`,`Requests (${t}, span ${n})`,`Tokens in`,`Tokens out`,`Cost (USD)`,`Free`],e.map(e=>[e.id,e.requests??0,e.tokensIn??0,e.tokensOut??0,tA(e.costMicroUsd??0),e.free?`true`:`false`]))}function iA(e,t){return e.id.toLowerCase().includes(t)}function aA(e,t){return e.id.toLowerCase().includes(t)}function oA(e,t){return t.filter(t=>(t.groups??[t.groupName]).includes(e.id))}function sA(e,t,n){return oA(e,t).filter(e=>iA(e,n))}function cA(e,t,n){return aA(e,n)||sA(e,t,n).length>0}var lA={class:`flex flex-col gap-6`},uA={class:`text-lg font-semibold tabular-nums`},dA={class:`text-lg font-semibold tabular-nums`},fA={class:`text-lg font-semibold tabular-nums`},pA={class:`text-lg font-semibold tabular-nums`},mA={class:`flex items-start justify-between gap-2`},hA={key:0,class:`mb-3 flex flex-wrap gap-x-4 gap-y-1 text-xs font-medium text-muted-foreground`},gA={class:`flex items-center gap-2`},_A={class:`sr-only`},vA={class:`flex flex-1 flex-wrap items-center gap-x-4 gap-y-1 pr-2 text-left`},yA={class:`text-xs text-muted-foreground tabular-nums`},bA={class:`text-xs text-muted-foreground tabular-nums`},xA={class:`text-xs text-muted-foreground tabular-nums`},SA={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},CA={key:0,class:`flex flex-wrap gap-1.5`},wA={key:1,class:`text-muted-foreground`},TA={key:0,class:`flex flex-wrap gap-1.5`},EA={key:1,class:`text-muted-foreground`},DA={key:0,class:`flex flex-wrap gap-1.5`},OA={key:1,class:`text-muted-foreground`},kA={key:0,class:`flex flex-wrap gap-1.5`},AA={key:1,class:`text-muted-foreground`},jA={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},MA={class:`tabular-nums`},NA={class:`tabular-nums`},PA={class:`tabular-nums`},FA={class:`tabular-nums`},IA={class:`tabular-nums`},LA={class:`tabular-nums`},RA=[`title`],zA={key:0,class:`mb-3 flex flex-wrap items-center gap-x-4 gap-y-1.5`},BA={key:2,class:`py-6 text-center text-sm text-muted-foreground`},VA={class:`flex items-start justify-between gap-2`},HA=`Glob pattern — matches like a shell wildcard (*, ?, [...])`,UA=P({__name:`UsageView`,setup(e){let t=dT(),n=W(()=>t.usage),{now:r,start:i,stop:a}=Jk();Qi(i),na(a);let o=W(()=>{let e={};for(let n of t.overview?.groups??[])e[n.name]=n.memberCount;return e});function s(e){return(e.groups??(e.groupName===void 0?[]:[e.groupName])).join(`, `)}function c(e){let t=o.value[e.id];return t===void 0?``:String(t)}let{usageQuery:l}=n_(yO()),{query:u,normalized:d,hasQuery:f}=gD(l),p=W(()=>{let e=n.value?.groups??[];if(!f.value)return e;let t=n.value?.users??[];return e.filter(e=>cA(e,t,d.value))}),m=W(()=>f.value?p.value.filter(e=>!aA(e,d.value)).map(e=>e.id):[]);function h(e){let t=n.value?.users??[];return!f.value||aA(e,d.value)?oA(e,t):sA(e,t,d.value)}let g=W(()=>n.value?.groups.length?f.value?`no groups match "${u.value}"`:`none`:`none configured`),_=W(()=>{let e=n.value?.users??[];if(!f.value)return e;let t=n.value?.groups??[],r=new Set(t.filter(e=>aA(e,d.value)).map(e=>e.id));return e.filter(e=>iA(e,d.value)||(e.groups??[e.groupName]).some(e=>e!==void 0&&r.has(e)))}),v=W(()=>n.value?.users.length?f.value?`no users match "${u.value}"`:`none`:`none configured`),y=W(()=>Gk(`Name`,`Members`,c,r.value)),b=j([]),x=qE({get data(){return p.value},get columns(){return y.value},getCoreRowModel:RE(),getSortedRowModel:zE(),onSortingChange:e=>aD(e,b),state:{get sorting(){return b.value}}}),S=W(()=>x.getRowModel().rows),C=new Set([`id`,`secondary`,`reqDay`,`costDay`]),w=W(()=>x.getHeaderGroups()[0].headers.filter(e=>C.has(e.column.id))),ee=Zt({manuallyExpanded:new Set,manuallyCollapsed:new Set}),te=W(()=>EO(ee,f.value,m.value));function T(e){DO(ee,e,te.value.has(e))}let ne=W({get:()=>Array.from(te.value),set:e=>{let t=new Set(e);for(let e of te.value)t.has(e)||T(e);for(let e of t)te.value.has(e)||T(e)}});Dr(u,e=>{e.trim()===``&&OO(ee)});function re(e){return/[*?[]/.test(e)}function ie(e){return e.id.startsWith(`cost`)?`${wD(e.used)} / ${wD(e.limit)}`:`${TD(e.used)} / ${TD(e.limit)}`}function E(e,t){let n=Ek(t),r=Dk(e.costPerMonthMicroUsd,n);return r===null?{text:`not enough data yet`,willExceed:!1}:{text:wD(r),willExceed:Ok(r,e.limits?.costPerMonthUSD).willExceed}}let ae=W(()=>Gk(`Name`,`Group`,s,r.value)),oe=j([]),se=qE({get data(){return _.value},get columns(){return ae.value},getCoreRowModel:RE(),getSortedRowModel:zE(),onSortingChange:e=>aD(e,oe),state:{get sorting(){return oe.value}}});function ce(){return nA(se.getRowModel().rows.map(e=>e.original),`users`,s,r.value)}function D(){return nA(S.value.map(e=>e.original),`groups`,c,r.value)}return(e,t)=>(L(),R(`div`,lA,[V(sD,{modelValue:M(u),"onUpdate:modelValue":t[0]||=e=>un(u)?u.value=e:null,placeholder:`Filter users or groups`,class:`max-w-sm`},null,8,[`modelValue`]),n.value?(L(),z(M(Jw),{key:0},{default:N(()=>[V(M(Zw),null,{default:N(()=>[V(M(Qw),null,{default:N(()=>[...t[3]||=[H(`Total`,-1)]]),_:1}),V(M(Xw),null,{default:N(()=>[...t[4]||=[H(`Usage summed across every user and group combined.`,-1)]]),_:1})]),_:1}),V(M(Yw),{class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-5`},{default:N(()=>[B(`div`,null,[t[5]||=B(`p`,{class:`text-muted-foreground`},`Requests/day`,-1),B(`p`,uA,[V(ak,{value:n.value.total.requestsPerDay},null,8,[`value`])])]),B(`div`,null,[t[6]||=B(`p`,{class:`text-muted-foreground`},`Rejected/day`,-1),B(`p`,{class:O([`text-lg font-semibold tabular-nums`,n.value.total.rejectionsPerDay>0?`text-destructive`:void 0])},[V(ak,{value:n.value.total.rejectionsPerDay},null,8,[`value`])],2)]),B(`div`,null,[t[7]||=B(`p`,{class:`text-muted-foreground`},`Tokens in/day`,-1),B(`p`,dA,[V(ak,{value:n.value.total.tokensInPerDay},null,8,[`value`])])]),B(`div`,null,[t[8]||=B(`p`,{class:`text-muted-foreground`},`Tokens out/day`,-1),B(`p`,fA,[V(ak,{value:n.value.total.tokensOutPerDay},null,8,[`value`])])]),B(`div`,null,[t[9]||=B(`p`,{class:`text-muted-foreground`},`Cost/day`,-1),B(`p`,pA,k(M(wD)(n.value.total.costPerDayMicroUsd)),1)])]),_:1})]),_:1})):U(``,!0),n.value?(L(),z(Pk,{key:1,"mtd-micros":n.value.total.costPerMonthMicroUsd,limits:n.value.total.limits,now:M(r)},null,8,[`mtd-micros`,`limits`,`now`])):U(``,!0),V(M(Jw),null,{default:N(()=>[V(M(Zw),null,{default:N(()=>[B(`div`,mA,[B(`div`,null,[V(M(Qw),null,{default:N(()=>[...t[10]||=[H(`Groups`,-1)]]),_:1}),V(M(Xw),null,{default:N(()=>[...t[11]||=[H(`Expand a group to see its member users' own usage.`,-1)]]),_:1})]),V(zk,{filename:`usage-groups.csv`,build:D})])]),_:1}),V(M(Yw),null,{default:N(()=>[S.value.length?(L(),R(`div`,hA,[(L(!0),R(I,null,ha(w.value,e=>(L(),z(YE,{key:e.id,header:e},null,8,[`header`]))),128))])):U(``,!0),S.value.length?(L(),z(M(SO),{key:1,modelValue:ne.value,"onUpdate:modelValue":t[1]||=e=>ne.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:N(()=>[(L(!0),R(I,null,ha(S.value,e=>(L(),z(M(wO),{key:e.original.id,value:e.original.id},{default:N(()=>[B(`div`,gA,[V(xO,{class:`shrink-0 py-2.5 font-medium`,label:e.original.id,scope:`group:${e.original.id}`},null,8,[`label`,`scope`]),V(M(TO),{"header-class":`flex-1`},{default:N(()=>[B(`span`,_A,`Group `+k(e.original.id)+` details`,1),B(`span`,vA,[B(`span`,yA,k(c(e.original)||`0`)+` members`,1),B(`span`,bA,[e.original.storeDown?(L(),R(I,{key:0},[H(`?`)],64)):(L(),z(ak,{key:1,value:e.original.requestsPerDay},null,8,[`value`])),t[12]||=H(` req/day `,-1)]),B(`span`,xA,k(e.original.storeDown?`?`:M(wD)(e.original.costPerDayMicroUsd))+`/day `,1)])]),_:2},1024)]),V(M(CO),null,{default:N(()=>[B(`dl`,SA,[B(`div`,null,[B(`dt`,{class:`text-xs text-muted-foreground`,title:HA},`Providers`),B(`dd`,null,[e.original.providers?.length?(L(),R(`div`,CA,[(L(!0),R(I,null,ha(e.original.providers,e=>(L(),z(M(_D),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:N(()=>[H(k(e),1)]),_:2},1024))),128))])):(L(),R(`span`,wA,`All providers`))])]),B(`div`,null,[B(`dt`,{class:`text-xs text-muted-foreground`,title:HA},`Models`),B(`dd`,null,[e.original.models?.length?(L(),R(`div`,TA,[(L(!0),R(I,null,ha(e.original.models,e=>(L(),R(I,{key:e},[re(e)?(L(),z(M(_D),{key:1,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:N(()=>[H(k(e),1)]),_:2},1024)):(L(),z(tO,{key:0,id:e},null,8,[`id`]))],64))),128))])):(L(),R(`span`,EA,`All models`))])]),B(`div`,null,[B(`dt`,{class:`text-xs text-muted-foreground`,title:HA},`MCP servers`),B(`dd`,null,[e.original.mcpServers?.length?(L(),R(`div`,DA,[(L(!0),R(I,null,ha(e.original.mcpServers,e=>(L(),z(M(_D),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:N(()=>[H(k(e),1)]),_:2},1024))),128))])):(L(),R(`span`,OA,`All MCP servers`))])]),B(`div`,null,[B(`dt`,{class:`text-xs text-muted-foreground`,title:HA},`Agents`),B(`dd`,null,[e.original.agents?.length?(L(),R(`div`,kA,[(L(!0),R(I,null,ha(e.original.agents,e=>(L(),z(M(_D),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:N(()=>[H(k(e),1)]),_:2},1024))),128))])):(L(),R(`span`,AA,`All agents`))])])]),B(`dl`,jA,[B(`div`,null,[t[13]||=B(`dt`,{class:`text-xs text-muted-foreground`},`Limits`,-1),B(`dd`,null,k(M(BD)(e.original.limits)),1)]),B(`div`,null,[t[14]||=B(`dt`,{class:`text-xs text-muted-foreground`},`req/min`,-1),B(`dd`,MA,[e.original.storeDown?(L(),R(I,{key:0},[H(`?`)],64)):(L(),z(ak,{key:1,value:e.original.requestsPerMinute},null,8,[`value`]))])]),B(`div`,null,[t[15]||=B(`dt`,{class:`text-xs text-muted-foreground`},`rejected/day`,-1),B(`dd`,{class:O([`tabular-nums`,!e.original.storeDown&&e.original.rejectionsPerDay>0?`text-destructive`:void 0])},[e.original.storeDown?(L(),R(I,{key:0},[H(`?`)],64)):(L(),z(ak,{key:1,value:e.original.rejectionsPerDay},null,8,[`value`]))],2)]),B(`div`,null,[t[16]||=B(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/day`,-1),B(`dd`,NA,[e.original.storeDown?(L(),R(I,{key:0},[H(`?`)],64)):(L(),z(ak,{key:1,value:e.original.tokensInPerDay},null,8,[`value`]))])]),B(`div`,null,[t[17]||=B(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/day`,-1),B(`dd`,PA,[e.original.storeDown?(L(),R(I,{key:0},[H(`?`)],64)):(L(),z(ak,{key:1,value:e.original.tokensOutPerDay},null,8,[`value`]))])]),B(`div`,null,[t[18]||=B(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/month`,-1),B(`dd`,FA,[e.original.storeDown?(L(),R(I,{key:0},[H(`?`)],64)):(L(),z(ak,{key:1,value:e.original.tokensInPerMonth},null,8,[`value`]))])]),B(`div`,null,[t[19]||=B(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/month`,-1),B(`dd`,IA,[e.original.storeDown?(L(),R(I,{key:0},[H(`?`)],64)):(L(),z(ak,{key:1,value:e.original.tokensOutPerMonth},null,8,[`value`]))])]),B(`div`,null,[t[20]||=B(`dt`,{class:`text-xs text-muted-foreground`},`cost/month`,-1),B(`dd`,LA,k(e.original.storeDown?`?`:M(wD)(e.original.costPerMonthMicroUsd)),1)]),B(`div`,null,[t[21]||=B(`dt`,{class:`text-xs text-muted-foreground`},`cost/month (proj.)`,-1),B(`dd`,{class:O([`tabular-nums`,!e.original.storeDown&&E(e.original,M(r)).willExceed?`text-destructive`:void 0]),title:!e.original.storeDown&&E(e.original,M(r)).willExceed?`Projected to exceed the configured cost/month limit`:void 0},k(e.original.storeDown?`?`:E(e.original,M(r)).text),11,RA)])]),M(Tk)(e.original).length?(L(),R(`div`,zA,[(L(!0),R(I,null,ha(M(Tk)(e.original),e=>(L(),R(`span`,{key:e.id,class:`inline-flex items-center gap-1.5 text-xs text-muted-foreground`},[H(k(M(Ck)[e.id])+` `,1),V(Vk,{ratio:e.ratio,label:M(Ck)[e.id],"value-text":ie(e)},null,8,[`ratio`,`label`,`value-text`])]))),128))])):U(``,!0),t[22]||=B(`p`,{class:`mb-1.5 text-xs font-medium text-muted-foreground`},`Members`,-1),V(Kk,{"id-label":`Name`,"secondary-column-label":`Group`,entries:h(e.original),"secondary-value":s,now:M(r)},null,8,[`entries`,`now`])]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):(L(),R(`p`,BA,k(g.value),1))]),_:1})]),_:1}),V(M(Jw),null,{default:N(()=>[V(M(Zw),null,{default:N(()=>[B(`div`,VA,[V(M(Qw),null,{default:N(()=>[...t[23]||=[H(`Users`,-1)]]),_:1}),V(zk,{filename:`usage-users.csv`,build:ce})])]),_:1}),V(M(Yw),null,{default:N(()=>[V(Kk,{"id-label":`Name`,"secondary-column-label":`Group`,entries:_.value,"secondary-value":s,"empty-message":v.value,now:M(r),sorting:oe.value,"onUpdate:sorting":t[2]||=e=>oe.value=e},null,8,[`entries`,`empty-message`,`now`,`sorting`])]),_:1})]),_:1})]))}}),WA=[`providers`,`usage`,`charts`,`targets`,`events`];function GA(e,t,n){let r=e.startsWith(`#`)?e.slice(1):e;return t.includes(r)?r:n}function KA(e){return`#${e}`}var qA=`providers`;function JA(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);return{tab:GA(r,WA,qA),query:new URLSearchParams(i)}}function YA(e,t){let n=Object.entries(t).filter(([,e])=>e!==``);return n.length===0?KA(e):`${KA(e)}?${new URLSearchParams(n).toString()}`}var XA=[`hour`,`day`,`month`],ZA=[`requests`,`tokens`,`cost`,`models`],QA=[`req`,`tokin`,`tokout`,`cost`],$A=/^(total|user:.+|group:.+|model:.+)$/;function ej(e){let t={},n=e.get(`window`);n&&XA.includes(n)&&(t.window=n);let r=e.get(`tab`);r&&ZA.includes(r)&&(t.tab=r);let i=e.get(`metric`);i&&QA.includes(i)&&(t.metric=i);let a=e.get(`scope`);a&&$A.test(a)&&(t.scope=a);let o=e.get(`filter`);return o&&(t.filter=o),t}function tj(e){let t=e.get(`q`);return t?{q:t}:{}}function nj(e){let t={},n=e.get(`kind`),r=e.get(`user`);return n&&(t.kind=n),r&&(t.user=r),t}var rj=`hour`,ij=`requests`,aj=`req`,oj=`total`,sj=``;function cj(){let e=yO(),t=vO(),n=JD();function r(r){let{tab:i,query:a}=JA(r);if(e.activeTab=i,i===`charts`){let e=ej(a);t.setSelection({window:e.window??rj,tab:e.tab??ij,modelMetric:e.metric??aj,scope:e.scope??oj,modelFilter:e.filter??sj})}else if(i===`usage`){let t=tj(a);e.usageQuery=t.q??``}else if(i===`events`){let e=nj(a);n.setKindFilter(e.kind??``),n.setUserFilter(e.user??``)}}let i=typeof window<`u`;i&&r(window.location.hash),Dr(W(()=>{if(e.activeTab===`charts`){let n={};return t.window!==rj&&(n.window=t.window),t.tab!==ij&&(n.tab=t.tab),t.modelMetric!==aj&&(n.metric=t.modelMetric),t.scope!==oj&&(n.scope=t.scope),t.modelFilter!==sj&&(n.filter=t.modelFilter),YA(e.activeTab,n)}if(e.activeTab===`usage`)return YA(e.activeTab,e.usageQuery?{q:e.usageQuery}:{});if(e.activeTab===`events`){let t={};return n.kindFilter&&(t.kind=n.kindFilter),n.userFilter&&(t.user=n.userFilter),YA(e.activeTab,t)}return YA(e.activeTab,{})}),e=>{i&&window.location.hash!==e&&window.history.replaceState(null,``,e)});function a(){r(window.location.hash)}i&&(Qi(()=>window.addEventListener(`hashchange`,a)),na(()=>window.removeEventListener(`hashchange`,a)))}var lj=(function(){let e=typeof document<`u`&&document.createElement(`link`).relList;return e&&e.supports&&e.supports(`modulepreload`)?`modulepreload`:`preload`})(),uj=function(e){return`/admin/`+e},dj={},fj=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=uj(t,n),t=s(t),t in dj)return;dj[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`:lj,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)})},pj={class:`flex w-full flex-col gap-6 px-4 py-8 sm:px-6 lg:px-8`},mj={class:`flex flex-col gap-1`},hj={class:`flex items-center justify-between gap-2`},gj={key:0,class:`flex items-center gap-1.5 text-sm text-muted-foreground`},_j=`https://github.com/lukaszraczylo/traefik-llmgateway`,vj=mu(P({__name:`App`,setup(e){let t=Ri(()=>fj(()=>import(`./ChartsView-L9LBTr3e.js`),[])),n=iT(),r=dT(),i=yO();cj();let a=W(()=>{if(r.error)return`refresh failed: ${r.error}`;if(r.lastUpdated){let e=r.overview?.replica;return`last updated ${r.lastUpdated.toLocaleTimeString()}${e?` · replica ${e}`:``}`}return`loading...`});return Qi(()=>{r.startPolling()}),(e,o)=>{let s=la(`FontAwesomeIcon`);return L(),R(`div`,pj,[B(`header`,mj,[B(`div`,hj,[o[1]||=B(`h1`,{class:`text-xl font-semibold tracking-tight`},`LLM Gateway — Admin`,-1),V(M(Gw),{as:`a`,href:_j,target:`_blank`,rel:`noopener noreferrer`,variant:`ghost`,size:`icon`,"aria-label":`GitHub repository`,class:`text-muted-foreground hover:text-foreground`},{default:N(()=>[V(s,{icon:M(r_),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`])]),_:1})]),M(n).isAuthenticated?(L(),R(`p`,gj,[M(r).error?(L(),z(s,{key:0,icon:M(u_),class:`size-3.5 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):U(``,!0),B(`span`,{class:O(M(r).error?`text-destructive`:void 0)},k(a.value),3)])):U(``,!0)]),M(n).isAuthenticated?(L(),z(CT,{key:0,warnings:M(r).overview?.warnings??[],"warnings-dropped":M(r).overview?.warningsDropped},null,8,[`warnings`,`warnings-dropped`])):U(``,!0),M(n).isAuthenticated?(L(),z(M(gk),{key:2,modelValue:M(i).activeTab,"onUpdate:modelValue":o[0]||=e=>M(i).activeTab=e},{default:N(()=>[V(M(vk),null,{default:N(()=>[V(M(yk),{value:`providers`},{default:N(()=>[...o[2]||=[H(`Providers`,-1)]]),_:1}),V(M(yk),{value:`usage`},{default:N(()=>[...o[3]||=[H(`Usage`,-1)]]),_:1}),V(M(yk),{value:`charts`},{default:N(()=>[...o[4]||=[H(`Charts`,-1)]]),_:1}),V(M(yk),{value:`targets`},{default:N(()=>[...o[5]||=[H(`MCP & Agents`,-1)]]),_:1}),V(M(yk),{value:`events`},{default:N(()=>[...o[6]||=[H(`Events`,-1)]]),_:1})]),_:1}),V(M(_k),{value:`providers`},{default:N(()=>[V(tk)]),_:1}),V(M(_k),{value:`usage`},{default:N(()=>[V(UA)]),_:1}),V(M(_k),{value:`charts`},{default:N(()=>[V(M(t))]),_:1}),V(M(_k),{value:`targets`},{default:N(()=>[V(hk)]),_:1}),V(M(_k),{value:`events`},{default:N(()=>[V($D)]),_:1})]),_:1},8,[`modelValue`])):(L(),z(bT,{key:1}))])}}}));vj.use(Vg()),vj.component(`FontAwesomeIcon`,Cg),vj.mount(`#app`);export{Dr as $,Zw as A,R as B,dD as C,oD as D,sD as E,I as F,$n as G,V as H,W as I,na as J,ta as K,B as L,Jw as M,Gw as N,dT as O,m_ as P,ic as Q,z as R,mD as S,cD as T,P as U,H as V,G as W,ha as X,L as Y,la as Z,wD as _,yk as a,A as at,gD as b,ak as c,k as ct,gO as d,N as et,hO as f,ED as g,VD as h,zk as i,dn as it,Yw as j,Qw as k,xO as l,tO as m,iA as n,un as nt,vk as o,M as ot,vO as p,Qi as q,rA as r,j as rt,gk as s,ge as st,cA as t,on as tt,fO as u,TD as v,lD as w,hD as x,_D as y,U as z};",
+			"aW1wb3J0e0V0IGFzIGUsSXQgYXMgdCxMdCBhcyBuLE90IGFzIHIsUnIgYXMgaSxkaSBhcyBhLGt0IGFzIG8sbyBhcyBzLHJyIGFzIGMsd24gYXMgbCx6dCBhcyB1fWZyb20iLi9uYXYtRHpiME9UTl8uanMiO2ltcG9ydHtkLHUgYXMgZn1mcm9tIi4vQ2FyZERlc2NyaXB0aW9uLUlkT3QzMTdjLmpzIjt2YXIgcD11KHtfX25hbWU6YENsYW1wZWRSYW5nZU5vdGljZWAscHJvcHM6e3dpbmRvdzp7fSxzcGFuOnt9fSxzZXR1cCh1KXtsZXQgcD11LG09ZSgoKT0+cyhwLndpbmRvdyxwLnNwYW4pKTtyZXR1cm4oZSxzKT0+bS52YWx1ZT8obCgpLHIoaShkKSx7a2V5OjAsdmFyaWFudDpgd2FybmB9LHtkZWZhdWx0OmMoKCk9PltuKGkoZiksbnVsbCx7ZGVmYXVsdDpjKCgpPT5bdChhKG0udmFsdWUpLDEpXSksXzoxfSldKSxfOjF9KSk6byhgYCwhMCl9fSk7ZXhwb3J0e3AgYXMgdH07",
 		),
 	},
-	"index-BSsefi4h.css": {
+	"CompactNumber-B1ihQZH7.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"aW1wb3J0e0F0IGFzIGUsRHQgYXMgdCxFdCBhcyBuLGRpIGFzIHIsd24gYXMgaSx6dCBhcyBhfWZyb20iLi9uYXYtRHpiME9UTl8uanMiO2ltcG9ydHtjIGFzIG8saSBhcyBzfWZyb20iLi9iYWRnZS1uczBqOE9Vci5qcyI7dmFyIGM9W2B0aXRsZWBdLGw9eyJhcmlhLWhpZGRlbiI6YHRydWVgfSx1PXtjbGFzczpgc3Itb25seWB9LGQ9YSh7X19uYW1lOmBDb21wYWN0TnVtYmVyYCxwcm9wczp7dmFsdWU6e319LHNldHVwKGEpe2xldCBkPWEsZj1uKCgpPT5zKGQudmFsdWUpKSxwPW4oKCk9Pm8oZC52YWx1ZSkpO3JldHVybihuLGEpPT4oaSgpLGUoYHNwYW5gLHt0aXRsZTpwLnZhbHVlfSxbdChgc3BhbmAsbCxyKGYudmFsdWUpLDEpLHQoYHNwYW5gLHUscihwLnZhbHVlKSwxKV0sOCxjKSl9fSk7ZXhwb3J0e2QgYXMgdH07",
+		),
+	},
+	"ConfigPage-BPgQjjSB.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{An as e,At as t,C as n,Dt as r,Er as i,Et as a,It as o,Jn as s,Lt as c,Mn as l,Or as u,Ot as d,Rr as f,S as p,Sn as m,W as h,Z as g,_,ar as v,b as y,di as b,gt as x,h as S,kt as C,lt as w,ot as T,rr as E,si as D,t as O,v as k,vn as A,wn as j,x as M,y as N,zt as P}from"./nav-Dzb0OTN_.js";import{O as ee,d as F,n as te,t as ne,u as I}from"./CardDescription-IdOt317c.js";import{n as re,r as ie,t as ae}from"./tabs-BbGJyCRr.js";import{a as L,i as R,n as z,o as B,r as V,s as H,u as oe}from"./index-BiTQ_gCE.js";import{t as se}from"./clipboard-B73fZ0c1.js";import{t as ce}from"./consumers-wB-itjnf.js";var le={class:`flex flex-col gap-1.5`},ue={class:`flex items-center justify-between gap-2`},de={key:0,class:`text-xs font-medium text-muted-foreground`},U=P({__name:`SnippetBlock`,props:{text:{},label:{}},setup(e){let n=e,i=s(`pre`),a=u(`idle`),d;async function p(){a.value=await se(n.text,i.value??void 0),clearTimeout(d),d=setTimeout(()=>{a.value=`idle`},1500)}let _={idle:`Copy`,copied:`Copied`,selected:`Selected — press ⌘/Ctrl+C`,failed:`Copy failed`};return m(()=>clearTimeout(d)),(n,i)=>{let s=l(`FontAwesomeIcon`);return j(),t(`div`,le,[r(`div`,ue,[e.label?(j(),t(`span`,de,b(e.label),1)):C(``,!0),c(f(te),{type:`button`,variant:`outline`,size:`sm`,class:`ml-auto`,onClick:p},{default:E(()=>[c(s,{icon:a.value===`idle`?f(g):a.value===`failed`?f(T):f(h),class:D([`size-3.5`,a.value===`failed`?`text-destructive`:void 0]),"aria-hidden":`true`},null,8,[`icon`,`class`]),o(` `+b(_[a.value]),1)]),_:1})]),r(`pre`,{ref:`pre`,class:`overflow-x-auto rounded-md border bg-muted p-3 font-mono text-xs select-text whitespace-pre`},b(e.text),513)])}}}),fe=`  `,pe=/^[A-Za-z_][A-Za-z0-9._-]*$/,me=new Set([`true`,`false`,`yes`,`no`,`y`,`n`,`on`,`off`,`null`,`nil`,`nan`,`inf`]);function he(e){return!pe.test(e)||me.has(e.toLowerCase())}function ge(e){return he(e)}var _e=RegExp(`[\\u007f\\u0080-\\u009f\u2028\u2029]`,`g`);function ve(e){return e.replace(_e,e=>{let t=e.codePointAt(0);return t<=255?`\\x${t.toString(16).padStart(2,`0`)}`:`\\u${t.toString(16).padStart(4,`0`)}`})}function W(e){return ge(e)?ve(JSON.stringify(e)):e}function G(e){return e===null?`null`:typeof e==`boolean`||typeof e==`number`?String(e):he(e)?ve(JSON.stringify(e)):e}function ye(e){return e.length===0?`[]`:`[${e.map(e=>G(e)).join(`, `)}]`}function be(e){return e.length===0?`{}`:`{ ${e.map(([e,t])=>`${W(e)}: ${G(t)}`).join(`, `)} }`}function xe(e){return typeof e==`object`&&!!e&&!Array.isArray(e)}function K(e){return e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`}function Se(e,t){let n=fe.repeat(t),r=[];for(let[i,a]of Object.entries(e)){if(a===void 0)continue;let e=`${n}${W(i)}:`;if(K(a))r.push(`${e} ${G(a)}`);else if(Array.isArray(a)){if(a.every(K))r.push(`${e} ${ye(a)}`);else{r.push(e);for(let e of a)r.push(`${n}${fe}- ${K(e)?G(e):JSON.stringify(e)}`)}}else xe(a)&&(Object.keys(a).filter(e=>a[e]!==void 0).length===0?r.push(`${e} {}`):(r.push(e),r.push(...Se(a,t+1))))}return r}function Ce(e,t=0){return Se(e,t).join(`
`)}function we(e,t){let n=t,r=[`spec`,`plugin`,`llmgateway`,...e];for(let e=r.length-1;e>=0;e--)n={[r[e]]:n};return Ce(n)}function q(e){if(e===null||typeof e==`string`||typeof e==`number`||typeof e==`boolean`)return e;if(Array.isArray(e))return e.map(q);if(typeof e==`object`){let t={};for(let[n,r]of Object.entries(e))t[n]=q(r);return t}return String(e)}var Te=/^[a-zA-Z0-9._-]+$/;function Ee(e){return Te.test(e)}function J(e){return e.trim()!==``}function Y(e){return Number.isFinite(e)&&e>=0}function De(e){return Number.isInteger(e)&&e>=0}function Oe(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 ke=[`requestsPerMinute`,`requestsPerDay`,`tokensPerDay`,`tokensPerMonth`,`costPerDayUSD`,`costPerMonthUSD`];function X(e){let t=[];for(let n of ke){let r=e[n];r&&t.push([n,r])}return t}function Ae(e,t){let n={};for(let[e,r]of X(t))n[e]=r;return we([`groups`,e],{limits:n})}function Z(e){return JSON.stringify(e)}function Q(e){return`[${e.map(Z).join(`, `)}]`}function $(e){return`{${X(e).map(([e,t])=>`${Z(e)}: ${t}`).join(`, `)}}`}function je(e){return`"limits": ${$(e)}`}function Me(e,t){return we([`groups`,e],{providers:t.providers,models:t.models,mcpServers:t.mcpServers,agents:t.agents})}function Ne(e){let t=[];return e.providers.length>0&&t.push(`"providers": ${Q(e.providers)}`),e.models.length>0&&t.push(`"models": ${Q(e.models)}`),t.join(`, `)}function Pe(e,t){let n=[];t.contextTokens!==void 0&&n.push([`contextTokens`,t.contextTokens]),t.free!==void 0&&n.push([`free`,t.free]);let r=be(n);return[`spec:`,`  plugin:`,`    llmgateway:`,`      modelMeta:`,`        ${JSON.stringify(e)}: ${r}`].join(`
`)}function Fe(e,t){let n=be([[`inputPerM`,t.inputPerM],[`outputPerM`,t.outputPerM]]);return[`spec:`,`  plugin:`,`    llmgateway:`,`      pricing:`,`        ${W(e)}: ${n}`].join(`
`)}var Ie=`sk-llmgw-REPLACE_ME`;function Le(){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 Re(e){let t=[`"name": ${Z(e.name)}`,`"apiKey": ${Z(e.apiKey)}`];return e.group&&t.push(`"group": ${Z(e.group)}`),e.groups&&e.groups.length>0&&t.push(`"groups": ${Q(e.groups)}`),e.providers&&e.providers.length>0&&t.push(`"providers": ${Q(e.providers)}`),e.models&&e.models.length>0&&t.push(`"models": ${Q(e.models)}`),e.limits&&X(e.limits).length>0&&t.push(`"limits": ${$(e.limits)}`),e.admin&&t.push(`"admin": ${G(!0)}`),`{${t.join(`, `)}}`}var ze={class:`flex flex-col gap-4`},Be={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},Ve={class:`flex flex-col gap-1`},He={class:`flex flex-col gap-1`},Ue={id:`grant-target-name-label`,class:`text-xs font-medium text-muted-foreground`},We={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},Ge={class:`flex flex-col gap-1`},Ke={class:`flex flex-col gap-1`},qe={class:`flex flex-col gap-1`},Je={class:`flex flex-col gap-1`},Ye={key:2,class:`text-sm text-muted-foreground`},Xe=P({__name:`GrantForm`,props:{groupNames:{},userNames:{}},setup(n){let i=n,s=u(`group`),l=u(``),p=u(``),m=u(``),h=u(``),g=u(``);function _(e){let t=new Set;for(let n of e.split(`,`)){let e=n.trim();e&&t.add(e)}return Array.from(t)}let v=a(()=>_(p.value)),y=a(()=>_(m.value)),S=a(()=>_(h.value)),w=a(()=>_(g.value)),T=a(()=>s.value===`group`?i.groupNames:i.userNames),D=a(()=>s.value===`group`?Ee(l.value.trim()):J(l.value)),O=a(()=>s.value===`user`?Oe(v.value,y.value):null),k=a(()=>v.value.length===0&&y.value.length===0&&S.value.length===0&&w.value.length===0),A=a(()=>!D.value||O.value||k.value?null:s.value===`group`?Me(l.value.trim(),{providers:v.value,models:y.value,mcpServers:S.value,agents:w.value}):Ne({providers:v.value,models:y.value})||null);return(n,i)=>(j(),t(`div`,ze,[r(`div`,Be,[r(`div`,Ve,[i[8]||=r(`label`,{id:`grant-target-kind-label`,class:`text-xs font-medium text-muted-foreground`},`Target`,-1),c(f(B),{"model-value":s.value,"onUpdate:modelValue":i[0]||=e=>s.value=e},{default:E(()=>[c(f(V),{"aria-labelledby":`grant-target-kind-label`},{default:E(()=>[c(f(z))]),_:1}),c(f(L),null,{default:E(()=>[c(f(R),{value:`group`},{default:E(()=>[...i[6]||=[o(`Group`,-1)]]),_:1}),c(f(R),{value:`user`},{default:E(()=>[...i[7]||=[o(`User (personal grant, existing users.json entry)`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`])]),r(`div`,He,[r(`label`,Ue,b(s.value===`group`?`Group name`:`User name`),1),c(f(B),{"model-value":l.value,"onUpdate:modelValue":i[1]||=e=>l.value=String(e)},{default:E(()=>[c(f(V),{"aria-labelledby":`grant-target-name-label`},{default:E(()=>[c(f(z),{placeholder:`Select…`})]),_:1}),c(f(L),null,{default:E(()=>[(j(!0),t(x,null,e(T.value,e=>(j(),d(f(R),{key:e,value:e},{default:E(()=>[o(b(e),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),r(`div`,We,[r(`div`,Ge,[i[9]||=r(`label`,{for:`grant-providers`,class:`text-xs font-medium text-muted-foreground`},`Providers (comma-separated, empty = all)`,-1),c(f(H),{id:`grant-providers`,modelValue:p.value,"onUpdate:modelValue":i[2]||=e=>p.value=e,placeholder:`anthropic, openai`},null,8,[`modelValue`])]),r(`div`,Ke,[i[10]||=r(`label`,{for:`grant-models`,class:`text-xs font-medium text-muted-foreground`},`Models (comma-separated, empty = all)`,-1),c(f(H),{id:`grant-models`,modelValue:m.value,"onUpdate:modelValue":i[3]||=e=>m.value=e,placeholder:`anthropic/claude-sonnet-5`},null,8,[`modelValue`])]),s.value===`group`?(j(),t(x,{key:0},[r(`div`,qe,[i[11]||=r(`label`,{for:`grant-mcp`,class:`text-xs font-medium text-muted-foreground`},`MCP servers (comma-separated, empty = all)`,-1),c(f(H),{id:`grant-mcp`,modelValue:h.value,"onUpdate:modelValue":i[4]||=e=>h.value=e,placeholder:`fetch, weather`},null,8,[`modelValue`])]),r(`div`,Je,[i[12]||=r(`label`,{for:`grant-agents`,class:`text-xs font-medium text-muted-foreground`},`Agents (comma-separated, empty = all)`,-1),c(f(H),{id:`grant-agents`,modelValue:g.value,"onUpdate:modelValue":i[5]||=e=>g.value=e,placeholder:`agentkit`},null,8,[`modelValue`])])],64)):C(``,!0)]),O.value?(j(),d(f(F),{key:0,variant:`destructive`},{default:E(()=>[c(f(I),null,{default:E(()=>[o(b(O.value),1)]),_:1})]),_:1})):C(``,!0),A.value?(j(),d(U,{key:1,label:s.value===`group`?`Paste into middleware.yaml`:`Merge into ${l.value}’s users.json line`,text:A.value},null,8,[`label`,`text`])):(j(),t(`p`,Ye,`Pick a target and at least one list to build a snippet.`))]))}}),Ze={class:`flex flex-col gap-4`},Qe={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},$e={class:`flex flex-col gap-1`},et={class:`flex flex-col gap-1`},tt={id:`limits-target-name-label`,class:`text-xs font-medium text-muted-foreground`},nt={class:`grid grid-cols-1 gap-3 sm:grid-cols-3`},rt=[`for`],it={key:0},at={key:1},ot={key:2,class:`text-sm text-muted-foreground`},st=P({__name:`LimitsForm`,props:{groupNames:{},userNames:{}},setup(n){let s=n,l=u(`group`),p=u(``),m=new Set([`requestsPerMinute`,`requestsPerDay`,`tokensPerDay`,`tokensPerMonth`]);function h(e,t){return m.has(e)?De(t):Y(t)}let g=[{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)`}],_=i({requestsPerMinute:``,requestsPerDay:``,tokensPerDay:``,tokensPerMonth:``,costPerDayUSD:``,costPerMonthUSD:``}),v=a(()=>l.value===`group`?s.groupNames:s.userNames),y=a(()=>g.filter(({key:e})=>_[e].trim()!==``&&!h(e,Number(_[e]))).map(e=>e.label)),S=a(()=>g.filter(({key:e})=>m.has(e)&&_[e].trim()!==``&&!h(e,Number(_[e]))).map(e=>e.label)),w=a(()=>g.filter(({key:e})=>!m.has(e)&&_[e].trim()!==``&&!h(e,Number(_[e]))).map(e=>e.label)),T=a(()=>{let e={};for(let{key:t}of g){let n=Number(_[t]);_[t].trim()!==``&&h(t,n)&&n>0&&(e[t]=n)}return e}),D=a(()=>l.value===`group`?Ee(p.value.trim()):J(p.value)),O=a(()=>!D.value||y.value.length>0||Object.keys(T.value).length===0?null:l.value===`group`?Ae(p.value.trim(),T.value):je(T.value));return(n,i)=>(j(),t(`div`,Ze,[r(`div`,Qe,[r(`div`,$e,[i[4]||=r(`label`,{id:`limits-target-kind-label`,class:`text-xs font-medium text-muted-foreground`},`Target`,-1),c(f(B),{"model-value":l.value,"onUpdate:modelValue":i[0]||=e=>l.value=e},{default:E(()=>[c(f(V),{"aria-labelledby":`limits-target-kind-label`},{default:E(()=>[c(f(z))]),_:1}),c(f(L),null,{default:E(()=>[c(f(R),{value:`group`},{default:E(()=>[...i[2]||=[o(`Group`,-1)]]),_:1}),c(f(R),{value:`user`},{default:E(()=>[...i[3]||=[o(`User (existing users.json entry)`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`])]),r(`div`,et,[r(`label`,tt,b(l.value===`group`?`Group name`:`User name`),1),c(f(B),{"model-value":p.value,"onUpdate:modelValue":i[1]||=e=>p.value=String(e)},{default:E(()=>[c(f(V),{"aria-labelledby":`limits-target-name-label`},{default:E(()=>[c(f(z),{placeholder:`Select…`})]),_:1}),c(f(L),null,{default:E(()=>[(j(!0),t(x,null,e(v.value,e=>(j(),d(f(R),{key:e,value:e},{default:E(()=>[o(b(e),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),r(`div`,nt,[(j(),t(x,null,e(g,e=>r(`div`,{key:e.key,class:`flex flex-col gap-1`},[r(`label`,{for:`limits-${e.key}`,class:`text-xs font-medium text-muted-foreground`},b(e.label),9,rt),c(f(H),{id:`limits-${e.key}`,modelValue:_[e.key],"onUpdate:modelValue":t=>_[e.key]=t,type:`number`,min:`0`,step:f(m).has(e.key)?`1`:`any`,placeholder:`unset`},null,8,[`id`,`modelValue`,`onUpdate:modelValue`,`step`])])),64))]),y.value.length?(j(),d(f(F),{key:0,variant:`destructive`},{default:E(()=>[c(f(I),null,{default:E(()=>[S.value.length?(j(),t(`p`,it,`Enter a non-negative whole number for: `+b(S.value.join(`, `))+`.`,1)):C(``,!0),w.value.length?(j(),t(`p`,at,`Enter a non-negative number for: `+b(w.value.join(`, `))+`.`,1)):C(``,!0)]),_:1})]),_:1})):C(``,!0),O.value?(j(),d(U,{key:1,label:l.value===`group`?`Paste into middleware.yaml`:`Merge into ${p.value}’s users.json line`,text:O.value},null,8,[`label`,`text`])):(j(),t(`p`,ot,`Pick a target and at least one limit to build a snippet.`))]))}}),ct={class:`flex flex-col gap-4`},lt={class:`flex flex-col gap-1`},ut={class:`grid grid-cols-1 gap-3 sm:grid-cols-2 sm:items-end`},dt={class:`flex flex-col gap-1`},ft={class:`flex items-center gap-2 pb-1.5 text-sm`},pt={key:2,class:`text-sm text-muted-foreground`},mt=P({__name:`ModelMetaForm`,setup(e){let n=u(``),i=u(``),s=u(!1),l=a(()=>n.value.trim()!==``),p=a(()=>Number(i.value)),m=a(()=>i.value.trim()!==``),h=a(()=>!m.value||De(p.value)&&p.value>0),g=a(()=>!l.value||!h.value||!m.value&&!s.value?null:Pe(n.value.trim(),{contextTokens:m.value?p.value:void 0,free:s.value||void 0}));return(e,a)=>(j(),t(`div`,ct,[r(`div`,lt,[a[3]||=r(`label`,{for:`modelmeta-model-id`,class:`text-xs font-medium text-muted-foreground`},`Model id (provider/model)`,-1),c(f(H),{id:`modelmeta-model-id`,modelValue:n.value,"onUpdate:modelValue":a[0]||=e=>n.value=e,placeholder:`gx10/current`,class:`font-mono`},null,8,[`modelValue`])]),r(`div`,ut,[r(`div`,dt,[a[4]||=r(`label`,{for:`modelmeta-context`,class:`text-xs font-medium text-muted-foreground`},`Context window (tokens)`,-1),c(f(H),{id:`modelmeta-context`,modelValue:i.value,"onUpdate:modelValue":a[1]||=e=>i.value=e,type:`number`,min:`1`,step:`1`,placeholder:`131072`},null,8,[`modelValue`])]),r(`label`,ft,[v(r(`input`,{id:`modelmeta-free`,"onUpdate:modelValue":a[2]||=e=>s.value=e,type:`checkbox`,class:`size-4 rounded border-input`},null,512),[[ee,s.value]]),a[5]||=o(` Free (billed as $0 regardless of any resolved price) `,-1)])]),m.value&&!h.value?(j(),d(f(F),{key:0,variant:`destructive`},{default:E(()=>[c(f(I),null,{default:E(()=>[...a[6]||=[o(`Context window must be a positive whole number of tokens.`,-1)]]),_:1})]),_:1})):C(``,!0),g.value?(j(),d(U,{key:1,label:`Paste into middleware.yaml`,text:g.value},null,8,[`text`])):(j(),t(`p`,pt,`Enter a model id and set a context window and/or free to build a snippet.`))]))}}),ht={class:`flex flex-col gap-4`},gt={class:`flex flex-col gap-1`},_t={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},vt={class:`flex flex-col gap-1`},yt={class:`flex flex-col gap-1`},bt={key:2,class:`text-sm text-muted-foreground`},xt=P({__name:`PricingForm`,setup(n){let i=u(``),o=u(``),s=u(``),l=a(()=>i.value.trim()!==``),p=a(()=>Number(o.value)),m=a(()=>Number(s.value)),h=a(()=>o.value.trim()!==``&&Y(p.value)),g=a(()=>s.value.trim()!==``&&Y(m.value)),_=a(()=>{let e=[];return o.value.trim()!==``&&!h.value&&e.push(`Input price/MTok must be a non-negative number.`),s.value.trim()!==``&&!g.value&&e.push(`Output price/MTok must be a non-negative number.`),(h.value&&!g.value||!h.value&&g.value)&&e.push(`Set both input and output price/MTok — a one-sided override has no billing meaning.`),e}),v=a(()=>!l.value||!h.value||!g.value?null:Fe(i.value.trim(),{inputPerM:p.value,outputPerM:m.value}));return(n,a)=>(j(),t(`div`,ht,[r(`div`,gt,[a[3]||=r(`label`,{for:`pricing-model-id`,class:`text-xs font-medium text-muted-foreground`},`Model id (provider/model)`,-1),c(f(H),{id:`pricing-model-id`,modelValue:i.value,"onUpdate:modelValue":a[0]||=e=>i.value=e,placeholder:`openai/gpt-4`,class:`font-mono`},null,8,[`modelValue`])]),r(`div`,_t,[r(`div`,vt,[a[4]||=r(`label`,{for:`pricing-input`,class:`text-xs font-medium text-muted-foreground`},`Input price / MTok (USD)`,-1),c(f(H),{id:`pricing-input`,modelValue:o.value,"onUpdate:modelValue":a[1]||=e=>o.value=e,type:`number`,min:`0`,step:`any`,placeholder:`0.50`},null,8,[`modelValue`])]),r(`div`,yt,[a[5]||=r(`label`,{for:`pricing-output`,class:`text-xs font-medium text-muted-foreground`},`Output price / MTok (USD)`,-1),c(f(H),{id:`pricing-output`,modelValue:s.value,"onUpdate:modelValue":a[2]||=e=>s.value=e,type:`number`,min:`0`,step:`any`,placeholder:`1.50`},null,8,[`modelValue`])])]),_.value.length?(j(),d(f(F),{key:0,variant:`destructive`},{default:E(()=>[c(f(I),null,{default:E(()=>[(j(!0),t(x,null,e(_.value,(e,n)=>(j(),t(`p`,{key:n},b(e),1))),128))]),_:1})]),_:1})):C(``,!0),v.value?(j(),d(U,{key:1,label:`Paste into middleware.yaml`,text:v.value},null,8,[`text`])):(j(),t(`p`,bt,`Enter a model id and both prices to build a snippet.`))]))}}),St={class:`flex flex-col gap-4`},Ct={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},wt={class:`flex flex-col gap-1`},Tt={class:`flex flex-col gap-1`},Et={class:`flex flex-col gap-1`},Dt={class:`flex gap-2`},Ot={key:0,class:`text-xs text-muted-foreground`},kt={class:`flex flex-col gap-1`},At={class:`grid grid-cols-1 gap-3 sm:grid-cols-2`},jt={class:`flex flex-col gap-1`},Mt={class:`flex flex-col gap-1`},Nt={class:`flex items-center gap-2 text-sm`},Pt={key:2,class:`text-sm text-muted-foreground`},Ft=P({__name:`UserForm`,props:{groupNames:{}},setup(n){let i=n,s=u(``),l=u(Ie),p=u(``),m=u(``),h=u(``),g=u(``),_=u(!1);function y(){l.value=Le()}function S(e){let t=new Set;for(let n of e.split(`,`)){let e=n.trim();e&&t.add(e)}return Array.from(t)}let w=a(()=>S(m.value)),T=a(()=>S(h.value)),D=a(()=>S(g.value)),O=a(()=>J(s.value)),k=a(()=>p.value!==``),A=a(()=>l.value.trim()!==``&&l.value!==`sk-llmgw-REPLACE_ME`),M=a(()=>Oe(T.value,D.value)),N=a(()=>{if(!O.value||!k.value||!A.value||M.value)return null;let e=w.value.length>0?[p.value,...w.value]:null;return Re({name:s.value.trim(),apiKey:l.value.trim(),group:e?void 0:p.value,groups:e??void 0,providers:T.value,models:D.value,admin:_.value})});return(n,a)=>(j(),t(`div`,St,[r(`div`,Ct,[r(`div`,wt,[a[7]||=r(`label`,{for:`user-name`,class:`text-xs font-medium text-muted-foreground`},`Name`,-1),c(f(H),{id:`user-name`,modelValue:s.value,"onUpdate:modelValue":a[0]||=e=>s.value=e,placeholder:`alice`},null,8,[`modelValue`])]),r(`div`,Tt,[a[8]||=r(`label`,{id:`user-group-label`,class:`text-xs font-medium text-muted-foreground`},`Primary group`,-1),c(f(B),{"model-value":p.value,"onUpdate:modelValue":a[1]||=e=>p.value=String(e)},{default:E(()=>[c(f(V),{"aria-labelledby":`user-group-label`},{default:E(()=>[c(f(z),{placeholder:`Select…`})]),_:1}),c(f(L),null,{default:E(()=>[(j(!0),t(x,null,e(i.groupNames,e=>(j(),d(f(R),{key:e,value:e},{default:E(()=>[o(b(e),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),r(`div`,Et,[a[10]||=r(`label`,{for:`user-api-key`,class:`text-xs font-medium text-muted-foreground`},`API key`,-1),r(`div`,Dt,[c(f(H),{id:`user-api-key`,modelValue:l.value,"onUpdate:modelValue":a[2]||=e=>l.value=e,class:`font-mono`},null,8,[`modelValue`]),c(f(te),{type:`button`,variant:`outline`,size:`sm`,onClick:y},{default:E(()=>[...a[9]||=[o(`Generate`,-1)]]),_:1})]),l.value===f(`sk-llmgw-REPLACE_ME`)?(j(),t(`p`,Ot,`Still the placeholder — click Generate for a real key.`)):C(``,!0)]),r(`div`,kt,[a[11]||=r(`label`,{for:`user-extra-groups`,class:`text-xs font-medium text-muted-foreground`},`Additional groups (comma-separated, optional)`,-1),c(f(H),{id:`user-extra-groups`,modelValue:m.value,"onUpdate:modelValue":a[3]||=e=>m.value=e,placeholder:`friends`},null,8,[`modelValue`])]),r(`div`,At,[r(`div`,jt,[a[12]||=r(`label`,{for:`user-providers`,class:`text-xs font-medium text-muted-foreground`},`Personal grant: providers (optional)`,-1),c(f(H),{id:`user-providers`,modelValue:h.value,"onUpdate:modelValue":a[4]||=e=>h.value=e,placeholder:`gx10`},null,8,[`modelValue`])]),r(`div`,Mt,[a[13]||=r(`label`,{for:`user-models`,class:`text-xs font-medium text-muted-foreground`},`Personal grant: models (optional)`,-1),c(f(H),{id:`user-models`,modelValue:g.value,"onUpdate:modelValue":a[5]||=e=>g.value=e,placeholder:`gx10/current`},null,8,[`modelValue`])])]),r(`label`,Nt,[v(r(`input`,{"onUpdate:modelValue":a[6]||=e=>_.value=e,type:`checkbox`,class:`size-4 rounded border-input`},null,512),[[ee,_.value]]),a[14]||=o(` Admin (full access to /admin/api/*) `,-1)]),M.value?(j(),d(f(F),{key:0,variant:`destructive`},{default:E(()=>[c(f(I),null,{default:E(()=>[o(b(M.value),1)]),_:1})]),_:1})):C(``,!0),N.value?(j(),d(U,{key:1,label:`Add as a new line in users.json`,text:N.value},null,8,[`text`])):(j(),t(`p`,Pt,`Fill in a name, group, and a real (generated) API key to build a snippet.`))]))}}),It={class:`flex flex-col gap-4`},Lt=P({__name:`ChangeHelper`,props:{groupNames:{},userNames:{}},setup(n){let r=[`limits`,`grant`,`pricing`,`model`,`user`],i={limits:`Limits`,grant:`Access grant`,pricing:`Pricing`,model:`Model metadata`,user:`New user`},s=n,l=O(),u=a(()=>{let e=l.params.helper;return r.includes(e??``)?e:`limits`});function p(e){typeof e!=`string`||!r.includes(e)||l.goTo(`config`,{...l.params,helper:e})}return(n,a)=>(j(),t(`div`,It,[c(f(ie),{"model-value":u.value,"onUpdate:modelValue":p},{default:E(()=>[c(f(re),null,{default:E(()=>[(j(),t(x,null,e(r,e=>c(f(ae),{key:e,value:e},{default:E(()=>[o(b(i[e]),1)]),_:2},1032,[`value`])),64))]),_:1})]),_:1},8,[`model-value`]),u.value===`limits`?(j(),d(st,{key:0,"group-names":s.groupNames,"user-names":s.userNames},null,8,[`group-names`,`user-names`])):u.value===`grant`?(j(),d(Xe,{key:1,"group-names":s.groupNames,"user-names":s.userNames},null,8,[`group-names`,`user-names`])):u.value===`pricing`?(j(),d(xt,{key:2})):u.value===`model`?(j(),d(mt,{key:3})):(j(),d(Ft,{key:4,"group-names":s.groupNames},null,8,[`group-names`]))]))}}),Rt={class:`flex flex-col gap-4`},zt=P({__name:`ConfigTree`,props:{config:{},warnings:{}},setup(n){let r=n,i=a(()=>Ce(q(r.config)));return(r,a)=>(j(),t(`div`,Rt,[(j(!0),t(x,null,e(n.warnings,(e,t)=>(j(),d(f(F),{key:t,variant:`warn`},{default:E(()=>[c(f(oe),null,{default:E(()=>[...a[0]||=[o(`Config warning`,-1)]]),_:1}),c(f(I),null,{default:E(()=>[o(b(e),1)]),_:2},1024)]),_:2},1024))),128)),c(U,{label:`Redacted running config (read-only)`,text:i.value},null,8,[`text`])]))}}),Bt=w(`config`,{state:()=>({data:null,loading:!1,error:``}),actions:{async fetchConfig(){if(N().isAuthenticated){this.loading=!0;try{this.data=await k(`/admin/api/config`),this.error=``}catch(e){if(e instanceof _&&(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()}}}),Vt={class:`flex flex-col gap-6`},Ht={key:1,class:`text-sm text-muted-foreground`},Ut=P({__name:`ConfigPage`,setup(e){let r=Bt(),i=S(),s=ce();A(()=>{r.ensureConfig(),s.ensureConsumers()});let l=a(()=>(i.overview?.groups??[]).map(e=>e.name)),u=a(()=>(s.data?.users??[]).map(e=>e.name));return(e,i)=>(j(),t(`div`,Vt,[f(r).error?(j(),d(f(n),{key:0},{default:E(()=>[c(f(M),null,{default:E(()=>[c(f(y),null,{default:E(()=>[...i[0]||=[o(`Config`,-1)]]),_:1}),c(f(ne),{class:`text-destructive`},{default:E(()=>[o(b(f(r).error),1)]),_:1})]),_:1})]),_:1})):f(r).loading&&!f(r).data?(j(),t(`p`,Ht,`loading…`)):f(r).data?(j(),d(zt,{key:2,config:f(r).data.config,warnings:f(r).data.warnings},null,8,[`config`,`warnings`])):C(``,!0),c(f(n),null,{default:E(()=>[c(f(M),null,{default:E(()=>[c(f(y),null,{default:E(()=>[...i[1]||=[o(`Change helper`,-1)]]),_:1}),c(f(ne),null,{default:E(()=>[...i[2]||=[o(`Build a paste-ready snippet for middleware.yaml or users.json — nothing here writes to the running config.`,-1)]]),_:1})]),_:1}),c(f(p),null,{default:E(()=>[c(Lt,{"group-names":l.value,"user-names":u.value},null,8,[`group-names`,`user-names`])]),_:1})]),_:1})]))}});export{Ut as default};",
+		),
+	},
+	"ConsumersPage-DZ5nHr-A.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{An as e,At as t,C as n,Dt as r,Er as i,Et as a,It as o,Lt as s,Mn as c,Or as l,Ot as u,Qn as d,Rr as f,S as p,Sn as ee,V as m,W as h,Xt as g,b as _,br as v,di as y,gt as b,h as te,kt as x,ot as S,rr as C,si as w,st as T,t as E,ui as ne,vn as D,wn as O,x as k,z as A,zt as j}from"./nav-Dzb0OTN_.js";import{d as M,n as N,t as P,u as re}from"./CardDescription-IdOt317c.js";import{a as F,c as ie,i as ae,n as oe,o as I,r as se,s as ce,t as le}from"./search-expand-B1qnK1H5.js";import{n as ue,r as L,t as R}from"./tabs-BbGJyCRr.js";import{t as z}from"./index-BiTQ_gCE.js";import{t as de}from"./consumers-wB-itjnf.js";import{a as fe,c as B,d as pe,i as me,l as V,n as he,o as ge,r as _e,s as H,t as ve,u as ye}from"./DataTable-DVueNFuA.js";import{c as U,f as be,o as W,r as xe,t as G,u as K}from"./badge-ns0j8OUr.js";import{t as q}from"./CompactNumber-B1ihQZH7.js";import{a as J,i as Y,n as Se,o as Ce,r as we,s as Te,t as Ee}from"./forecast-BMSkg5Xs.js";import{a as De,i as Oe,o as ke,r as Ae,s as je}from"./burndown-CqtdXSYk.js";import{n as Me,t as Ne}from"./useSearchQuery-DysBt-In.js";import{t as X}from"./EntityLink-CovsFjEl.js";import{t as Pe}from"./ClampedRangeNotice-Bvhm1e-B.js";import{t as Fe}from"./TimeSeriesChart-BP5IcUyg.js";import{t as Ie}from"./events-BPFIBv4M.js";function Le(e,t){t.value=typeof e==`function`?e(t.value):e}function Re(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 Z(e,t){return t.access===void 0||t.access===null?{allowed:!0}:{allowed:t.access.includes(e.name)}}function ze(e,t,n,r){return e.map(e=>({group:e.name,providers:Object.fromEntries(t.map(t=>[t,Re(e,t)])),mcpServers:Object.fromEntries(n.map(t=>[t.name,Z(e,t)])),agents:Object.fromEntries(r.map(t=>[t.name,Z(e,t)]))}))}var Q={key:0,"aria-hidden":`true`,class:`ml-1 text-xs text-muted-foreground`},Be={class:`sr-only`},Ve=j({__name:`AccessMatrix`,setup(i){let l=de(),d=te();D(()=>{l.ensureConsumers()});let ee=a(()=>(d.overview?.providers??[]).map(e=>e.name)),m=a(()=>d.targets?.mcpServers??[]),g=a(()=>d.targets?.agents??[]),v=a(()=>[...ee.value.map(e=>({key:e,label:e,section:`providers`})),...m.value.map(e=>({key:e.name,label:`${e.name} (MCP)`,section:`mcpServers`})),...g.value.map(e=>({key:e.name,label:`${e.name} (agent)`,section:`agents`}))]),E=a(()=>ze(l.data?.groups??[],ee.value,m.value,g.value)),ne={allowed:!1};function A(e,t){return e[t.section][t.key]??ne}function j(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 M(e){return e.allowed?e.zero?S:h:T}function N(e){return e.allowed?e.zero?`text-status-warn`:`text-chart-requests`:`text-muted-foreground/40`}return(i,a)=>{let d=c(`FontAwesomeIcon`);return O(),u(f(n),null,{default:C(()=>[s(f(k),null,{default:C(()=>[s(f(_),null,{default:C(()=>[...a[0]||=[o(`Access matrix`,-1)]]),_:1}),s(f(P),null,{default:C(()=>[...a[1]||=[o(`Which groups can reach which providers, MCP servers, and agents.`,-1)]]),_:1})]),_:1}),f(l).error?(O(),u(f(p),{key:0,class:`text-sm text-destructive`},{default:C(()=>[o(y(f(l).error),1)]),_:1})):E.value.length===0?(O(),u(f(p),{key:1,class:`py-6 text-center text-sm text-muted-foreground`},{default:C(()=>[o(y(f(l).loading?`loading…`:`no groups configured`),1)]),_:1})):(O(),u(f(p),{key:2,class:`overflow-x-auto`},{default:C(()=>[s(f(pe),null,{default:C(()=>[s(f(ge),null,{default:C(()=>[s(f(B),null,{default:C(()=>[s(f(H),null,{default:C(()=>[...a[2]||=[o(`Group`,-1)]]),_:1}),(O(!0),t(b,null,e(v.value,e=>(O(),u(f(H),{key:e.key+e.section},{default:C(()=>[o(y(e.label),1)]),_:2},1024))),128))]),_:1})]),_:1}),s(f(ye),null,{default:C(()=>[(O(!0),t(b,null,e(E.value,n=>(O(),u(f(B),{key:n.group},{default:C(()=>[s(f(H),{scope:`row`,class:`font-medium`},{default:C(()=>[o(y(n.group),1)]),_:2},1024),(O(!0),t(b,null,e(v.value,e=>(O(),u(f(V),{key:e.key+e.section,class:`text-center`,title:A(n,e).detail},{default:C(()=>[s(d,{icon:M(A(n,e)),class:w([N(A(n,e)),`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),A(n,e).detail?(O(),t(`span`,Q,y(A(n,e).detail),1)):x(``,!0),r(`span`,Be,y(j(A(n,e))),1)]),_:2},1032,[`title`]))),128))]),_:2},1024))),128))]),_:1})]),_:1})]),_:1}))]),_:1})}}}),He=[`aria-label`,`aria-valuenow`,`aria-valuetext`,`title`],Ue=j({__name:`UsageBar`,props:{ratio:{},label:{},valueText:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let n=e,i=a(()=>Te(n.ratio)),o=a(()=>Math.min(100,Math.max(0,n.ratio*100))),s=a(()=>Math.round(o.value)),c={normal:`bg-primary`,amber:`bg-bar-amber`,red:`bg-destructive`};return(a,l)=>(O(),t(`span`,{role:`meter`,"aria-label":e.label,"aria-valuenow":s.value,"aria-valuemin":`0`,"aria-valuemax":`100`,"aria-valuetext":e.valueText,title:e.valueText,class:w(f(A)(`relative inline-block h-1.5 w-14 shrink-0 overflow-hidden rounded-full bg-muted align-middle`,n.class))},[r(`span`,{class:w([`absolute inset-y-0 left-0 rounded-full`,c[i.value]]),style:ne({width:`${o.value}%`})},null,6)],10,He))}}),We=60,Ge=3600,Ke=86400,qe=60,Je=30;function Ye(e,t=new Date){if(!e)return`never`;let n=Math.floor(t.getTime()/1e3),r=Math.max(0,n-e);if(r<We)return`just now`;if(r<Ge)return`${Math.floor(r/We)}m ago`;if(r<Ke)return`${Math.floor(r/Ge)}h ago`;let i=Math.floor(r/Ke);return i<qe?`${i}d ago`:`${Math.floor(i/Je)}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 o=n(e.original),s=i?g(q,{value:o}):r(o);if(!a)return s;let c=Ce(e.original).find(e=>e.id===a);if(!c)return s;let l=i?`${U(c.used)} / ${U(c.limit)}`:`${r(c.used)} / ${r(c.limit)}`;return g(`span`,{class:`inline-flex items-center justify-end gap-1.5`},[s,g(Ue,{ratio:c.ratio,label:Y[a]??t,valueText:l})])}}}function Xe(){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 g(q,{value:t,class:t>0?`text-destructive`:void 0})}}}function Ze(e){return{id:`costMonthProj`,header:`cost/month (proj.)`,meta:{align:`right`},accessorFn:t=>we(t.costPerMonthMicroUsd,e)??0,cell:({row:t})=>{if(t.original.storeDown)return`?`;let n=we(t.original.costPerMonthMicroUsd,e);if(n===null)return g(`span`,{class:`text-muted-foreground`},`not enough data yet`);let r=Ee(n,t.original.limits?.costPerMonthUSD);return g(`span`,{class:r.willExceed?`text-destructive`:void 0,title:r.willExceed?`Projected to exceed the configured cost/month limit`:void 0},W(n))}}}function Qe(e){return{id:`source`,header:`Source`,accessorFn:t=>e(t)??``,cell:({row:t})=>g(`span`,{class:`text-muted-foreground`},e(t.original)??`—`)}}function $e(e){return{id:`lastSeen`,header:`Last seen`,accessorFn:e=>e.lastSeen??0,cell:({row:t})=>Ye(t.original.lastSeen,e)}}function et(e,t,n,r=new Date,i){let a=Se(r),o=[{id:`id`,header:e,accessorFn:e=>e.id,cell:({row:e})=>g(X,{class:`font-medium`,label:e.original.id,kind:`user`,id:e.original.id})},{id:`secondary`,header:t,accessorFn:n,sortingFn:`alphanumeric`,cell:({row:e})=>g(`span`,{class:`text-muted-foreground`},n(e.original))}];return i&&o.push(Qe(i)),o.push({id:`limits`,header:`Limits`,accessorFn:e=>K(e.limits),cell:({row:e})=>g(`span`,{class:`text-muted-foreground`},K(e.original.limits))},$(`reqMin`,`req/min`,e=>e.requestsPerMinute,String,!0,`reqMin`),$(`reqDay`,`req/day`,e=>e.requestsPerDay,String,!0,`reqDay`),Xe(),$(`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,W,!1,`costDay`),$(`costMonth`,`cost/month`,e=>e.costPerMonthMicroUsd,W,!1,`costMonth`),Ze(a),$e(r)),o}var tt=j({__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=a(()=>et(n.idLabel,n.secondaryColumnLabel,n.secondaryValue,n.now,n.sourceValue));return(t,n)=>(O(),u(ve,{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`]))}}),nt={users:`Group`,groups:`Members`};function rt(e){return(e/J).toFixed(6)}function it(e,t,n,r=new Date){let i=Se(r),a=[`Name`,nt[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:we(e.costPerMonthMicroUsd,i);return[e.id,n(e),K(e.limits),t?`?`:e.requestsPerMinute,t?`?`:e.requestsPerDay,t?`?`:e.rejectionsPerDay,t?`?`:e.tokensInPerDay,t?`?`:e.tokensOutPerDay,t?`?`:e.tokensInPerMonth,t?`?`:e.tokensOutPerMonth,t?`?`:rt(e.costPerDayMicroUsd),t?`?`:rt(e.costPerMonthMicroUsd),t?`?`:r===null?`not enough data yet`:rt(r),e.lastSeen??0]});return Oe(a,o)}function at(e,t){return e.id.toLowerCase().includes(t)}function ot(e,t){return e.id.toLowerCase().includes(t)}function st(e,t){return t.filter(t=>(t.groups??[t.groupName]).includes(e.id))}function ct(e,t,n){return st(e,t).filter(e=>at(e,n))}function lt(e,t,n){return ot(e,n)||ct(e,t,n).length>0}var ut={class:`flex flex-col gap-6`},dt={class:`text-lg font-semibold tabular-nums`},ft={class:`text-lg font-semibold tabular-nums`},pt={class:`text-lg font-semibold tabular-nums`},mt={class:`text-lg font-semibold tabular-nums`},ht={class:`flex items-start justify-between gap-2`},gt={key:0,class:`mb-3 flex flex-wrap gap-x-4 gap-y-1 text-xs font-medium text-muted-foreground`},_t={class:`flex items-center gap-2`},vt={class:`shrink-0 py-2.5 font-medium`},yt={class:`sr-only`},bt={class:`flex flex-1 flex-wrap items-center gap-x-4 gap-y-1 pr-2 text-left`},xt={class:`text-xs text-muted-foreground tabular-nums`},St={class:`text-xs text-muted-foreground tabular-nums`},Ct={class:`text-xs text-muted-foreground tabular-nums`},wt={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},Tt={key:0,class:`flex flex-wrap gap-1.5`},Et={key:1,class:`text-muted-foreground`},Dt={key:0,class:`flex flex-wrap gap-1.5`},Ot={key:1,class:`text-muted-foreground`},kt={key:0,class:`flex flex-wrap gap-1.5`},At={key:1,class:`text-muted-foreground`},jt={key:0,class:`flex flex-wrap gap-1.5`},Mt={key:1,class:`text-muted-foreground`},Nt={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4`},Pt={class:`tabular-nums`},Ft={class:`tabular-nums`},It={class:`tabular-nums`},Lt={class:`tabular-nums`},Rt={class:`tabular-nums`},zt={class:`tabular-nums`},Bt=[`title`],Vt={key:0,class:`mb-3 flex flex-wrap items-center gap-x-4 gap-y-1.5`},Ht={key:2,class:`py-6 text-center text-sm text-muted-foreground`},Ut={class:`flex items-start justify-between gap-2`},Wt=`Glob pattern — matches like a shell wildcard (*, ?, [...])`,Gt=j({__name:`ConsumerDirectory`,setup(c){let m=te(),h=de(),g=E(),S=a(()=>m.usage);D(()=>{h.ensureConsumers()});let{now:T,start:ne,stop:A}=De();D(ne),ee(A);let j=a(()=>{let e={};for(let t of m.overview?.groups??[])e[t.name]=t.memberCount;return e});function M(e){return(e.groups??(e.groupName===void 0?[]:[e.groupName])).join(`, `)}function N(e){let t=j.value[e.id];return t===void 0?``:String(t)}function re(e){return h.data?.users.find(t=>t.name===e.id)?.source}let ue=a({get:()=>g.params.q??``,set:e=>g.goTo(`consumers`,{...g.params,q:e})}),{query:L,normalized:R,hasQuery:z}=Ne(ue),B=a(()=>{let e=S.value?.groups??[];if(!z.value)return e;let t=S.value?.users??[];return e.filter(e=>lt(e,t,R.value))}),pe=a(()=>z.value?B.value.filter(e=>!ot(e,R.value)).map(e=>e.id):[]);function V(e){let t=S.value?.users??[];return!z.value||ot(e,R.value)?st(e,t):ct(e,t,R.value)}let ge=a(()=>S.value?.groups.length?z.value?`no groups match "${L.value}"`:`none`:`none configured`),H=a(()=>{let e=S.value?.users??[];if(!z.value)return e;let t=S.value?.groups??[],n=new Set(t.filter(e=>ot(e,R.value)).map(e=>e.id));return e.filter(e=>at(e,R.value)||(e.groups??[e.groupName]).some(e=>e!==void 0&&n.has(e)))}),ve=a(()=>S.value?.users.length?z.value?`no users match "${L.value}"`:`none`:`none configured`),ye=a(()=>et(`Name`,`Members`,N,T.value)),be=l([]),xe=_e({get data(){return B.value},get columns(){return ye.value},getCoreRowModel:me(),getSortedRowModel:fe(),onSortingChange:e=>Le(e,be),state:{get sorting(){return be.value}}}),J=a(()=>xe.getRowModel().rows),Te=new Set([`id`,`secondary`,`reqDay`,`costDay`]),Oe=a(()=>xe.getHeaderGroups()[0].headers.filter(e=>Te.has(e.column.id))),Ae=i({manuallyExpanded:new Set,manuallyCollapsed:new Set}),X=a(()=>oe(Ae,z.value,pe.value));function Pe(e){se(Ae,e,X.value.has(e))}let Fe=a({get:()=>Array.from(X.value),set:e=>{let t=new Set(e);for(let e of X.value)t.has(e)||Pe(e);for(let e of t)X.value.has(e)||Pe(e)}});d(L,e=>{e.trim()===``&&le(Ae)});function Ie(e){return/[*?[]/.test(e)}function Re(e){return e.id.startsWith(`cost`)?`${W(e.used)} / ${W(e.limit)}`:`${U(e.used)} / ${U(e.limit)}`}function Z(e,t){let n=Se(t),r=we(e.costPerMonthMicroUsd,n);return r===null?{text:`not enough data yet`,willExceed:!1}:{text:W(r),willExceed:Ee(r,e.limits?.costPerMonthUSD).willExceed}}let ze=a(()=>et(`Name`,`Group`,M,T.value,re)),Q=l([]),Be=_e({get data(){return H.value},get columns(){return ze.value},getCoreRowModel:me(),getSortedRowModel:fe(),onSortingChange:e=>Le(e,Q),state:{get sorting(){return Q.value}}});function Ve(){return it(Be.getRowModel().rows.map(e=>e.original),`users`,M,T.value)}function He(){return it(J.value.map(e=>e.original),`groups`,N,T.value)}return(i,a)=>(O(),t(`div`,ut,[s(Me,{modelValue:f(L),"onUpdate:modelValue":a[0]||=e=>v(L)?L.value=e:null,placeholder:`Filter users or groups`,class:`max-w-sm`},null,8,[`modelValue`]),S.value?(O(),u(f(n),{key:0},{default:C(()=>[s(f(k),null,{default:C(()=>[s(f(_),null,{default:C(()=>[...a[3]||=[o(`Total`,-1)]]),_:1}),s(f(P),null,{default:C(()=>[...a[4]||=[o(`Usage summed across every user and group combined.`,-1)]]),_:1})]),_:1}),s(f(p),{class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-5`},{default:C(()=>[r(`div`,null,[a[5]||=r(`p`,{class:`text-muted-foreground`},`Requests/day`,-1),r(`p`,dt,[s(q,{value:S.value.total.requestsPerDay},null,8,[`value`])])]),r(`div`,null,[a[6]||=r(`p`,{class:`text-muted-foreground`},`Rejected/day`,-1),r(`p`,{class:w([`text-lg font-semibold tabular-nums`,S.value.total.rejectionsPerDay>0?`text-destructive`:void 0])},[s(q,{value:S.value.total.rejectionsPerDay},null,8,[`value`])],2)]),r(`div`,null,[a[7]||=r(`p`,{class:`text-muted-foreground`},`Tokens in/day`,-1),r(`p`,ft,[s(q,{value:S.value.total.tokensInPerDay},null,8,[`value`])])]),r(`div`,null,[a[8]||=r(`p`,{class:`text-muted-foreground`},`Tokens out/day`,-1),r(`p`,pt,[s(q,{value:S.value.total.tokensOutPerDay},null,8,[`value`])])]),r(`div`,null,[a[9]||=r(`p`,{class:`text-muted-foreground`},`Cost/day`,-1),r(`p`,mt,y(f(W)(S.value.total.costPerDayMicroUsd)),1)])]),_:1})]),_:1})):x(``,!0),S.value?(O(),u(je,{key:1,"mtd-micros":S.value.total.costPerMonthMicroUsd,limits:S.value.total.limits,now:f(T)},null,8,[`mtd-micros`,`limits`,`now`])):x(``,!0),s(f(n),null,{default:C(()=>[s(f(k),null,{default:C(()=>[r(`div`,ht,[r(`div`,null,[s(f(_),null,{default:C(()=>[...a[10]||=[o(`Groups`,-1)]]),_:1}),s(f(P),null,{default:C(()=>[...a[11]||=[o(`Expand a group to see its member users' own usage.`,-1)]]),_:1})]),s(ke,{filename:`consumers-groups.csv`,build:He})])]),_:1}),s(f(p),null,{default:C(()=>[J.value.length?(O(),t(`div`,gt,[(O(!0),t(b,null,e(Oe.value,e=>(O(),u(he,{key:e.id,header:e},null,8,[`header`]))),128))])):x(``,!0),J.value.length?(O(),u(f(ce),{key:1,modelValue:Fe.value,"onUpdate:modelValue":a[1]||=e=>Fe.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:C(()=>[(O(!0),t(b,null,e(J.value,n=>(O(),u(f(F),{key:n.original.id,value:n.original.id},{default:C(()=>[r(`div`,_t,[r(`span`,vt,y(n.original.id),1),s(f(ae),{"header-class":`flex-1`},{default:C(()=>[r(`span`,yt,`Group `+y(n.original.id)+` details`,1),r(`span`,bt,[r(`span`,xt,y(N(n.original)||`0`)+` members`,1),r(`span`,St,[n.original.storeDown?(O(),t(b,{key:0},[o(`?`)],64)):(O(),u(q,{key:1,value:n.original.requestsPerDay},null,8,[`value`])),a[12]||=o(` req/day `,-1)]),r(`span`,Ct,y(n.original.storeDown?`?`:f(W)(n.original.costPerDayMicroUsd))+`/day `,1)])]),_:2},1024)]),s(f(I),null,{default:C(()=>[r(`dl`,wt,[r(`div`,null,[r(`dt`,{class:`text-xs text-muted-foreground`,title:Wt},`Providers`),r(`dd`,null,[n.original.providers?.length?(O(),t(`div`,Tt,[(O(!0),t(b,null,e(n.original.providers,e=>(O(),u(f(G),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:C(()=>[o(y(e),1)]),_:2},1024))),128))])):(O(),t(`span`,Et,`All providers`))])]),r(`div`,null,[r(`dt`,{class:`text-xs text-muted-foreground`,title:Wt},`Models`),r(`dd`,null,[n.original.models?.length?(O(),t(`div`,Dt,[(O(!0),t(b,null,e(n.original.models,e=>(O(),t(b,{key:e},[Ie(e)?(O(),u(f(G),{key:1,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:C(()=>[o(y(e),1)]),_:2},1024)):(O(),u(ie,{key:0,id:e},null,8,[`id`]))],64))),128))])):(O(),t(`span`,Ot,`All models`))])]),r(`div`,null,[r(`dt`,{class:`text-xs text-muted-foreground`,title:Wt},`MCP servers`),r(`dd`,null,[n.original.mcpServers?.length?(O(),t(`div`,kt,[(O(!0),t(b,null,e(n.original.mcpServers,e=>(O(),u(f(G),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:C(()=>[o(y(e),1)]),_:2},1024))),128))])):(O(),t(`span`,At,`All MCP servers`))])]),r(`div`,null,[r(`dt`,{class:`text-xs text-muted-foreground`,title:Wt},`Agents`),r(`dd`,null,[n.original.agents?.length?(O(),t(`div`,jt,[(O(!0),t(b,null,e(n.original.agents,e=>(O(),u(f(G),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:C(()=>[o(y(e),1)]),_:2},1024))),128))])):(O(),t(`span`,Mt,`All agents`))])])]),r(`dl`,Nt,[r(`div`,null,[a[13]||=r(`dt`,{class:`text-xs text-muted-foreground`},`Limits`,-1),r(`dd`,null,y(f(K)(n.original.limits)),1)]),r(`div`,null,[a[14]||=r(`dt`,{class:`text-xs text-muted-foreground`},`req/min`,-1),r(`dd`,Pt,[n.original.storeDown?(O(),t(b,{key:0},[o(`?`)],64)):(O(),u(q,{key:1,value:n.original.requestsPerMinute},null,8,[`value`]))])]),r(`div`,null,[a[15]||=r(`dt`,{class:`text-xs text-muted-foreground`},`rejected/day`,-1),r(`dd`,{class:w([`tabular-nums`,!n.original.storeDown&&n.original.rejectionsPerDay>0?`text-destructive`:void 0])},[n.original.storeDown?(O(),t(b,{key:0},[o(`?`)],64)):(O(),u(q,{key:1,value:n.original.rejectionsPerDay},null,8,[`value`]))],2)]),r(`div`,null,[a[16]||=r(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/day`,-1),r(`dd`,Ft,[n.original.storeDown?(O(),t(b,{key:0},[o(`?`)],64)):(O(),u(q,{key:1,value:n.original.tokensInPerDay},null,8,[`value`]))])]),r(`div`,null,[a[17]||=r(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/day`,-1),r(`dd`,It,[n.original.storeDown?(O(),t(b,{key:0},[o(`?`)],64)):(O(),u(q,{key:1,value:n.original.tokensOutPerDay},null,8,[`value`]))])]),r(`div`,null,[a[18]||=r(`dt`,{class:`text-xs text-muted-foreground`},`tokIn/month`,-1),r(`dd`,Lt,[n.original.storeDown?(O(),t(b,{key:0},[o(`?`)],64)):(O(),u(q,{key:1,value:n.original.tokensInPerMonth},null,8,[`value`]))])]),r(`div`,null,[a[19]||=r(`dt`,{class:`text-xs text-muted-foreground`},`tokOut/month`,-1),r(`dd`,Rt,[n.original.storeDown?(O(),t(b,{key:0},[o(`?`)],64)):(O(),u(q,{key:1,value:n.original.tokensOutPerMonth},null,8,[`value`]))])]),r(`div`,null,[a[20]||=r(`dt`,{class:`text-xs text-muted-foreground`},`cost/month`,-1),r(`dd`,zt,y(n.original.storeDown?`?`:f(W)(n.original.costPerMonthMicroUsd)),1)]),r(`div`,null,[a[21]||=r(`dt`,{class:`text-xs text-muted-foreground`},`cost/month (proj.)`,-1),r(`dd`,{class:w([`tabular-nums`,!n.original.storeDown&&Z(n.original,f(T)).willExceed?`text-destructive`:void 0]),title:!n.original.storeDown&&Z(n.original,f(T)).willExceed?`Projected to exceed the configured cost/month limit`:void 0},y(n.original.storeDown?`?`:Z(n.original,f(T)).text),11,Bt)])]),f(Ce)(n.original).length?(O(),t(`div`,Vt,[(O(!0),t(b,null,e(f(Ce)(n.original),e=>(O(),t(`span`,{key:e.id,class:`inline-flex items-center gap-1.5 text-xs text-muted-foreground`},[o(y(f(Y)[e.id])+` `,1),s(Ue,{ratio:e.ratio,label:f(Y)[e.id],"value-text":Re(e)},null,8,[`ratio`,`label`,`value-text`])]))),128))])):x(``,!0),a[22]||=r(`p`,{class:`mb-1.5 text-xs font-medium text-muted-foreground`},`Members`,-1),s(tt,{"id-label":`Name`,"secondary-column-label":`Group`,entries:V(n.original),"secondary-value":M,now:f(T),"source-value":re},null,8,[`entries`,`now`])]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])):(O(),t(`p`,Ht,y(ge.value),1))]),_:1})]),_:1}),s(f(n),null,{default:C(()=>[s(f(k),null,{default:C(()=>[r(`div`,Ut,[r(`div`,null,[s(f(_),null,{default:C(()=>[...a[23]||=[o(`Users`,-1)]]),_:1}),f(h).data?.usersFile?(O(),u(f(P),{key:0},{default:C(()=>[o(`File-backed users load from `+y(f(h).data.usersFile)+`.`,1)]),_:1})):x(``,!0)]),s(ke,{filename:`consumers-users.csv`,build:Ve})])]),_:1}),s(f(p),null,{default:C(()=>[s(tt,{"id-label":`Name`,"secondary-column-label":`Group`,entries:H.value,"secondary-value":M,"empty-message":ve.value,now:f(T),"source-value":re,sorting:Q.value,"onUpdate:sorting":a[2]||=e=>Q.value=e},null,8,[`entries`,`empty-message`,`now`,`sorting`])]),_:1})]),_:1})]))}}),Kt={class:`flex flex-col gap-4`},qt={class:`flex items-center gap-2`},Jt={class:`flex flex-wrap items-center gap-2`},Yt={class:`text-lg font-semibold tabular-nums`},Xt={class:`text-lg font-semibold tabular-nums`},Zt={class:`text-lg font-semibold tabular-nums`},Qt={class:`text-sm`},$t={key:0,class:`text-sm text-muted-foreground`},en={key:1,class:`text-sm text-destructive`},tn={key:0,class:`text-sm text-muted-foreground`},nn={key:1,class:`text-sm text-destructive`},rn={key:2,class:`py-6 text-center text-sm text-muted-foreground`},an={key:0,class:`flex flex-col gap-2 text-sm`},on={class:`flex flex-wrap items-center gap-2`},sn={class:`text-muted-foreground`},cn={class:`text-muted-foreground`},ln={key:1,class:`py-6 text-center text-sm text-muted-foreground`},un={class:`flex flex-wrap gap-1.5`},dn={class:`flex flex-wrap gap-1.5`},fn=j({__name:`UserDetail`,props:{userId:{}},emits:[`close`],setup(i,{emit:l}){let h=i,g=l,v=te(),S=de(),w=Ie(),T=z(),{now:E,start:ne,stop:A}=De();D(ne),ee(A);let j=a(()=>v.usage?.users.find(e=>e.id===h.userId)),F=a(()=>S.data?.users.find(e=>e.name===h.userId)),ae=a(()=>v.overview?.features.userModelStats??!1);function oe(){S.fetchUserDetail(h.userId,T.window,T.span,ae.value)}D(()=>{oe(),w.refresh()}),d([()=>h.userId,()=>T.range,ae],oe);let I=a(()=>S.detail[h.userId]),se=a(()=>(I.value?.reqSeries?.buckets??[]).map(e=>xe(e,I.value?.reqSeries?.window??T.window))),ce=a(()=>[{label:`Requests`,data:I.value?.reqSeries?.series[0]?.points??[],color:`--chart-requests`}]),le=a(()=>(I.value?.costSeries?.buckets??[]).map(e=>xe(e,I.value?.costSeries?.window??T.window))),ue=a(()=>[{label:`Cost`,data:(I.value?.costSeries?.series[0]?.points??[]).map(e=>e),color:`--chart-cost`}]),L=a(()=>!ae.value||I.value?.modelTotalsUnavailable===!0),R=a(()=>[...I.value?.modelTotals?.rows??[]].sort((e,t)=>(t.values.cost??t.values.req??0)-(e.values.cost??e.values.req??0))),fe=a(()=>w.events.filter(e=>e.user===h.userId).slice(0,10)),me=a(()=>j.value?Ce(j.value):[]);function he(e,t,n){return e.startsWith(`cost`)?`${W(t)} / ${W(n)}`:`${U(t)} / ${U(n)}`}let _e=a(()=>{let e=j.value?.limits?.costPerMonthUSD;return!j.value||!e?null:Ae(j.value.costPerMonthMicroUsd,Math.round(e*1e6),E.value)});return(a,l)=>{let d=c(`FontAwesomeIcon`);return O(),t(`div`,Kt,[r(`div`,qt,[s(f(N),{type:`button`,variant:`ghost`,size:`sm`,onClick:l[0]||=e=>g(`close`)},{default:C(()=>[s(d,{icon:f(m),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`]),l[1]||=o(` Back to directory `,-1)]),_:1})]),s(f(n),null,{default:C(()=>[s(f(k),null,{default:C(()=>[r(`div`,Jt,[s(f(_),{class:`font-mono`},{default:C(()=>[o(y(i.userId),1)]),_:1}),F.value?.admin?(O(),u(f(G),{key:0,variant:`destructive`},{default:C(()=>[...l[2]||=[o(`admin`,-1)]]),_:1})):x(``,!0),F.value?.source?(O(),u(f(G),{key:1,variant:`secondary`},{default:C(()=>[o(y(F.value.source),1)]),_:1})):x(``,!0)]),j.value?.groups?.length||j.value?.groupName?(O(),u(f(P),{key:0},{default:C(()=>[o(` Member of `+y((j.value?.groups??[j.value?.groupName]).filter(Boolean).join(`, `)),1)]),_:1})):x(``,!0)]),_:1}),j.value?(O(),u(f(p),{key:1,class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-4`},{default:C(()=>[r(`div`,null,[l[4]||=r(`p`,{class:`text-muted-foreground`},`Requests/day`,-1),r(`p`,Yt,[s(q,{value:j.value.requestsPerDay},null,8,[`value`])])]),r(`div`,null,[l[5]||=r(`p`,{class:`text-muted-foreground`},`Cost/day`,-1),r(`p`,Xt,y(f(W)(j.value.costPerDayMicroUsd)),1)]),r(`div`,null,[l[6]||=r(`p`,{class:`text-muted-foreground`},`Cost/month`,-1),r(`p`,Zt,y(f(W)(j.value.costPerMonthMicroUsd)),1)]),r(`div`,null,[l[7]||=r(`p`,{class:`text-muted-foreground`},`Limits`,-1),r(`p`,Qt,y(f(K)(j.value.limits)),1)])]),_:1})):(O(),u(f(p),{key:0,class:`text-sm text-muted-foreground`},{default:C(()=>[...l[3]||=[o(` No usage scope for this user yet — it appears after their first request. `,-1)]]),_:1}))]),_:1}),j.value&&me.value.length?(O(),u(f(n),{key:0},{default:C(()=>[s(f(k),null,{default:C(()=>[s(f(_),null,{default:C(()=>[...l[8]||=[o(`Headroom`,-1)]]),_:1}),_e.value?(O(),u(f(P),{key:0},{default:C(()=>[o(`At the current pace, cost/month runs out around `+y(f(be)(_e.value.toISOString()))+`.`,1)]),_:1})):x(``,!0)]),_:1}),s(f(p),{class:`flex flex-wrap items-center gap-x-4 gap-y-1.5`},{default:C(()=>[(O(!0),t(b,null,e(me.value,e=>(O(),t(`span`,{key:e.id,class:`inline-flex items-center gap-1.5 text-xs text-muted-foreground`},[o(y(f(Y)[e.id])+` `,1),s(Ue,{ratio:e.ratio,label:f(Y)[e.id],"value-text":he(e.id,e.used,e.limit)},null,8,[`ratio`,`label`,`value-text`])]))),128))]),_:1})]),_:1})):x(``,!0),s(f(n),null,{default:C(()=>[s(f(k),null,{default:C(()=>[s(f(_),null,{default:C(()=>[...l[9]||=[o(`Requests over time`,-1)]]),_:1})]),_:1}),s(f(p),null,{default:C(()=>[I.value?.loading?(O(),t(`p`,$t,`loading…`)):I.value?.error?(O(),t(`p`,en,y(I.value.error),1)):(O(),u(Fe,{key:2,labels:se.value,datasets:ce.value,ariaLabel:`Requests over time for ${i.userId}`},null,8,[`labels`,`datasets`,`ariaLabel`]))]),_:1})]),_:1}),s(f(n),null,{default:C(()=>[s(f(k),null,{default:C(()=>[s(f(_),null,{default:C(()=>[...l[10]||=[o(`Cost over time`,-1)]]),_:1})]),_:1}),s(f(p),null,{default:C(()=>[I.value?.loading?(O(),t(`p`,tn,`loading…`)):I.value?.error?(O(),t(`p`,nn,y(I.value.error),1)):(O(),u(Fe,{key:2,labels:le.value,datasets:ue.value,"value-formatter":f(W),ariaLabel:`Cost over time for ${i.userId}`},null,8,[`labels`,`datasets`,`value-formatter`,`ariaLabel`]))]),_:1})]),_:1}),s(f(n),null,{default:C(()=>[s(f(k),null,{default:C(()=>[s(f(_),null,{default:C(()=>[...l[11]||=[o(`Models used`,-1)]]),_:1})]),_:1}),s(f(p),{class:`flex flex-col gap-3`},{default:C(()=>[s(Pe,{window:f(T).window,span:f(T).span},null,8,[`window`,`span`]),L.value?(O(),u(f(M),{key:0,variant:`warn`},{default:C(()=>[s(f(re),null,{default:C(()=>[...l[12]||=[o(`Enable admin.stats.userModel in the plugin config to see a per-model breakdown for this user.`,-1)]]),_:1})]),_:1})):R.value.length?(O(),u(f(pe),{key:1},{default:C(()=>[s(f(ge),null,{default:C(()=>[s(f(B),null,{default:C(()=>[s(f(H),null,{default:C(()=>[...l[13]||=[o(`Model`,-1)]]),_:1}),s(f(H),{class:`text-right`},{default:C(()=>[...l[14]||=[o(`Requests`,-1)]]),_:1}),s(f(H),{class:`text-right`},{default:C(()=>[...l[15]||=[o(`Cost`,-1)]]),_:1})]),_:1})]),_:1}),s(f(ye),null,{default:C(()=>[(O(!0),t(b,null,e(R.value,e=>(O(),u(f(B),{key:e.id},{default:C(()=>[s(f(V),null,{default:C(()=>[s(ie,{id:e.id},null,8,[`id`])]),_:2},1024),s(f(V),{class:`text-right tabular-nums`},{default:C(()=>[s(q,{value:e.values.req??0},null,8,[`value`])]),_:2},1024),s(f(V),{class:`text-right tabular-nums`},{default:C(()=>[o(y(f(W)(e.values.cost??0)),1)]),_:2},1024)]),_:2},1024))),128))]),_:1})]),_:1})):(O(),t(`p`,rn,`no model usage in this range`))]),_:1})]),_:1}),s(f(n),null,{default:C(()=>[s(f(k),null,{default:C(()=>[s(f(_),null,{default:C(()=>[...l[16]||=[o(`Recent errors`,-1)]]),_:1})]),_:1}),s(f(p),null,{default:C(()=>[fe.value.length?(O(),t(`ul`,an,[(O(!0),t(b,null,e(fe.value,(e,n)=>(O(),t(`li`,{key:n,class:`border-b pb-2 last:border-0 last:pb-0`},[r(`p`,on,[s(f(G),{variant:`secondary`},{default:C(()=>[o(y(e.kind),1)]),_:2},1024),r(`span`,sn,y(f(be)(e.time)),1)]),r(`p`,cn,y(e.message),1)]))),128))])):(O(),t(`p`,ln,`none in the current event window`))]),_:1})]),_:1}),F.value?.providers?.length||F.value?.models?.length?(O(),u(f(n),{key:1},{default:C(()=>[s(f(k),null,{default:C(()=>[s(f(_),null,{default:C(()=>[...l[17]||=[o(`Personal grant`,-1)]]),_:1}),s(f(P),null,{default:C(()=>[...l[18]||=[o(`Access this user has beyond their group's own.`,-1)]]),_:1})]),_:1}),s(f(p),{class:`grid grid-cols-1 gap-4 sm:grid-cols-2`},{default:C(()=>[r(`div`,null,[l[19]||=r(`p`,{class:`mb-1.5 text-xs text-muted-foreground`},`Providers`,-1),r(`div`,un,[(O(!0),t(b,null,e(F.value?.providers??[],e=>(O(),u(f(G),{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},{default:C(()=>[o(y(e),1)]),_:2},1024))),128))])]),r(`div`,null,[l[20]||=r(`p`,{class:`mb-1.5 text-xs text-muted-foreground`},`Models`,-1),r(`div`,dn,[(O(!0),t(b,null,e(F.value?.models??[],e=>(O(),u(ie,{key:e,id:e},null,8,[`id`]))),128))])])]),_:1})]),_:1})):x(``,!0)])}}}),pn={key:1,class:`flex flex-col gap-4`},mn=j({__name:`ConsumersPage`,setup(e){let n=E(),r=a(()=>n.params.user),i=a(()=>n.params.view===`matrix`?`matrix`:`directory`);function c(e){if(e!==`directory`&&e!==`matrix`)return;let{user:t,...r}=n.params;n.goTo(`consumers`,{...r,view:e})}function l(){let{user:e,...t}=n.params;n.goTo(`consumers`,t)}return(e,n)=>r.value?(O(),u(fn,{key:0,"user-id":r.value,onClose:l},null,8,[`user-id`])):(O(),t(`div`,pn,[s(f(L),{"model-value":i.value,"onUpdate:modelValue":c},{default:C(()=>[s(f(ue),null,{default:C(()=>[s(f(R),{value:`directory`},{default:C(()=>[...n[0]||=[o(`Directory`,-1)]]),_:1}),s(f(R),{value:`matrix`},{default:C(()=>[...n[1]||=[o(`Access matrix`,-1)]]),_:1})]),_:1})]),_:1},8,[`model-value`]),i.value===`directory`?(O(),u(Gt,{key:0})):(O(),u(Ve,{key:1}))]))}});export{mn as default};",
+		),
+	},
+	"DataTable-DVueNFuA.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{$n as e,An as t,At as n,Dt as r,Et as i,It as a,Lt as o,Mn as s,N as c,Or as l,Ot as u,Qn as d,Rr as f,Xt as p,at as m,br as h,di as g,gt as _,it as ee,jn as v,jr as te,kt as y,rr as b,rt as ne,si as x,un as re,wn as S,z as C,zt as w}from"./nav-Dzb0OTN_.js";var ie={"data-slot":`table-container`,class:`relative w-full overflow-x-auto`},ae=w({__name:`Table`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,i)=>(S(),n(`div`,ie,[r(`table`,{"data-slot":`table`,class:x(f(C)(`w-full caption-bottom text-sm`,t.class))},[v(e.$slots,`default`)],2)]))}}),oe=w({__name:`TableBody`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,r)=>(S(),n(`tbody`,{"data-slot":`table-body`,class:x(f(C)(`[&_tr:last-child]:border-0`,t.class))},[v(e.$slots,`default`)],2))}}),se=w({__name:`TableCell`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,r)=>(S(),n(`td`,{"data-slot":`table-cell`,class:x(f(C)(`p-2 align-middle whitespace-nowrap [&:has([role=checkbox])]:pr-0`,t.class))},[v(e.$slots,`default`)],2))}}),T=w({__name:`TableRow`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,r)=>(S(),n(`tr`,{"data-slot":`table-row`,class:x(f(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))}}),ce={class:`flex items-center justify-center py-10`},le=w({__name:`TableEmpty`,props:{class:{type:[Boolean,null,String,Object,Array]},colspan:{default:1}},setup(e){let t=e,n=c(t,`class`);return(e,i)=>(S(),u(T,null,{default:b(()=>[o(se,re({class:f(C)(`p-4 whitespace-nowrap align-middle text-sm text-foreground`,t.class)},f(n)),{default:b(()=>[r(`div`,ce,[v(e.$slots,`default`)])]),_:3},16,[`class`])]),_:3}))}}),ue=w({__name:`TableHead`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,r)=>(S(),n(`th`,{"data-slot":`table-head`,class:x(f(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))}}),de=w({__name:`TableHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,r)=>(S(),n(`thead`,{"data-slot":`table-header`,class:x(f(C)(`[&_tr]:border-b`,t.class))},[v(e.$slots,`default`)],2))}});function E(e,t){return typeof e==`function`?e(t):e}function D(e,t){return n=>{t.setState(t=>({...t,[e]:E(n,t[e])}))}}function O(e){return e instanceof Function}function fe(e){return Array.isArray(e)&&e.every(e=>typeof e==`number`)}function pe(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 k(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 A(e,t,n,r){return{debug:()=>e?.debugAll??e[t],key:!1,onChange:r}}function me(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:k(()=>[e,n,t,i],(e,t,n,r)=>({table:e,column:t,row:n,cell:r,getValue:r.getValue,renderValue:r.renderValue}),A(e.options,`debugCells`,`cell.getContext`))};return e._features.forEach(r=>{r.createCell==null||r.createCell(i,n,t,e)},{}),i}function he(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:k(()=>[!0],()=>[c,...c.columns?.flatMap(e=>e.getFlatColumns())],A(e.options,`debugColumns`,`column.getFlatColumns`)),getLeafColumns:k(()=>[e._getOrderColumnsFn()],e=>{var t;return(t=c.columns)!=null&&t.length?e(c.columns.flatMap(e=>e.getLeafColumns())):[c]},A(e.options,`debugColumns`,`column.getLeafColumns`))};for(let t of e._features)t.createColumn==null||t.createColumn(c,e);return c}var j=`debugHeaders`;function ge(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 _e={createTable:e=>{e.getHeaderGroups=k(()=>[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 M(t,[...a,...s,...o],e)},A(e.options,j,`getHeaderGroups`)),e.getCenterHeaderGroups=k(()=>[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))),M(t,n,e,`center`)),A(e.options,j,`getCenterHeaderGroups`)),e.getLeftHeaderGroups=k(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.left],(t,n,r)=>M(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`left`),A(e.options,j,`getLeftHeaderGroups`)),e.getRightHeaderGroups=k(()=>[e.getAllColumns(),e.getVisibleLeafColumns(),e.getState().columnPinning.right],(t,n,r)=>M(t,r?.map(e=>n.find(t=>t.id===e)).filter(Boolean)??[],e,`right`),A(e.options,j,`getRightHeaderGroups`)),e.getFooterGroups=k(()=>[e.getHeaderGroups()],e=>[...e].reverse(),A(e.options,j,`getFooterGroups`)),e.getLeftFooterGroups=k(()=>[e.getLeftHeaderGroups()],e=>[...e].reverse(),A(e.options,j,`getLeftFooterGroups`)),e.getCenterFooterGroups=k(()=>[e.getCenterHeaderGroups()],e=>[...e].reverse(),A(e.options,j,`getCenterFooterGroups`)),e.getRightFooterGroups=k(()=>[e.getRightHeaderGroups()],e=>[...e].reverse(),A(e.options,j,`getRightFooterGroups`)),e.getFlatHeaders=k(()=>[e.getHeaderGroups()],e=>e.map(e=>e.headers).flat(),A(e.options,j,`getFlatHeaders`)),e.getLeftFlatHeaders=k(()=>[e.getLeftHeaderGroups()],e=>e.map(e=>e.headers).flat(),A(e.options,j,`getLeftFlatHeaders`)),e.getCenterFlatHeaders=k(()=>[e.getCenterHeaderGroups()],e=>e.map(e=>e.headers).flat(),A(e.options,j,`getCenterFlatHeaders`)),e.getRightFlatHeaders=k(()=>[e.getRightHeaderGroups()],e=>e.map(e=>e.headers).flat(),A(e.options,j,`getRightFlatHeaders`)),e.getCenterLeafHeaders=k(()=>[e.getCenterFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),A(e.options,j,`getCenterLeafHeaders`)),e.getLeftLeafHeaders=k(()=>[e.getLeftFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),A(e.options,j,`getLeftLeafHeaders`)),e.getRightLeafHeaders=k(()=>[e.getRightFlatHeaders()],e=>e.filter(e=>{var t;return!((t=e.subHeaders)!=null&&t.length)}),A(e.options,j,`getRightLeafHeaders`)),e.getLeafHeaders=k(()=>[e.getLeftHeaderGroups(),e.getCenterHeaderGroups(),e.getRightHeaderGroups()],(e,t,n)=>[...e[0]?.headers??[],...t[0]?.headers??[],...n[0]?.headers??[]].map(e=>e.getLeafHeaders()).flat(),A(e.options,j,`getLeafHeaders`))}};function M(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=ge(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)=>ge(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 ve=(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:()=>pe(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:k(()=>[e.getAllLeafColumns()],t=>t.map(t=>me(e,s,t,t.id)),A(e.options,`debugRows`,`getAllCells`)),_getAllCellsByColumnId:k(()=>[s.getAllCells()],e=>e.reduce((e,t)=>(e[t.column.id]=t,e),{}),A(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},ye={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()}}},be=(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))};be.autoRemove=e=>P(e);var xe=(e,t,n)=>{var r;return!!((r=e.getValue(t))!=null&&(r=r.toString())!=null&&r.includes(n))};xe.autoRemove=e=>P(e);var Se=(e,t,n)=>{var r;return((r=e.getValue(t))==null||(r=r.toString())==null?void 0:r.toLowerCase())===n?.toLowerCase()};Se.autoRemove=e=>P(e);var Ce=(e,t,n)=>e.getValue(t)?.includes(n);Ce.autoRemove=e=>P(e);var we=(e,t,n)=>!n.some(n=>{var r;return!((r=e.getValue(t))!=null&&r.includes(n))});we.autoRemove=e=>P(e)||!(e!=null&&e.length);var Te=(e,t,n)=>n.some(n=>e.getValue(t)?.includes(n));Te.autoRemove=e=>P(e)||!(e!=null&&e.length);var Ee=(e,t,n)=>e.getValue(t)===n;Ee.autoRemove=e=>P(e);var De=(e,t,n)=>e.getValue(t)==n;De.autoRemove=e=>P(e);var Oe=(e,t,n)=>{let[r,i]=n,a=e.getValue(t);return a>=r&&a<=i};Oe.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]},Oe.autoRemove=e=>P(e)||P(e[0])&&P(e[1]);var N={includesString:be,includesStringSensitive:xe,equalsString:Se,arrIncludes:Ce,arrIncludesAll:we,arrIncludesSome:Te,equals:Ee,weakEquals:De,inNumberRange:Oe};function P(e){return e==null||e===``}var ke={getDefaultColumnDef:()=>({filterFn:`auto`}),getInitialState:e=>({columnFilters:[],...e}),getDefaultOptions:e=>({onColumnFiltersChange:D(`columnFilters`,e),filterFromLeafRows:!1,maxLeafRowFilterDepth:100}),createColumn:(e,t)=>{e.getAutoFilterFn=()=>{let n=t.getCoreRowModel().flatRows[0]?.getValue(e.id);return typeof n==`string`?N.includesString:typeof n==`number`?N.inNumberRange:typeof n==`boolean`||typeof n==`object`&&n?N.equals:Array.isArray(n)?N.arrIncludes:N.weakEquals},e.getFilterFn=()=>O(e.columnDef.filterFn)?e.columnDef.filterFn:e.columnDef.filterFn===`auto`?e.getAutoFilterFn():t.options.filterFns?.[e.columnDef.filterFn]??N[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=E(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=>E(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 F={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(!fe(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:D(`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 F.sum;if(Object.prototype.toString.call(n)===`[object Date]`)return F.extent},e.getAggregationFn=()=>{if(!e)throw Error();return O(e.columnDef.aggregationFn)?e.columnDef.aggregationFn:e.columnDef.aggregationFn===`auto`?e.getAutoAggregationFn():t.options.aggregationFns?.[e.columnDef.aggregationFn]??F[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:D(`columnOrder`,e)}),createColumn:(e,t)=>{e.getIndex=k(e=>[V(t,e)],t=>t.findIndex(t=>t.id===e.id),A(t.options,`debugColumns`,`getIndex`)),e.getIsFirstColumn=n=>V(t,n)[0]?.id===e.id,e.getIsLastColumn=n=>{let r=V(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=k(()=>[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)},A(e.options,`debugTable`,`_getOrderColumnsFn`))}},I=()=>({left:[],right:[]}),Pe={getInitialState:e=>({columnPinning:I(),...e}),getDefaultOptions:e=>({onColumnPinningChange:D(`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=k(()=>[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))},A(t.options,`debugRows`,`getCenterVisibleCells`)),e.getLeftVisibleCells=k(()=>[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`})),A(t.options,`debugRows`,`getLeftVisibleCells`)),e.getRightVisibleCells=k(()=>[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`})),A(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?I():e.initialState?.columnPinning??I()),e.getIsSomeColumnsPinned=t=>{let n=e.getState().columnPinning;return t?!!n[t]?.length:!!(n.left?.length||n.right?.length)},e.getLeftLeafColumns=k(()=>[e.getAllLeafColumns(),e.getState().columnPinning.left],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),A(e.options,`debugColumns`,`getLeftLeafColumns`)),e.getRightLeafColumns=k(()=>[e.getAllLeafColumns(),e.getState().columnPinning.right],(e,t)=>(t??[]).map(t=>e.find(e=>e.id===t)).filter(Boolean),A(e.options,`debugColumns`,`getRightLeafColumns`)),e.getCenterLeafColumns=k(()=>[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))},A(e.options,`debugColumns`,`getCenterLeafColumns`))}};function Fe(e){return e||(typeof document<`u`?document:null)}var L={size:150,minSize:20,maxSize:2**53-1},R=()=>({startOffset:null,startSize:null,deltaOffset:null,deltaPercentage:null,isResizingColumn:!1,columnSizingStart:[]}),Ie={getDefaultColumnDef:()=>L,getInitialState:e=>({columnSizing:{},columnSizingInfo:R(),...e}),getDefaultOptions:e=>({columnResizeMode:`onEnd`,columnResizeDirection:`ltr`,onColumnSizingChange:D(`columnSizing`,e),onColumnSizingInfoChange:D(`columnSizingInfo`,e)}),createColumn:(e,t)=>{e.getSize=()=>{let n=t.getState().columnSizing[e.id];return Math.min(Math.max(e.columnDef.minSize??L.minSize,n??e.columnDef.size??L.size),e.columnDef.maxSize??L.maxSize)},e.getStart=k(e=>[e,V(t,e),t.getState().columnSizing],(t,n)=>n.slice(0,e.getIndex(t)).reduce((e,t)=>e+t.getSize(),0),A(t.options,`debugColumns`,`getStart`)),e.getAfter=k(e=>[e,V(t,e),t.getState().columnSizing],(t,n)=>n.slice(e.getIndex(t)+1).reduce((e,t)=>e+t.getSize(),0),A(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(),B(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=B(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;B(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?R():e.initialState.columnSizingInfo??R())},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}},z=null;function Le(){if(typeof z==`boolean`)return z;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 z=e,z}function B(e){return e.type===`touchstart`}var Re={getInitialState:e=>({columnVisibility:{},...e}),getDefaultOptions:e=>({onColumnVisibilityChange:D(`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=k(()=>[e.getAllCells(),t.getState().columnVisibility],e=>e.filter(e=>e.column.getIsVisible()),A(t.options,`debugRows`,`_getAllVisibleCells`)),e.getVisibleCells=k(()=>[e.getLeftVisibleCells(),e.getCenterVisibleCells(),e.getRightVisibleCells()],(e,t,n)=>[...e,...t,...n],A(t.options,`debugRows`,`getVisibleCells`))},createTable:e=>{let t=(t,n)=>k(()=>[n(),n().filter(e=>e.getIsVisible()).map(e=>e.id).join(`_`)],e=>e.filter(e=>e.getIsVisible==null?void 0:e.getIsVisible()),A(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 V(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:D(`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=()=>N.includesString,e.getGlobalFilterFn=()=>{let{globalFilterFn:t}=e.options;return O(t)?t:t===`auto`?e.getGlobalAutoFilterFn():e.options.filterFns?.[t]??N[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:D(`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()}}}},H=0,U=10,W=()=>({pageIndex:H,pageSize:U}),He={getInitialState:e=>({...e,pagination:{...W(),...e?.pagination}}),getDefaultOptions:e=>({onPaginationChange:D(`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=>E(t,e)),e.resetPagination=t=>{e.setPagination(t?W():e.initialState.pagination??W())},e.setPageIndex=t=>{e.setPagination(n=>{let r=E(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?H:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageIndex)??H)},e.resetPageSize=t=>{var n;e.setPageSize(t?U:((n=e.initialState)==null||(n=n.pagination)==null?void 0:n.pageSize)??U)},e.setPageSize=t=>{e.setPagination(e=>{let n=Math.max(1,E(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=E(t,e.options.pageCount??-1);return typeof r==`number`&&(r=Math.max(-1,r)),{...n,pageCount:r}}),e.getPageOptions=k(()=>[e.getPageCount()],e=>{let t=[];return e&&e>0&&(t=[...Array(e)].fill(null).map((e,t)=>t)),t},A(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}},G=()=>({top:[],bottom:[]}),Ue={getInitialState:e=>({rowPinning:G(),...e}),getDefaultOptions:e=>({onRowPinningChange:D(`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?G():e.initialState?.rowPinning??G()),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=k(()=>[e.getRowModel().rows,e.getState().rowPinning.top],(t,n)=>e._getPinnedRows(t,n,`top`),A(e.options,`debugRows`,`getTopRows`)),e.getBottomRows=k(()=>[e.getRowModel().rows,e.getState().rowPinning.bottom],(t,n)=>e._getPinnedRows(t,n,`bottom`),A(e.options,`debugRows`,`getBottomRows`)),e.getCenterRows=k(()=>[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))},A(e.options,`debugRows`,`getCenterRows`))}},We={getInitialState:e=>({rowSelection:{},...e}),getDefaultOptions:e=>({onRowSelectionChange:D(`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=>{K(i,t.id,r,!0,e)}),i}),e.getPreSelectedRowModel=()=>e.getCoreRowModel(),e.getSelectedRowModel=k(()=>[e.getState().rowSelection,e.getCoreRowModel()],(t,n)=>Object.keys(t).length?q(e,n):{rows:[],flatRows:[],rowsById:{}},A(e.options,`debugTable`,`getSelectedRowModel`)),e.getFilteredSelectedRowModel=k(()=>[e.getState().rowSelection,e.getFilteredRowModel()],(t,n)=>Object.keys(t).length?q(e,n):{rows:[],flatRows:[],rowsById:{}},A(e.options,`debugTable`,`getFilteredSelectedRowModel`)),e.getGroupedSelectedRowModel=k(()=>[e.getState().rowSelection,e.getSortedRowModel()],(t,n)=>Object.keys(t).length?q(e,n):{rows:[],flatRows:[],rowsById:{}},A(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 K(o,e.id,n,r?.selectChildren??!0,t),o})},e.getIsSelected=()=>{let{rowSelection:n}=t.getState();return J(e,n)},e.getIsSomeSelected=()=>{let{rowSelection:n}=t.getState();return Y(e,n)===`some`},e.getIsAllSubRowsSelected=()=>{let{rowSelection:n}=t.getState();return Y(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)}}}},K=(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=>K(e,t.id,n,r,i))};function q(e,t){let n=e.getState().rowSelection,r=[],i={},a=function(e,t){return e.map(e=>{var t;let o=J(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 J(e,t){return t[e.id]??!1}function Y(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()&&(J(e,t)?a=!0:i=!1),e.subRows&&e.subRows.length)){let n=Y(e,t);n===`all`?a=!0:(n===`some`&&(a=!0),i=!1)}}),i?`all`:a?`some`:!1}var Ge=/([0-9]+)/gm,Ke=(e,t,n)=>$e(X(e.getValue(n)).toLowerCase(),X(t.getValue(n)).toLowerCase()),qe=(e,t,n)=>$e(X(e.getValue(n)),X(t.getValue(n))),Je=(e,t,n)=>Qe(X(e.getValue(n)).toLowerCase(),X(t.getValue(n)).toLowerCase()),Ye=(e,t,n)=>Qe(X(e.getValue(n)),X(t.getValue(n))),Xe=(e,t,n)=>{let r=e.getValue(n),i=t.getValue(n);return r>i?1:r<i?-1:0},Ze=(e,t,n)=>Qe(e.getValue(n),t.getValue(n));function Qe(e,t){return e===t?0:e>t?1:-1}function X(e){return typeof e==`number`?isNaN(e)||e===1/0||e===-1/0?``:String(e):typeof e==`string`?e:``}function $e(e,t){let n=e.split(Ge).filter(Boolean),r=t.split(Ge).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 Z={alphanumeric:Ke,alphanumericCaseSensitive:qe,text:Je,textCaseSensitive:Ye,datetime:Xe,basic:Ze},et=[_e,Re,Ne,Pe,ye,ke,ze,Be,{getInitialState:e=>({sorting:[],...e}),getDefaultColumnDef:()=>({sortingFn:`auto`,sortUndefined:1}),getDefaultOptions:e=>({onSortingChange:D(`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 Z.datetime;if(typeof n==`string`&&(r=!0,n.split(Ge).length>1))return Z.alphanumeric}return r?Z.text:Z.basic},e.getAutoSortDir=()=>typeof t.getFilteredRowModel().flatRows[0]?.getValue(e.id)==`string`?`asc`:`desc`,e.getSortingFn=()=>{if(!e)throw Error();return O(e.columnDef.sortingFn)?e.columnDef.sortingFn:e.columnDef.sortingFn===`auto`?e.getAutoSortingFn():t.options.sortingFns?.[e.columnDef.sortingFn]??Z[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 tt(e){let t=[...et,...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=E(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:k(()=>[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}),A(e,`debugColumns`,`_getDefaultColumnDef`)),_getColumnDefs:()=>n.options.columns,getAllColumns:k(()=>[n._getColumnDefs()],e=>{let t=function(e,r,i){return i===void 0&&(i=0),e.map(e=>{let a=he(n,e,i,r),o=e;return a.columns=o.columns?t(o.columns,a,i+1):[],a})};return t(e)},A(e,`debugColumns`,`getAllColumns`)),getAllFlatColumns:k(()=>[n.getAllColumns()],e=>e.flatMap(e=>e.getFlatColumns()),A(e,`debugColumns`,`getAllFlatColumns`)),_getAllFlatColumnsById:k(()=>[n.getAllFlatColumns()],e=>e.reduce((e,t)=>(e[t.id]=t,e),{}),A(e,`debugColumns`,`getAllFlatColumnsById`)),getAllLeafColumns:k(()=>[n.getAllColumns(),n._getOrderColumnsFn()],(e,t)=>t(e.flatMap(e=>e.getLeafColumns())),A(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 nt(){return e=>k(()=>[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=ve(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},A(e.options,`debugTable`,`getRowModel`,()=>e._autoResetPageIndex()))}function rt(){return e=>k(()=>[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}},A(e.options,`debugTable`,`getSortedRowModel`,()=>e._autoResetPageIndex()))}function Q(){return!0}var it=Symbol(`merge-proxy`),at={get(e,t,n){return t===it?n:e.get(t)},has(e,t){return e.has(t)},set:Q,deleteProperty:Q,getOwnPropertyDescriptor(e,t){return{configurable:!0,enumerable:!0,get(){return e.get(t)},set:Q,deleteProperty:Q}},ownKeys(e){return e.keys()}};function ot(e){return`value`in e?e.value:e}function $(){var e=[...arguments];return new Proxy({get(t){for(let n=e.length-1;n>=0;n--){let r=ot(e[n])[t];if(r!==void 0)return r}},has(t){for(let n=e.length-1;n>=0;n--)if(t in ot(e[n]))return!0;return!1},keys(){let t=[];for(let n=0;n<e.length;n++)t.push(...Object.keys(ot(e[n])));return[...Array.from(new Set(t))]}},at)}var st=w({props:[`render`,`props`],setup:e=>()=>typeof e.render==`function`||typeof e.render==`object`?p(e.render,e.props):e.render});function ct(e){return $(e,{data:f(e.data)})}function lt(t){let n=h(t.data),r=tt($({state:{},onStateChange:()=>{},renderFallbackValue:null,mergeOptions(e,t){return n?{...e,...t}:$(e,t)}},n?ct(t):t));if(n){let e=te(t.data);d(e,()=>{r.setState(t=>({...t,data:e.value}))},{immediate:!0})}let i=l(r.initialState);return e(()=>{r.setOptions(e=>{let r=new Proxy({},{get:(e,t)=>i.value[t]});return $(e,n?ct(t):t,{state:$(r,t.state??{}),onStateChange:e=>{e instanceof Function?i.value=e(i.value):i.value=e,t.onStateChange==null||t.onStateChange(e)}})})}),r}var ut=[`aria-label`],dt=w({__name:`SortHeaderButton`,props:{header:{}},setup(e){let t=e,r=i(()=>t.header.column.getIsSorted()),a=i(()=>r.value===`asc`?m:r.value===`desc`?ee:ne),c=i(()=>{let e=t.header.column.columnDef.header;return typeof e==`string`?e:t.header.column.id}),l=i(()=>{let e=r.value===`asc`?`ascending`:r.value===`desc`?`descending`:`none`;return`Sort by ${c.value}, currently ${e}`});function d(){t.header.column.toggleSorting(r.value===`asc`)}return(t,i)=>{let c=s(`FontAwesomeIcon`);return S(),n(`button`,{type:`button`,"aria-label":l.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:d},[e.header.isPlaceholder?y(``,!0):(S(),u(f(st),{key:0,render:e.header.column.columnDef.header,props:e.header.getContext()},null,8,[`render`,`props`])),o(c,{icon:a.value,class:x([`size-3 shrink-0`,r.value?`text-foreground`:`text-muted-foreground/60`]),"aria-hidden":`true`},null,8,[`icon`,`class`])],8,ut)}}}),ft=w({__name:`DataTable`,props:{columns:{},data:{},rowClass:{type:Function},emptyMessage:{},sorting:{}},emits:[`update:sorting`],setup(e,{emit:r}){let i=e,s=r,c=l([]),d=lt({get data(){return i.data},get columns(){return i.columns},getCoreRowModel:nt(),getSortedRowModel:rt(),onSortingChange:e=>{let t=i.sorting??c.value,n=typeof e==`function`?e(t):e;i.sorting===void 0?c.value=n:s(`update:sorting`,n)},state:{get sorting(){return i.sorting??c.value}}});function p(e){if(e===`asc`)return`ascending`;if(e===`desc`)return`descending`}return(r,i)=>(S(),u(f(ae),null,{default:b(()=>[o(f(de),null,{default:b(()=>[(S(!0),n(_,null,t(f(d).getHeaderGroups(),e=>(S(),u(f(T),{key:e.id},{default:b(()=>[(S(!0),n(_,null,t(e.headers,e=>(S(),u(f(ue),{key:e.id,class:x(e.column.columnDef.meta?.align===`right`?`text-right`:void 0),"aria-sort":e.column.getCanSort()?p(e.column.getIsSorted())??`none`:void 0},{default:b(()=>[e.column.getCanSort()?(S(),u(dt,{key:0,header:e,class:`-mx-1.5`},null,8,[`header`])):e.isPlaceholder?y(``,!0):(S(),u(f(st),{key:1,render:e.column.columnDef.header,props:e.getContext()},null,8,[`render`,`props`]))]),_:2},1032,[`class`,`aria-sort`]))),128))]),_:2},1024))),128))]),_:1}),o(f(oe),null,{default:b(()=>[f(d).getRowModel().rows.length===0?(S(),u(f(le),{key:0,colspan:e.columns.length,class:`text-muted-foreground`},{default:b(()=>[a(g(e.emptyMessage??`none`),1)]),_:1},8,[`colspan`])):y(``,!0),(S(!0),n(_,null,t(f(d).getRowModel().rows,r=>(S(),u(f(T),{key:r.id,class:x(e.rowClass?.(r.original))},{default:b(()=>[(S(!0),n(_,null,t(r.getVisibleCells(),e=>(S(),u(f(se),{key:e.id,class:x(e.column.columnDef.meta?.align===`right`?`text-right tabular-nums`:void 0)},{default:b(()=>[o(f(st),{render:e.column.columnDef.cell,props:e.getContext()},null,8,[`render`,`props`])]),_:2},1032,[`class`]))),128))]),_:2},1032,[`class`]))),128))]),_:1})]),_:1}))}});export{rt as a,T as c,ae as d,nt as i,se as l,dt as n,de as o,lt as r,ue as s,ft as t,oe as u};",
+		),
+	},
+	"EntityLink-CovsFjEl.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"aW1wb3J0e0F0IGFzIGUsRHQgYXMgdCxMdCBhcyBuLE1uIGFzIHIsUnIgYXMgaSxVIGFzIGEsZGkgYXMgbyx0IGFzIHMsd24gYXMgYyx6dCBhcyBsfWZyb20iLi9uYXYtRHpiME9UTl8uanMiO3ZhciB1PVtgYXJpYS1sYWJlbGAsYHRpdGxlYF0sZD1sKHtfX25hbWU6YEVudGl0eUxpbmtgLHByb3BzOntsYWJlbDp7fSxraW5kOnt9LGlkOnt9fSxzZXR1cChsKXtsZXQgZD1sLGY9cygpLHA9e3VzZXI6e3BhZ2U6YGNvbnN1bWVyc2AscGFyYW1LZXk6YHVzZXJgLG5vdW46YENvbnN1bWVyc2B9LG1vZGVsOntwYWdlOmBtb2RlbHNgLHBhcmFtS2V5OmBtb2RlbGAsbm91bjpgTW9kZWxzYH19O2Z1bmN0aW9uIG0oZSl7ZS5zdG9wUHJvcGFnYXRpb24oKTtsZXQgdD1wW2Qua2luZF07Zi5nb1RvKHQucGFnZSx7W3QucGFyYW1LZXldOmQuaWR9KX1yZXR1cm4ocyxkKT0+e2xldCBmPXIoYEZvbnRBd2Vzb21lSWNvbmApO3JldHVybiBjKCksZShgYnV0dG9uYCx7dHlwZTpgYnV0dG9uYCwiYXJpYS1sYWJlbCI6YFZpZXcgJHtsLmxhYmVsfSBpbiAke3BbbC5raW5kXS5ub3VufWAsdGl0bGU6YFZpZXcgJHtsLmxhYmVsfSBpbiAke3BbbC5raW5kXS5ub3VufWAsY2xhc3M6YGlubGluZS1mbGV4IGN1cnNvci1wb2ludGVyIGl0ZW1zLWNlbnRlciBnYXAtMSByb3VuZGVkLXNtIHRleHQtaW5oZXJpdCBob3Zlcjp0ZXh0LXByaW1hcnkgaG92ZXI6dW5kZXJsaW5lIGZvY3VzLXZpc2libGU6b3V0bGluZS1ub25lIGZvY3VzLXZpc2libGU6cmluZy0yIGZvY3VzLXZpc2libGU6cmluZy1yaW5nLzUwYCxvbkNsaWNrOm19LFt0KGBzcGFuYCxudWxsLG8obC5sYWJlbCksMSksbihmLHtpY29uOmkoYSksY2xhc3M6YHNpemUtM2AsImFyaWEtaGlkZGVuIjpgdHJ1ZWB9LG51bGwsOCxbYGljb25gXSldLDgsdSl9fX0pO2V4cG9ydHtkIGFzIHR9Ow==",
+		),
+	},
+	"HomePage-9BEnKqFn.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{An as e,At as t,C as n,Dt as r,Et as i,It as a,Lt as o,Or as s,Ot as c,Pn as l,Qn as u,Rr as d,S as f,Sn as p,b as m,d as ee,di as h,g as te,gt as g,h as ne,kt as _,rr as v,si as y,t as b,v as x,vn as S,wn as C,x as w,y as re,zt as T}from"./nav-Dzb0OTN_.js";import{t as E}from"./index-BiTQ_gCE.js";import{f as D,i as O,o as k,t as ie}from"./badge-ns0j8OUr.js";import{n as ae,r as oe,t as se}from"./forecast-BMSkg5Xs.js";import{t as A}from"./EntityLink-CovsFjEl.js";import{t as ce}from"./events-BPFIBv4M.js";import{n as le,r as ue}from"./events-filter-XFnjIaR7.js";import{a as de,i as fe,n as pe,o as me,r as he,t as ge}from"./kpi-CU52LDmq.js";var j={class:`text-xs font-medium text-muted-foreground`},M={key:0,class:`text-xs text-muted-foreground`},N=T({__name:`KpiTile`,props:{label:{},value:{},delta:{},tier:{default:`ok`},to:{}},setup(e){let a=e,s=b(),u=i(()=>{switch(a.tier){case`warn`:return`text-status-warn`;case`critical`:return`text-destructive`;default:return`text-foreground`}});function p(){a.to&&s.goTo(a.to.page,a.to.params??{})}return(i,a)=>(C(),c(l(e.to?`button`:`div`),{type:e.to?`button`:void 0,class:y([`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:p},{default:v(()=>[o(d(n),null,{default:v(()=>[o(d(f),{class:`flex flex-col gap-1 px-4 py-3`},{default:v(()=>[r(`span`,j,h(e.label),1),r(`span`,{class:y([`text-2xl font-semibold tracking-tight tabular-nums`,u.value])},h(e.value),3),e.delta?(C(),t(`span`,M,h(e.delta),1)):_(``,!0)]),_:1})]),_:1})]),_:1},8,[`type`,`class`]))}}),P={key:0,class:`text-sm text-muted-foreground`},F={key:1,class:`flex flex-col gap-1.5`},I={class:`flex min-w-0 items-center gap-2`},L={class:`w-4 shrink-0 text-right text-xs text-muted-foreground`},R={class:`shrink-0 font-medium tabular-nums`},z=T({__name:`TopList`,props:{title:{},items:{},emptyText:{}},setup(i){return(s,l)=>(C(),c(d(n),null,{default:v(()=>[o(d(w),null,{default:v(()=>[o(d(m),null,{default:v(()=>[a(h(i.title),1)]),_:1})]),_:1}),o(d(f),null,{default:v(()=>[i.items.length===0?(C(),t(`p`,P,h(i.emptyText),1)):(C(),t(`ol`,F,[(C(!0),t(g,null,e(i.items,(e,n)=>(C(),t(`li`,{key:e.id,class:`flex items-center justify-between gap-3 text-sm`},[r(`span`,I,[r(`span`,L,h(n+1),1),o(A,{label:e.label,kind:e.kind,id:e.id,class:`min-w-0 truncate`},null,8,[`label`,`kind`,`id`])]),r(`span`,R,h(e.value),1)]))),128))]))]),_:1})]),_:1}))}}),_e={class:`flex flex-col gap-4`},ve={"aria-label":`Key metrics`,class:`grid grid-cols-2 gap-3 sm:grid-cols-3 lg:grid-cols-4`},ye={key:0,class:`text-sm text-destructive`},be={"aria-label":`Top spenders and models`,class:`grid grid-cols-1 gap-3 lg:grid-cols-2`},xe={key:0,class:`text-sm text-muted-foreground`},Se={key:1,class:`flex flex-col gap-2`},Ce={class:`flex min-w-0 items-center gap-2`},we={class:`min-w-0 truncate text-muted-foreground`},Te={class:`shrink-0 tabular-nums text-muted-foreground`},B=5,Ee=6e4,V=T({__name:`HomePage`,setup(c){let l=re(),y=ne(),b=ce(),T=E(),A=i(()=>y.usage?.total.costPerDayMicroUsd??0),j=i(()=>y.usage?.total.costPerMonthMicroUsd??0),M=i(()=>me(y.overview?.groups??[])),P=i(()=>pe(ge(j.value,M.value))),F=i(()=>{let e=`${k(A.value)} today`;return M.value>0?`${e} · budget ${k(M.value)}/mo`:`${e} · no budget set`}),I=i(()=>oe(j.value,ae(new Date))),L=i(()=>se(I.value,M.value>0?M.value/1e6:void 0)),R=i(()=>I.value===null?`not enough data yet`:k(I.value)),V=i(()=>L.value.willExceed?`critical`:`ok`),De=i(()=>{if(I.value!==null)return M.value<=0?`no budget set`:L.value.willExceed?`projected to exceed budget`:`projected within budget`}),Oe=i(()=>y.usage?.total.requestsPerMinute??0),H=i(()=>fe(y.overview?.providers??[])),ke=i(()=>he(H.value.rate)),Ae=i(()=>{let e=H.value.rate;return e===null?`no traffic`:e<=0?`0%`:`${Math.ceil(e*100)}%`}),U=i(()=>`${H.value.failures}/${H.value.attempts} attempts in the last minute`),W=i(()=>de(y.overview?.providers??[])),G=i(()=>y.overview?.warnings.length??0),K=i(()=>y.overview?.pricing.unpriced??0),q=s([]),J=s([]),Y=s(``),X=0;async function Z(){if(!l.isAuthenticated)return;let e=++X;try{let[t,n]=await Promise.all([x(ee({kind:`user`,window:T.window,span:T.span,metrics:[`cost`],limit:B})),x(`/admin/api/usage/models?metric=cost&window=${T.window}&span=${T.span}&limit=${B}`)]);if(e!==X)return;q.value=t.rows.map(e=>({id:e.id,label:e.id,value:k(e.values.cost??0),kind:`user`})),J.value=n.models.map(e=>({id:e.id,label:e.id,value:k(e.value),kind:`model`})),Y.value=``}catch(t){if(e!==X)return;Y.value=t instanceof Error?t.message:String(t)}}let Q;u(()=>T.range,()=>void Z());function je(e){return le[e]??e}let $=i(()=>b.events.slice(0,8));return S(()=>{b.startPolling(),Q=te({intervalMs:Ee,tick:()=>void Z()}),Q.start()}),p(()=>{b.stopPolling(),Q?.stop()}),(i,s)=>(C(),t(`div`,_e,[r(`section`,ve,[o(N,{label:`Spend (MTD)`,value:d(k)(j.value),delta:F.value,tier:P.value,to:{page:`spend`}},null,8,[`value`,`delta`,`tier`]),o(N,{label:`Projected month-end`,value:R.value,delta:De.value,tier:V.value,to:{page:`spend`}},null,8,[`value`,`delta`,`tier`]),o(N,{label:`Requests/min`,value:d(O)(Oe.value)},null,8,[`value`]),o(N,{label:`Error rate (last minute)`,value:Ae.value,delta:U.value,tier:ke.value,to:{page:`reliability`}},null,8,[`value`,`delta`,`tier`]),o(N,{label:`Open breakers (per replica)`,value:String(W.value),tier:W.value>0?`warn`:`ok`,to:{page:`models`}},null,8,[`value`,`tier`]),o(N,{label:`Config warnings`,value:String(G.value),tier:G.value>0?`warn`:`ok`,to:{page:`config`}},null,8,[`value`,`tier`]),o(N,{label:`Unpriced models`,value:String(K.value),tier:K.value>0?`warn`:`ok`,to:{page:`spend`}},null,8,[`value`,`tier`])]),Y.value?(C(),t(`p`,ye,`Top lists failed to load: `+h(Y.value),1)):_(``,!0),r(`section`,be,[o(z,{title:`Top 5 users by cost`,items:q.value,"empty-text":`No spend in this range yet.`},null,8,[`items`]),o(z,{title:`Top 5 models by cost`,items:J.value,"empty-text":`No spend in this range yet.`},null,8,[`items`])]),o(d(n),null,{default:v(()=>[o(d(w),null,{default:v(()=>[o(d(m),null,{default:v(()=>[...s[0]||=[a(`Latest events`,-1)]]),_:1})]),_:1}),o(d(f),null,{default:v(()=>[$.value.length===0?(C(),t(`p`,xe,`No events recorded yet.`)):(C(),t(`ol`,Se,[(C(!0),t(g,null,e($.value,(e,n)=>(C(),t(`li`,{key:`${e.time}-${e.replica}-${n}`,class:`flex items-start justify-between gap-3 text-sm`},[r(`span`,Ce,[o(d(ie),{variant:d(ue)(e.kind),class:`shrink-0 font-normal`},{default:v(()=>[a(h(je(e.kind)),1)]),_:2},1032,[`variant`]),r(`span`,we,h(e.message),1)]),r(`span`,Te,h(d(D)(e.time)),1)]))),128))]))]),_:1})]),_:1})]))}});export{V as default};",
+		),
+	},
+	"ModelsPage-3Nt3gvlN.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{An as e,At as t,C as n,Dt as r,Er as i,Et as a,It as o,J as s,Lt as c,Mn as l,Ot as u,Qn as d,Rr as f,S as p,X as m,Xt as h,_ as ee,b as g,br as te,di as _,gt as v,h as ne,kt as y,lt as re,ot as ie,rr as b,si as x,t as ae,v as S,vn as C,wn as w,x as T,zt as E}from"./nav-Dzb0OTN_.js";import{d as oe,t as D,u as se}from"./CardDescription-IdOt317c.js";import{a as ce,c as O,i as le,n as ue,o as de,r as fe,s as pe,t as me}from"./search-expand-B1qnK1H5.js";import{t as k}from"./index-BiTQ_gCE.js";import{t as he}from"./DataTable-DVueNFuA.js";import{a as ge,d as A,g as j,h as _e,l as M,m as ve,n as ye,o as N,p as be,t as P}from"./badge-ns0j8OUr.js";import{t as F}from"./CompactNumber-B1ihQZH7.js";import{n as xe,t as Se}from"./useSearchQuery-DysBt-In.js";import{t as Ce}from"./EntityLink-CovsFjEl.js";import{a as I,c as L,i as we,n as Te,o as R,r as z,s as Ee,t as B}from"./provider-rate-DU7OgSeB.js";import{t as V}from"./catalog-C-TfKLVZ.js";import{t as H}from"./reliability-0KiJSjTP.js";function U(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 De(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 W={override:`override`,builtin:`builtin`,litellm:`litellm`};function Oe(e){if(e.priceSource===`unpriced`)return h(P,{as:`span`,variant:`destructive`,class:`font-normal`,title:`No pricing rule matched — billed as $0.`},()=>`unpriced`);if(e.priceSource===`free`)return h(P,{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 h(`span`,{class:`inline-flex flex-wrap items-center gap-1.5`},[h(`span`,{},t?A(e.inputPerMTokUsd,e.outputPerMTokUsd):`—`),h(P,{as:`span`,variant:`outline`,class:`font-normal`},()=>W[n])])}function ke(e){return e.priceSource===`unpriced`?-1:e.inputPerMTokUsd??0}function G(){return[{id:`id`,header:`Model`,accessorFn:e=>e.id,cell:({row:e})=>h(`span`,{class:`inline-flex flex-wrap items-center gap-1.5`},[h(O,{id:e.original.id,contextTokens:e.original.contextTokens,inputPerMTokUsd:e.original.inputPerMTokUsd,outputPerMTokUsd:e.original.outputPerMTokUsd}),h(Ce,{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})=>h(`span`,{class:`tabular-nums`},e.original.contextTokens===void 0?`—`:ge(e.original.contextTokens))},{id:`price`,header:`Price`,accessorFn:e=>ke(e),cell:({row:e})=>Oe(e.original)},{id:`free`,header:`Free`,accessorFn:e=>+!!e.displayFree,cell:({row:e})=>e.original.displayFree?h(P,{as:`span`,variant:`secondary`,class:`font-normal`,title:`':free' suffix model — display-only, billing follows the Price column's own source`},()=>`free`):h(`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?h(`span`,{class:`text-muted-foreground`},`—`):h(`div`,{class:`flex flex-wrap gap-1`},t.map(e=>h(P,{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})=>h(F,{value:e.original.requests})},{id:`tokensIn`,header:`Tokens in`,meta:{align:`right`},accessorFn:e=>e.tokensIn,cell:({row:e})=>h(F,{value:e.original.tokensIn})},{id:`tokensOut`,header:`Tokens out`,meta:{align:`right`},accessorFn:e=>e.tokensOut,cell:({row:e})=>h(F,{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?h(P,{as:`span`,variant:`secondary`,class:`font-normal`,title:`priced at $0 per token`},()=>`free`):N(t.costMicroUsd)}},{id:`p50`,header:`p50`,meta:{align:`right`},accessorFn:e=>e.p50Ms??-1,cell:({row:e})=>h(`span`,{class:`tabular-nums`},e.original.p50Ms===void 0?`—`:M(e.original.p50Ms))},{id:`p95`,header:`p95`,meta:{align:`right`},accessorFn:e=>e.p95Ms??-1,cell:({row:e})=>h(`span`,{class:`tabular-nums`},e.original.p95Ms===void 0?`—`:M(e.original.p95Ms))},{id:`errorRate`,header:`Error rate`,meta:{align:`right`},accessorFn:e=>R(e.attempts,e.failures)??-1,cell:({row:e})=>h(`span`,{class:`tabular-nums`},Te(R(e.original.attempts,e.original.failures)))}]}var Ae=E({__name:`ModelCatalogTable`,props:{rows:{},query:{},latencyEnabled:{type:Boolean},loading:{type:Boolean}},emits:[`update:query`],setup(e,{emit:t}){let i=e,s=t,l=a(()=>U(i.rows,i.query)),d=G(),m=a(()=>i.loading?`loading…`:i.rows.length===0?`no models configured`:i.query.trim()?`no models match "${i.query}"`:`none`);return(t,i)=>(w(),u(f(n),null,{default:b(()=>[c(f(T),null,{default:b(()=>[c(f(g),null,{default:b(()=>[...i[1]||=[o(`Model catalog`,-1)]]),_:1}),c(f(D),null,{default:b(()=>[...i[2]||=[o(` Every configured model: price source, per-model usage for the current range, fleet p50/p95, and error rate. `,-1)]]),_:1}),c(xe,{"model-value":e.query,placeholder:`Search models or aliases...`,class:`mt-2 max-w-sm`,"onUpdate:modelValue":i[0]||=e=>s(`update:query`,e)},null,8,[`model-value`])]),_:1}),c(f(p),{class:`flex flex-col gap-3`},{default:b(()=>[e.latencyEnabled?y(``,!0):(w(),u(f(oe),{key:0,variant:`warn`},{default:b(()=>[c(f(se),null,{default:b(()=>[...i[3]||=[o(` Latency percentiles (p50/p95) are off for this deployment. Enable `,-1),r(`code`,null,`admin.stats.latency`,-1),o(` to see them. `,-1)]]),_:1})]),_:1})),c(he,{columns:f(d),data:l.value,"empty-message":m.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1}))}}),K={"aria-hidden":`true`},je={class:`sr-only`},Me=E({__name:`ProviderRateBadge`,props:{attemptsDay:{},failuresDay:{},attemptsMinute:{},failuresMinute:{}},setup(e){let t=e,n=a(()=>L(t.attemptsDay,t.failuresDay)),i=a(()=>Ee(n.value)),o=a(()=>i.value===`no-traffic`?`no traffic`:z(n.value)),s=a(()=>t.attemptsMinute===void 0||t.failuresMinute===void 0?B(t.attemptsDay,t.failuresDay):I(t.attemptsMinute,t.failuresMinute)),c=a(()=>i.value===`severe`?`destructive`:i.value===`healthy`?`secondary`:`outline`),l=a(()=>i.value===`degraded`?`border-status-warn/40 text-status-warn`:i.value===`no-traffic`?`text-muted-foreground`:``);return(e,t)=>(w(),u(f(P),{as:`span`,variant:c.value,class:x([l.value,`font-normal tabular-nums`]),title:s.value},{default:b(()=>[r(`span`,K,_(o.value),1),r(`span`,je,_(s.value),1)]),_:1},8,[`variant`,`class`,`title`]))}}),Ne=re(`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=V(),n=k();if(await t.ensureLoaded(),e!==this.reqId)return;if(!t.data){this.error=t.error||`catalog unavailable`;return}let r=H(n.window,n.span),[i,a,o]=await Promise.all([S(`/admin/api/usage/models?window=${n.window}&span=${n.span}&limit=100&detail=1&metric=req`),S(`/admin/api/performance?kind=model&window=${r.window}&span=${r.span}`),S(`/admin/api/performance?kind=provider&window=${r.window}&span=${r.span}`)]);if(e!==this.reqId)return;this.rows=De(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 ee&&(t.status===401||t.status===403))return;this.error=t instanceof Error?t.message:String(t)}finally{e===this.reqId&&(this.loading=!1)}}}}),Pe={class:`flex flex-col gap-6`},Fe={class:`grid gap-4 sm:grid-cols-3`},Ie={class:`font-medium`},Le={key:0,class:`flex items-start gap-1.5 text-destructive`},Re={class:`font-medium`},ze={key:0,class:`text-muted-foreground`},Be={class:`font-medium`},Ve={key:0,class:`text-muted-foreground`},He={key:1,class:`py-6 text-center text-sm text-muted-foreground`},Ue={key:2,class:`py-6 text-center text-sm text-muted-foreground`},We={class:`text-xs text-muted-foreground`},Ge={class:`flex items-center gap-2`},Ke=[`aria-label`,`title`,`onClick`],qe={class:`sr-only`},Je={class:`flex flex-1 flex-wrap items-center gap-x-3 gap-y-1 pr-2 text-left`},Ye={class:`text-xs text-muted-foreground tabular-nums`},Xe={class:`text-xs text-muted-foreground`},Ze={class:`mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-3`},Qe={class:`break-all`},$e={key:0},et={key:1},tt={class:`text-destructive`},nt={key:0,class:`flex flex-wrap gap-1.5`},rt={key:0,title:`context window`,class:`text-xs text-muted-foreground tabular-nums`},it={key:1,class:`text-sm text-muted-foreground`},at={key:0,class:`text-xs text-muted-foreground`},q=E({__name:`ProviderHealthPanel`,setup(ee){let re=ne(),S=Ne(),C=a(()=>re.overview),E=ae();function k(e){E.goTo(`models`,{q:`${e}/`})}let A=i({manuallyExpanded:new Set,manuallyCollapsed:new Set}),{query:N,normalized:F,hasQuery:I}=Se();function L(e,t){return j(e,t).toLowerCase().includes(F.value)}function Te(e){return e.models.some(t=>L(e.name,t))}function R(e){return e.alias.toLowerCase().includes(F.value)||e.target.toLowerCase().includes(F.value)}let z=a(()=>{let e=C.value?.providers??[];return I.value?e.filter(Te):e}),Ee=a(()=>{let e=C.value?.aliases??[];return I.value?e.filter(R):e}),B=a(()=>ue(A,I.value,z.value.map(e=>e.name)));function V(e){fe(A,e,B.value.has(e))}let H=a({get:()=>Array.from(B.value),set:e=>{let t=new Set(e);for(let e of B.value)t.has(e)||V(e);for(let e of t)B.value.has(e)||V(e)}});d(N,e=>{e.trim()===``&&me(A)});function U(e){return I.value?e.models.filter(t=>L(e.name,t)):e.models}let De={attemptsDay:0,failuresDay:0};function W(e,t){return e.modelRates?.[t]??De}function Oe(e,t){let n=W(e,t);return we(n.attemptsDay,n.failuresDay)}let ke={};function G(e,t){return e.modelMeta?.[t]??ke}function Ae(e){switch(e){case`open`:return`destructive`;case`half-open`:return`secondary`;default:return}}function K(e){let t=be(e.openUntil);return t?`${e.healthState} (${t})`:e.healthState}function je(e){return e===`open`?`text-destructive`:`text-muted-foreground`}function q(e){return e.latency?.streaming}function J(e){return e.latency?.[`non-streaming`]}function Y(e){return e.count===void 0?`no observations counted`:`${e.count} ${e.count===1?`observation`:`observations`} on this replica`}function X(){let e=C.value?.replica;return`Per-replica (${e?`replica ${e}`:`this replica`}), in-process only — not a fleet-wide average across this deployment’s replicas.`}function ot(e){return`Average time to first byte, the load-sensitive reading for streaming traffic. ${Y(e)}. ${X()}`}function st(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. ${Y(e)}. ${X()}`}function Z(e){return e.provenance?.estimated}function Q(e){return e.provenance?.unbilled}function ct(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. ${X()}`}function lt(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. ${X()}`}function $(e){return S.providerPerf.find(t=>t.id===e)}function ut(e){let{window:t,span:n}=S.perfWindow;return`Fleet-wide (every replica combined) ${e===`p50`?`median`:`95th percentile`} response time, over the last ${n} ${t}${n===1?``:`s`}.`}function dt(e){let{window:t,span:n}=S.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 ft=[{id:`alias`,header:`Alias`,accessorFn:e=>e.alias,cell:({row:e})=>h(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})=>h(`span`,{class:`text-muted-foreground`},e.original.target)}],pt=a(()=>C.value?.aliases.length?I.value?`no aliases match "${N.value}"`:`none`:`none configured`);return(i,a)=>{let d=l(`FontAwesomeIcon`);return w(),t(`div`,Pe,[r(`div`,Fe,[c(f(n),null,{default:b(()=>[c(f(T),null,{default:b(()=>[c(f(g),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:b(()=>[c(d,{icon:C.value?.redis.configured?f(s):f(m),class:x([C.value?.redis.configured?`text-chart-requests`:`text-muted-foreground`,`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),a[2]||=o(` Redis `,-1)]),_:1})]),_:1}),c(f(p),{class:`flex flex-col gap-1 text-sm`},{default:b(()=>[r(`p`,Ie,_(C.value?.redis.configured?`Configured`:`Not configured`),1),C.value?.redis.lastErr?(w(),t(`p`,Le,[c(d,{icon:f(ie),class:`mt-0.5 size-3.5 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),r(`span`,null,_(C.value.redis.lastErr)+_(f(ye)(C.value.redis.lastErrAt)),1)])):y(``,!0)]),_:1})]),_:1}),c(f(n),null,{default:b(()=>[c(f(T),null,{default:b(()=>[c(f(g),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:b(()=>[c(d,{icon:C.value?.cache.enabled?f(s):f(m),class:x([C.value?.cache.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),a[3]||=o(` Response cache `,-1)]),_:1})]),_:1}),c(f(p),{class:`text-sm`},{default:b(()=>[r(`p`,Re,_(C.value?.cache.enabled?`Enabled`:`Disabled`),1),C.value?.cache.enabled?(w(),t(`p`,ze,`ttl `+_(C.value.cache.ttl),1)):y(``,!0)]),_:1})]),_:1}),c(f(n),null,{default:b(()=>[c(f(T),null,{default:b(()=>[c(f(g),{class:`flex items-center gap-2 text-sm font-medium text-muted-foreground`},{default:b(()=>[c(d,{icon:C.value?.retry.enabled?f(s):f(m),class:x([C.value?.retry.enabled?`text-chart-requests`:`text-muted-foreground`,`size-3.5`]),"aria-hidden":`true`},null,8,[`icon`,`class`]),a[4]||=o(` Retry `,-1)]),_:1})]),_:1}),c(f(p),{class:`text-sm`},{default:b(()=>[r(`p`,Be,_(C.value?.retry.enabled?`Enabled`:`Disabled`),1),C.value?.retry.enabled?(w(),t(`p`,Ve,` attempts `+_(C.value.retry.attempts)+`, backoff `+_(C.value.retry.backoff),1)):y(``,!0)]),_:1})]),_:1})]),c(f(n),null,{default:b(()=>[c(f(T),null,{default:b(()=>[c(f(g),null,{default:b(()=>[...a[5]||=[o(`Providers`,-1)]]),_:1}),c(f(D),null,{default:b(()=>[...a[6]||=[o(` Every configured upstream, its last discovery refresh, and fleet-wide performance. Search filters providers and aliases by model id. `,-1)]]),_:1}),c(xe,{modelValue:f(N),"onUpdate:modelValue":a[0]||=e=>te(N)?N.value=e:null,placeholder:`Search models or aliases...`,class:`mt-2 max-w-sm`},null,8,[`modelValue`])]),_:1}),c(f(p),{class:`flex flex-col gap-3`},{default:b(()=>[f(S).latencyEnabled?y(``,!0):(w(),u(f(oe),{key:0,variant:`warn`},{default:b(()=>[c(f(se),null,{default:b(()=>[...a[7]||=[o(` Fleet p50/p95 are off for this deployment. Enable `,-1),r(`code`,null,`admin.stats.latency`,-1),o(` to see them. `,-1)]]),_:1})]),_:1})),C.value?.providers.length?f(I)&&z.value.length===0?(w(),t(`p`,Ue,` no providers match "`+_(f(N))+`" `,1)):(w(),t(v,{key:3},[r(`p`,We,_(X())+` Fleet p50/p95/timeouts/failovers below are fleet-wide, not per-replica.`,1),c(f(pe),{modelValue:H.value,"onUpdate:modelValue":a[1]||=e=>H.value=e,type:`multiple`,class:`rounded-md border px-3`},{default:b(()=>[(w(!0),t(v,null,e(z.value,n=>(w(),u(f(ce),{key:n.name,value:n.name},{default:b(()=>[r(`div`,Ge,[r(`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 ${n.name}'s models in the Models table`,title:`View ${n.name}'s models in the Models table`,onClick:e=>k(n.name)},_(n.name),9,Ke),c(f(le),{"header-class":`flex-1`},{default:b(()=>[r(`span`,qe,`Provider `+_(n.name)+` details`,1),r(`span`,Je,[c(f(P),{as:`span`,variant:`secondary`,class:`font-normal`},{default:b(()=>[o(_(n.type),1)]),_:2},1024),r(`span`,Ye,_(n.modelCount)+` models`,1),c(Me,{"attempts-day":n.attemptsDay,"failures-day":n.failuresDay,"attempts-minute":n.attemptsMinute,"failures-minute":n.failuresMinute},null,8,[`attempts-day`,`failures-day`,`attempts-minute`,`failures-minute`]),n.healthState===`closed`?y(``,!0):(w(),u(f(P),{key:0,as:`span`,variant:Ae(n.healthState),class:`font-normal`,title:n.healthState===`open`?`discovery is backing off after repeated failures`:`a discovery probe is deciding whether to recover`},{default:b(()=>[o(_(K(n)),1)]),_:2},1032,[`variant`,`title`])),q(n)?.avgTtfbMs===void 0?y(``,!0):(w(),u(f(P),{key:1,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:ot(q(n))},{default:b(()=>[o(` streaming ttfb `+_(f(M)(q(n).avgTtfbMs)),1)]),_:2},1032,[`title`])),J(n)?.avgDurationMs===void 0?y(``,!0):(w(),u(f(P),{key:2,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:st(J(n))},{default:b(()=>[o(` non-streaming avg `+_(f(M)(J(n).avgDurationMs)),1)]),_:2},1032,[`title`])),$(n.name)?.p50Ms===void 0?y(``,!0):(w(),u(f(P),{key:3,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:ut(`p50`)},{default:b(()=>[o(` fleet p50 `+_(f(M)($(n.name).p50Ms)),1)]),_:2},1032,[`title`])),$(n.name)?.p95Ms===void 0?y(``,!0):(w(),u(f(P),{key:4,as:`span`,variant:`outline`,class:`font-normal tabular-nums`,title:ut(`p95`)},{default:b(()=>[o(` fleet p95 `+_(f(M)($(n.name).p95Ms)),1)]),_:2},1032,[`title`])),($(n.name)?.timeouts??0)>0?(w(),u(f(P),{key:5,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:dt(`timeouts`)},{default:b(()=>[o(_($(n.name).timeouts)+` timeouts `,1)]),_:2},1032,[`title`])):y(``,!0),($(n.name)?.failovers??0)>0?(w(),u(f(P),{key:6,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:dt(`failovers`)},{default:b(()=>[o(_($(n.name).failovers)+` failovers `,1)]),_:2},1032,[`title`])):y(``,!0),Z(n)?(w(),u(f(P),{key:7,as:`span`,variant:`secondary`,class:`font-normal tabular-nums`,title:ct(Z(n))},{default:b(()=>[o(` estimated `+_(Z(n).requests),1)]),_:2},1032,[`title`])):y(``,!0),Q(n)?(w(),u(f(P),{key:8,as:`span`,variant:`destructive`,class:`font-normal tabular-nums`,title:lt(Q(n))},{default:b(()=>[o(` unbilled `+_(Q(n).requests),1)]),_:2},1032,[`title`])):y(``,!0),n.lastErr?(w(),u(d,{key:9,icon:f(ie),class:`size-3.5 shrink-0 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):y(``,!0),r(`span`,Xe,_(f(_e)(n.discoveryEnabled,n.lastRefresh)),1)])]),_:2},1024)]),c(f(de),null,{default:b(()=>[r(`dl`,Ze,[r(`div`,null,[a[8]||=r(`dt`,{class:`text-xs text-muted-foreground`},`Base URL`,-1),r(`dd`,Qe,_(n.baseUrl),1)]),r(`div`,null,[a[9]||=r(`dt`,{class:`text-xs text-muted-foreground`},`Last refresh`,-1),r(`dd`,null,_(f(ve)(n.discoveryEnabled,n.lastRefresh)),1)]),n.healthState===`closed`?y(``,!0):(w(),t(`div`,$e,[a[10]||=r(`dt`,{class:`text-xs text-muted-foreground`},`Discovery health`,-1),r(`dd`,{class:x(je(n.healthState))},_(K(n)),3)])),n.lastErr?(w(),t(`div`,et,[a[11]||=r(`dt`,{class:`text-xs text-muted-foreground`},`Last error`,-1),r(`dd`,tt,_(n.lastErr),1)])):y(``,!0)]),U(n).length?(w(),t(`div`,nt,[(w(!0),t(v,null,e(U(n),e=>(w(),t(`span`,{key:e,class:`inline-flex items-center gap-1`},[c(O,{id:f(j)(n.name,e),"context-tokens":G(n,e).contextTokens,"input-per-m-tok-usd":G(n,e).inputPerMTokUsd,"output-per-m-tok-usd":G(n,e).outputPerMTokUsd},null,8,[`id`,`context-tokens`,`input-per-m-tok-usd`,`output-per-m-tok-usd`]),c(Ce,{label:f(j)(n.name,e),kind:`model`,id:f(j)(n.name,e)},null,8,[`label`,`id`]),G(n,e).contextTokens===void 0?y(``,!0):(w(),t(`span`,rt,_(f(ge)(G(n,e).contextTokens)),1)),Oe(n,e)?(w(),u(Me,{key:1,"attempts-day":W(n,e).attemptsDay,"failures-day":W(n,e).failuresDay},null,8,[`attempts-day`,`failures-day`])):y(``,!0)]))),128))])):(w(),t(`p`,it,`no models known yet`))]),_:2},1024)]),_:2},1032,[`value`]))),128))]),_:1},8,[`modelValue`])],64)):(w(),t(`p`,He,`none`))]),_:1})]),_:1}),c(f(n),null,{default:b(()=>[c(f(T),null,{default:b(()=>[c(f(g),null,{default:b(()=>[...a[12]||=[o(`Model aliases`,-1)]]),_:1}),c(f(D),null,{default:b(()=>[...a[13]||=[o(`Operator-defined alias → target model mappings.`,-1)]]),_:1})]),_:1}),c(f(p),null,{default:b(()=>[c(he,{columns:ft,data:Ee.value,"empty-message":pt.value},null,8,[`data`,`empty-message`])]),_:1})]),_:1}),C.value?.version?(w(),t(`p`,at,`Version: `+_(C.value.version),1)):y(``,!0)])}}}),J={class:`flex flex-col gap-6`},Y={key:0,class:`text-sm text-destructive`},X=E({__name:`ModelsPage`,setup(e){let n=k(),r=Ne(),i=ae(),o=a({get:()=>i.params.q??i.params.model??``,set:e=>{let{model:t,...n}=i.params;i.goTo(`models`,{...n,q:e})}});return C(()=>void r.fetch()),d(()=>n.range,()=>void r.fetch()),(e,n)=>(w(),t(`div`,J,[c(q),f(r).error?(w(),t(`p`,Y,_(f(r).error),1)):y(``,!0),c(Ae,{rows:f(r).rows,query:o.value,"latency-enabled":f(r).latencyEnabled,loading:f(r).loading,"onUpdate:query":n[0]||=e=>o.value=e},null,8,[`rows`,`query`,`latency-enabled`,`loading`])]))}});export{X as default};",
+		),
+	},
+	"Presence-CuQUGFyS.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{$n as e,$t as t,An as n,Ar as r,At as i,Bn as a,Bt as o,Cn as s,Cr as c,Ct as l,Dn as u,Dr as d,Dt as f,E as p,En as m,Er as h,Et as g,Fn as ee,Fr as _,Ft as v,Gn as y,Gt as b,Hn as te,Hr as ne,Ht as re,In as ie,Ir as ae,It as oe,Jn as se,Jt as ce,Kn as le,Kt as ue,Ln as de,Lr as x,Lt as fe,Mn as pe,Mr as me,Mt as he,Nn as ge,Nr as _e,Nt as ve,On as S,Or as C,Ot as w,Pn as T,Pr as E,Pt as D,Qn as O,Qt as k,Rn as A,Rr as j,Rt as M,Sn as N,Sr as P,St as F,Tn as ye,Tr as be,Tt as xe,Un as Se,Ut as Ce,Vn as we,Vr as I,Vt as Te,Wn as L,Wt as Ee,Xn as De,Xt as R,Yn as Oe,Yt as ke,Zn as Ae,Zt as je,_n as Me,_r as Ne,_t as Pe,an as Fe,ar as Ie,bn as Le,br as Re,bt as ze,cn as Be,cr as Ve,di as He,dn as z,dr as Ue,dt as We,en as Ge,er as Ke,fi as B,fn as qe,fr as Je,ft as Ye,gn as Xe,gr as Ze,gt as Qe,hn as $e,hr as et,ht as tt,in as V,ir as nt,jn as rt,jr as it,jt as at,k as ot,kn as st,kr as ct,kt as lt,li as ut,ln as dt,lr as ft,mn as pt,mr as mt,mt as ht,nn as gt,nr as _t,on as vt,or as yt,pn as bt,pr as xt,pt as St,qn as Ct,qt as H,rn as wt,rr as Tt,si as Et,sn as Dt,sr as Ot,tn as kt,tr as At,ui as jt,un as Mt,ur as Nt,vn as Pt,vr as Ft,vt as It,wn as Lt,wr as Rt,wt as zt,xn as Bt,xr as Vt,xt as Ht,yn as Ut,yr as Wt,yt as Gt,zn as Kt,zt as U}from"./nav-Dzb0OTN_.js";import{A as qt,C as Jt,D as Yt,E as Xt,F as Zt,M as Qt,N as $t,O as en,P as tn,S as nn,T as rn,_ as an,a as W,b as on,f as sn,g as cn,h as ln,j as un,k as dn,m as fn,p as pn,r as mn,v as hn,w as gn,x as _n,y as vn}from"./CardDescription-IdOt317c.js";var G=Object.defineProperty,yn=((e,t)=>{let n={};for(var r in e)G(n,r,{get:e[r],enumerable:!0});return t||G(n,Symbol.toStringTag,{value:`Module`}),n})({BaseTransition:()=>We,BaseTransitionPropsValidators:()=>Ye,Comment:()=>St,DeprecationTypes:()=>null,EffectScope:()=>Ve,ErrorCodes:()=>ht,ErrorTypeStrings:()=>tt,Fragment:()=>Qe,KeepAlive:()=>Pe,ReactiveEffect:()=>ft,Static:()=>It,Suspense:()=>Gt,Teleport:()=>ze,Text:()=>Ht,TrackOpTypes:()=>Nt,Transition:()=>sn,TransitionGroup:()=>pn,TriggerOpTypes:()=>Ue,VueElement:()=>fn,assertNumber:()=>F,callWithAsyncErrorHandling:()=>l,callWithErrorHandling:()=>zt,camelize:()=>I,capitalize:()=>ne,cloneVNode:()=>xe,compatUtils:()=>null,compile:()=>bn,computed:()=>g,createApp:()=>ln,createBlock:()=>w,createCommentVNode:()=>lt,createElementBlock:()=>i,createElementVNode:()=>f,createHydrationRenderer:()=>at,createPropsRestProxy:()=>he,createRenderer:()=>ve,createSSRApp:()=>cn,createSlots:()=>D,createStaticVNode:()=>v,createTextVNode:()=>oe,createVNode:()=>fe,customRef:()=>Je,defineAsyncComponent:()=>M,defineComponent:()=>U,defineCustomElement:()=>an,defineEmits:()=>o,defineExpose:()=>Te,defineModel:()=>re,defineOptions:()=>Ce,defineProps:()=>Ee,defineSSRCustomElement:()=>hn,defineSlots:()=>b,devtools:()=>ue,effect:()=>xt,effectScope:()=>mt,getCurrentInstance:()=>H,getCurrentScope:()=>et,getCurrentWatcher:()=>Ze,getTransitionRawChildren:()=>ce,guardReactiveProps:()=>ke,h:()=>R,handleError:()=>je,hasInjectionContext:()=>k,hydrate:()=>vn,hydrateOnIdle:()=>t,hydrateOnInteraction:()=>Ge,hydrateOnMediaQuery:()=>kt,hydrateOnVisible:()=>gt,initCustomFormatter:()=>wt,initDirectivesForSSR:()=>on,inject:()=>V,isMemoSame:()=>Fe,isProxy:()=>Ne,isReactive:()=>Ft,isReadonly:()=>Wt,isRef:()=>Re,isRuntimeOnly:()=>vt,isShallow:()=>Vt,isVNode:()=>Dt,markRaw:()=>P,mergeDefaults:()=>Be,mergeModels:()=>dt,mergeProps:()=>Mt,nextTick:()=>z,nodeOps:()=>_n,normalizeClass:()=>Et,normalizeProps:()=>ut,normalizeStyle:()=>jt,onActivated:()=>qe,onBeforeMount:()=>bt,onBeforeUnmount:()=>pt,onBeforeUpdate:()=>$e,onDeactivated:()=>Xe,onErrorCaptured:()=>Me,onMounted:()=>Pt,onRenderTracked:()=>Ut,onRenderTriggered:()=>Le,onScopeDispose:()=>c,onServerPrefetch:()=>Bt,onUnmounted:()=>N,onUpdated:()=>s,onWatcherCleanup:()=>Rt,openBlock:()=>Lt,patchProp:()=>nn,popScopeId:()=>ye,provide:()=>m,proxyRefs:()=>be,pushScopeId:()=>u,queuePostFlushCb:()=>S,reactive:()=>h,readonly:()=>d,ref:()=>C,registerRuntimeCompiler:()=>st,render:()=>Jt,renderList:()=>n,renderSlot:()=>rt,resolveComponent:()=>pe,resolveDirective:()=>ge,resolveDynamicComponent:()=>T,resolveFilter:()=>null,resolveTransitionHooks:()=>ee,setBlockTracking:()=>ie,setDevtoolsHook:()=>de,setTransitionHooks:()=>A,shallowReactive:()=>ct,shallowReadonly:()=>r,shallowRef:()=>it,ssrContextKey:()=>Kt,ssrUtils:()=>a,stop:()=>me,toDisplayString:()=>He,toHandlerKey:()=>B,toHandlers:()=>we,toRaw:()=>_e,toRef:()=>E,toRefs:()=>_,toValue:()=>ae,transformVNodeArgs:()=>te,triggerRef:()=>x,unref:()=>j,useAttrs:()=>Se,useCssModule:()=>gn,useCssVars:()=>rn,useHost:()=>Xt,useId:()=>L,useModel:()=>y,useSSRContext:()=>le,useShadowRoot:()=>Yt,useSlots:()=>Ct,useTemplateRef:()=>se,useTransitionState:()=>Oe,vModelCheckbox:()=>en,vModelDynamic:()=>dn,vModelRadio:()=>qt,vModelSelect:()=>un,vModelText:()=>Qt,vShow:()=>$t,version:()=>De,warn:()=>Ae,watch:()=>O,watchEffect:()=>e,watchPostEffect:()=>Ke,watchSyncEffect:()=>At,withAsyncContext:()=>_t,withCtx:()=>Tt,withDefaults:()=>nt,withDirectives:()=>Ie,withKeys:()=>tn,withMemo:()=>yt,withModifiers:()=>Zt,withScopeId:()=>Ot}),bn=()=>{};function K(e){return typeof e==`string`?`'${e}'`:new Sn().serialize(e)}var xn=` _-,;:!?.'"()[]{}@*/\\&#%\`^+<=>|~$0123456789abcdefghijklmnopqrstuvwxyz`,q=(function(){let e=new Uint8Array(128);for(let t=0;t<69;t++)e[xn.charCodeAt(t)]=t+1;for(let t=65;t<=90;t++)e[t]=e[t+32];return e})();function J(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&&q[n]?q[n]:n+128,s=a<128&&q[a]?q[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 Sn=(function(){class e{#e=new Map;compare(e,t){let n=typeof e,r=typeof t;return n===`string`&&r===`string`?J(e,t):n===`number`&&r===`number`?e-t:J(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(J),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 Cn(e,t){return e===t||K(e)===K(t)}function Y(e,t){let n=typeof e==`string`&&!t?`${e}Context`:t,r=Symbol(n);return[t=>{let n=V(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=>(m(r,e),e)]}function wn(e){return e==null}var[X,Tn]=Y(`ConfigProvider`);function En(e){let t=X({dir:C(`ltr`)});return g(()=>e?.value||t.dir?.value||`ltr`)}function Dn(e){let t=H(),n=t?.type.emits,r={};return n?.length||console.warn(`No emitted event found. Please check component: ${t?.type.__name}`),n?.forEach(t=>{r[B(I(t))]=(...n)=>e(t,...n)}),r}function On(){let e=H(),t=C(),n=g(()=>r());s(()=>{n.value!==r()&&x(t)});function r(){return t.value&&`$el`in t.value&&[`#text`,`#comment`].includes(t.value.$el.nodeName)?t.value.$el.nextElementSibling:W(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 Z(e){let t=H(),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=E(e);return g(()=>{let e={},i=t?.vnode.props??{};return Object.keys(i).forEach(t=>{e[I(t)]=i[t]}),Object.keys({...n,...e}).reduce((e,t)=>(r.value[t]!==void 0&&(e[t]=r.value[t]),e),{})})}function kn(e,t){let n=Z(e),r=t?Dn(t):{};return g(()=>({...n.value,...r}))}var Q=0;function An(e,t=`reka`){if(e)return e;let n,r=X({useId:void 0});return n=r.useId?r.useId():`useId`in yn?L?.():`${++Q}`,t?`${t}-${n}`:n}function jn(e,t){let n=C(e);function r(e){return t[n.value][e]??n.value}return{state:n,dispatch:e=>{n.value=r(e)}}}function Mn(e,t){let n=C({}),r=C(`none`),i=C(e),a=e.value?`mounted`:`unmounted`,o,s=t.value?.ownerDocument.defaultView??mn,{state:c,dispatch:l}=jn(a,{mounted:{UNMOUNT:`unmounted`,ANIMATION_OUT:`unmountSuspended`},unmountSuspended:{MOUNT:`mounted`,ANIMATION_END:`unmounted`},unmounted:{MOUNT:`mounted`}}),u=e=>{if(ot){let n=new CustomEvent(e,{bubbles:!1,cancelable:!1});t.value?.dispatchEvent(n)}};O(e,async(e,i)=>{let a=i!==e;if(await z(),a){let a=r.value,o=$(t.value);e?(l(`MOUNT`),u(`enter`),o===`none`&&u(`after-enter`)):o===`none`||o===`undefined`||n.value?.display===`none`?(l(`UNMOUNT`),u(`leave`),u(`after-leave`)):i&&a!==o?(l(`ANIMATION_OUT`),u(`leave`)):(l(`UNMOUNT`),u(`after-leave`))}},{immediate:!0});let d=e=>{if(e.target!==t.value)return;let n=$(t.value),r=n.includes(CSS.escape(e.animationName)),a=c.value===`mounted`?`enter`:`leave`;if(r&&(u(`after-${a}`),l(`ANIMATION_END`),!i.value)){let e=t.value.style.animationFillMode;t.value.style.animationFillMode=`forwards`,o=s?.setTimeout(()=>{t.value?.style.animationFillMode===`forwards`&&(t.value.style.animationFillMode=e)})}n===`none`&&l(`ANIMATION_END`)},f=e=>{e.target===t.value&&(r.value=$(t.value))},p=O(t,(e,t)=>{e?(n.value=getComputedStyle(e),e.addEventListener(`animationstart`,f),e.addEventListener(`animationcancel`,d),e.addEventListener(`animationend`,d)):(l(`ANIMATION_END`),o!==void 0&&s?.clearTimeout(o),t?.removeEventListener(`animationstart`,f),t?.removeEventListener(`animationcancel`,d),t?.removeEventListener(`animationend`,d))},{immediate:!0}),m=O(c,()=>{let e=$(t.value);r.value=c.value===`mounted`?e:`none`});return N(()=>{p(),m(),t.value&&(t.value.removeEventListener(`animationstart`,f),t.value.removeEventListener(`animationcancel`,d),t.value.removeEventListener(`animationend`,d)),o!==void 0&&s?.clearTimeout(o)}),{isPresent:g(()=>[`mounted`,`unmountSuspended`].includes(c.value))}}function $(e){return e&&getComputedStyle(e).animationName||`none`}var Nn=U({name:`Presence`,props:{present:{type:Boolean,required:!0},forceMount:{type:Boolean}},slots:{},setup(e,{slots:t,expose:n}){let{present:r,forceMount:i}=_(e),a=C(),{isPresent:o}=Mn(r,a);n({present:o});let s=t.default({present:o.value});s=p(s||[]);let c=H();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?R(t.default({present:o.value})[0],{ref:e=>{let t=W(e);return t?.hasAttribute===void 0||(t?.hasAttribute(`data-reka-popper-content-wrapper`)?a.value=t.firstElementChild:a.value=t),t}}):null}});export{On as a,wn as c,Z as i,Y as l,An as n,En as o,kn as r,X as s,Nn as t,Cn as u};",
+		),
+	},
+	"ReliabilityPage-D4CjC5Gn.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{An as e,At as t,C as n,Dt as r,Et as i,It as a,Lt as o,Mn as s,Ot as c,Qn as l,Rr as u,S as d,Sn as f,Xt as p,b as m,br as h,di as g,gt as _,h as v,kt as y,ot as b,rr as x,t as S,ut as C,vn as ee,wn as w,x as T,zt as E}from"./nav-Dzb0OTN_.js";import{d as D,t as O,u as te}from"./CardDescription-IdOt317c.js";import{a as ne,i as k,n as A,o as j,r as M,t as N,u as P}from"./index-BiTQ_gCE.js";import{t as F}from"./DataTable-DVueNFuA.js";import{f as I,r as L,t as R}from"./badge-ns0j8OUr.js";import{n as re,t as z}from"./useSearchQuery-DysBt-In.js";import{t as B}from"./TimeSeriesChart-BP5IcUyg.js";import{t as V}from"./events-BPFIBv4M.js";import{i as H,n as U,r as W,t as G}from"./events-filter-XFnjIaR7.js";import{n as ie}from"./provider-rate-DU7OgSeB.js";import{n as K,r as ae}from"./reliability-0KiJSjTP.js";function q(e){return U[e]??e}function J(e){return e.user?`user:${e.user}`:e.group?`group:${e.group}`:`—`}function Y(e){let t=[e.model,e.provider].filter(e=>!!e);return t.length?t.join(` → `):`—`}function X(){return[{id:`time`,header:`Time`,accessorFn:e=>e.time,cell:({row:e})=>p(`span`,{class:`text-muted-foreground tabular-nums`},I(e.original.time))},{id:`kind`,header:`Kind`,accessorFn:e=>e.kind,cell:({row:e})=>p(R,{as:`span`,variant:W(e.original.kind),class:`font-normal`},()=>q(e.original.kind))},{id:`route`,header:`Route`,accessorFn:e=>e.route,cell:({row:e})=>p(`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=J(e.original);return p(`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=Y(e.original);return p(`span`,{class:t===`—`?`text-muted-foreground`:`font-mono text-xs`},t)}},{id:`replica`,header:`Replica`,accessorFn:e=>e.replica,cell:({row:e})=>p(`span`,{class:`text-muted-foreground`},e.original.replica)},{id:`status`,header:`Status`,meta:{align:`right`},accessorFn:e=>e.status??0,cell:({row:e})=>p(`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})=>p(`span`,{class:`text-muted-foreground`},e.original.message)}]}var oe={class:`flex flex-col gap-6`},Z={class:`flex flex-wrap items-center gap-3`},se={key:0,class:`mb-3 text-sm text-destructive`},Q=`all`,ce=E({__name:`EventsView`,setup(l){let p=V(),{kindFilter:v,userFilter:S}=C(p),{normalized:E}=z(S),N=i(()=>v.value===``?Q:v.value),I=i(()=>H(p.events,{kind:v.value,user:E.value}));function L(e){typeof e==`string`&&p.setKindFilter(e===Q?``:e)}let R=X(),B=i(()=>p.lastUpdated?p.events.length===0?`no events recorded`:v.value!==``||E.value?`no events match the current filter`:`none`:`loading…`),W=i(()=>p.lastUpdated?p.source===`redis`?`Fleet-wide, across every replica`:`This replica only (${p.replica||`unknown`}) — Redis is unreachable or unconfigured`:`loading…`);return ee(()=>{p.startPolling()}),f(()=>{p.stopPolling()}),(i,l)=>{let f=s(`FontAwesomeIcon`);return w(),t(`div`,oe,[u(p).degraded?(w(),c(u(D),{key:0,variant:`destructive`},{default:x(()=>[o(f,{icon:u(b),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`]),o(u(P),null,{default:x(()=>[...l[1]||=[a(`Fleet-wide event log unavailable`,-1)]]),_:1}),o(u(te),null,{default:x(()=>[...l[2]||=[a(` 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})):y(``,!0),o(u(n),null,{default:x(()=>[o(u(T),{class:`flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between`},{default:x(()=>[r(`div`,null,[o(u(m),null,{default:x(()=>[...l[3]||=[a(`Events`,-1)]]),_:1}),u(p).lastUpdated?(w(),c(u(O),{key:1},{default:x(()=>[a(g(W.value)+` — rate limit, budget, and upstream events, newest first (capacity `+g(u(p).capacity)+`). `,1)]),_:1})):(w(),c(u(O),{key:0},{default:x(()=>[...l[4]||=[a(`Loading…`,-1)]]),_:1}))]),r(`div`,Z,[o(re,{modelValue:u(S),"onUpdate:modelValue":l[0]||=e=>h(S)?S.value=e:null,placeholder:`Filter by user or group`,class:`w-56`},null,8,[`modelValue`]),o(u(j),{"model-value":N.value,"onUpdate:modelValue":L},{default:x(()=>[o(u(M),{class:`w-44`,"aria-label":`Filter by kind`},{default:x(()=>[o(u(A),{placeholder:`Kind`})]),_:1}),o(u(ne),null,{default:x(()=>[o(u(k),{value:Q},{default:x(()=>[...l[5]||=[a(`All kinds`,-1)]]),_:1}),(w(!0),t(_,null,e(u(G),e=>(w(),c(u(k),{key:e,value:e},{default:x(()=>[a(g(u(U)[e]),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),_:1}),o(u(d),null,{default:x(()=>[u(p).error?(w(),t(`p`,se,g(u(p).error),1)):y(``,!0),o(F,{columns:u(R),data:I.value,"empty-message":B.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1})])}}}),le={class:`flex flex-col gap-6`},ue={class:`flex flex-col gap-1`},de={key:0,class:`text-sm text-destructive`},fe={key:1,class:`text-sm text-muted-foreground`},pe={key:0,class:`text-sm text-muted-foreground`},me={key:1,class:`text-sm text-muted-foreground`},he={key:0,class:`text-sm text-destructive`},ge={class:`grid gap-6 lg:grid-cols-2`},_e={class:`grid gap-6 lg:grid-cols-2`},$=`all`,ve=E({__name:`ReliabilityPage`,setup(s){let f=v(),p=V(),h=N(),b=S(),C=ae(),E=i(()=>b.params.provider??``),P=i(()=>E.value||$);function F(e){typeof e==`string`&&b.goTo(`reliability`,{...b.params,provider:e===$?``:e})}function I(e){return e.replace(/^provider:/,``)}function R(e){return E.value?e.filter(e=>I(e.scope)===E.value):e}function re(e){return e.map(e=>e===null?NaN:e)}let z=i(()=>R(C.errorRate).map((e,t)=>({label:I(e.scope),data:re(e.points),color:K(t)})));function H(e){return R(e).map((e,t)=>({label:I(e.scope),data:e.points,color:K(t)}))}let U=i(()=>H(C.timeouts)),W=i(()=>H(C.failovers)),G=i(()=>[{label:`429 rejections`,data:C.rejections,color:`--destructive`}]),q=i(()=>[{label:`402 unpriced refusals`,data:C.unpriced,color:`--status-warn`}]),J=i(()=>C.buckets.map(e=>L(e,C.windowUsed)));function Y(e){return ie(Number.isNaN(e)?null:e)}let X=i(()=>(f.overview?.providers.length??0)>0),oe=i(()=>f.overview!==null&&f.overview.features.failover===!1),Z=i(()=>f.overview?.features.latencyStats??!1),se=i(()=>E.value!==``&&Z.value),Q=i(()=>C.providerPerfBuckets.map(e=>L(e,C.providerPerfWindowUsed))),ve=i(()=>[{label:`p50`,data:C.providerPerfPoints.map(e=>e.p50Ms??NaN),color:`--chart-requests`},{label:`p95`,data:C.providerPerfPoints.map(e=>e.p95Ms??NaN),color:`--chart-tokens-in`}]),ye=i(()=>[{label:`failures`,data:C.providerPerfPoints.map(e=>e.failures),color:`--destructive`}]);l(()=>[E.value,h.range],([e])=>void C.fetchProviderPerf(e),{immediate:!0});let be=i(()=>h.window===`month`);return l(()=>[h.range,f.overview?.providers.length??0],()=>void C.fetch()),l(()=>[p.kindFilter,p.userFilter],([e,t])=>{b.goTo(`reliability`,{...b.params,kind:e,user:t})}),l(()=>[b.params.kind,b.params.user],([e,t])=>{p.setKindFilter(e??``),p.setUserFilter(t??``)},{immediate:!0}),ee(()=>void C.fetch()),(i,s)=>(w(),t(`div`,le,[o(u(n),null,{default:x(()=>[o(u(T),{class:`flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between`},{default:x(()=>[r(`div`,null,[o(u(m),null,{default:x(()=>[...s[0]||=[a(`Reliability`,-1)]]),_:1}),o(u(O),null,{default:x(()=>[...s[1]||=[a(`Provider error rate, failovers, timeouts, rate-limit rejections, and 402 refusals.`,-1)]]),_:1})]),r(`div`,ue,[s[3]||=r(`label`,{id:`reliability-provider-label`,class:`text-xs font-medium text-muted-foreground`},`Provider`,-1),o(u(j),{"model-value":P.value,"onUpdate:modelValue":F},{default:x(()=>[o(u(M),{"aria-labelledby":`reliability-provider-label`,class:`w-48`},{default:x(()=>[o(u(A),{placeholder:`All providers`})]),_:1}),o(u(ne),null,{default:x(()=>[o(u(k),{value:$},{default:x(()=>[...s[2]||=[a(`All providers`,-1)]]),_:1}),(w(!0),t(_,null,e(u(f).overview?.providers??[],e=>(w(),c(u(k),{key:e.name,value:e.name},{default:x(()=>[a(g(e.name),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),_:1}),o(u(d),null,{default:x(()=>[u(C).error?(w(),t(`p`,de,g(u(C).error),1)):X.value?y(``,!0):(w(),t(`p`,fe,`No providers configured.`))]),_:1})]),_:1}),be.value?(w(),c(u(D),{key:0,variant:`warn`},{default:x(()=>[o(u(te),null,{default:x(()=>[a(` Reliability data has no monthly retention — every chart below shows the most recent 30 days, not the full `+g(u(h).range)+` range selected above. `,1)]),_:1})]),_:1})):y(``,!0),X.value?(w(),c(u(n),{key:1},{default:x(()=>[o(u(T),null,{default:x(()=>[o(u(m),null,{default:x(()=>[...s[4]||=[a(`Error rate by provider`,-1)]]),_:1}),o(u(O),null,{default:x(()=>[...s[5]||=[a(`Failed attempts / total attempts per bucket. A gap means no attempts in that bucket.`,-1)]]),_:1})]),_:1}),o(u(d),null,{default:x(()=>[o(B,{labels:J.value,datasets:z.value,"value-formatter":Y,ariaLabel:`Error rate by provider over time`},null,8,[`labels`,`datasets`])]),_:1})]),_:1})):y(``,!0),X.value?(w(),c(u(n),{key:2},{default:x(()=>[o(u(T),null,{default:x(()=>[o(u(m),null,{default:x(()=>[...s[6]||=[a(`Selected provider performance`,-1)]]),_:1}),o(u(O),null,{default:x(()=>[...s[7]||=[a(`Latency (p50/p95) and failures per bucket for one provider.`,-1)]]),_:1})]),_:1}),o(u(d),{class:`flex flex-col gap-4`},{default:x(()=>[E.value===``?(w(),t(`p`,pe,` Select a provider above to see its latency and failure breakdown per bucket. `)):Z.value?se.value?(w(),t(_,{key:2},[u(C).providerPerfError?(w(),t(`p`,he,g(u(C).providerPerfError),1)):y(``,!0),r(`div`,ge,[r(`div`,null,[s[10]||=r(`p`,{class:`mb-2 text-sm font-medium text-muted-foreground`},`Latency (ms)`,-1),o(B,{labels:Q.value,datasets:ve.value,ariaLabel:`p50/p95 latency for ${E.value} over time`},null,8,[`labels`,`datasets`,`ariaLabel`])]),r(`div`,null,[s[11]||=r(`p`,{class:`mb-2 text-sm font-medium text-muted-foreground`},`Failures`,-1),o(B,{labels:Q.value,datasets:ye.value,ariaLabel:`Failures for ${E.value} over time`},null,8,[`labels`,`datasets`,`ariaLabel`])])])],64)):y(``,!0):(w(),t(`p`,me,[s[8]||=a(` Enable `,-1),s[9]||=r(`code`,{class:`font-mono text-xs`},`admin.stats.latency`,-1),a(` in the plugin config to see per-bucket latency for `+g(E.value)+`. `,1)]))]),_:1})]),_:1})):y(``,!0),X.value?(w(),c(u(n),{key:3},{default:x(()=>[o(u(T),null,{default:x(()=>[o(u(m),null,{default:x(()=>[...s[12]||=[a(`Timeouts by provider`,-1)]]),_:1})]),_:1}),o(u(d),null,{default:x(()=>[o(B,{labels:J.value,datasets:U.value,ariaLabel:`Timeouts by provider over time`},null,8,[`labels`,`datasets`])]),_:1})]),_:1})):y(``,!0),X.value?(w(),c(u(n),{key:4},{default:x(()=>[o(u(T),null,{default:x(()=>[o(u(m),null,{default:x(()=>[...s[13]||=[a(`Failovers by provider`,-1)]]),_:1}),oe.value?(w(),c(u(O),{key:0},{default:x(()=>[...s[14]||=[a(`This deployment has no failover chains configured.`,-1)]]),_:1})):y(``,!0)]),_:1}),o(u(d),null,{default:x(()=>[o(B,{labels:J.value,datasets:W.value,ariaLabel:`Failovers by provider over time`},null,8,[`labels`,`datasets`])]),_:1})]),_:1})):y(``,!0),r(`div`,_e,[o(u(n),null,{default:x(()=>[o(u(T),null,{default:x(()=>[o(u(m),null,{default:x(()=>[...s[15]||=[a(`Rate-limit rejections (429)`,-1)]]),_:1}),o(u(O),null,{default:x(()=>[...s[16]||=[a(`Fleet-wide, every scope combined.`,-1)]]),_:1})]),_:1}),o(u(d),null,{default:x(()=>[o(B,{labels:J.value,datasets:G.value,ariaLabel:`Rate-limit rejections over time, fleet-wide`},null,8,[`labels`,`datasets`])]),_:1})]),_:1}),o(u(n),null,{default:x(()=>[o(u(T),null,{default:x(()=>[o(u(m),null,{default:x(()=>[...s[17]||=[a(`Unpriced refusals (402)`,-1)]]),_:1}),o(u(O),null,{default:x(()=>[...s[18]||=[a(`Fleet-wide requests refused for having no resolvable price.`,-1)]]),_:1})]),_:1}),o(u(d),null,{default:x(()=>[o(B,{labels:J.value,datasets:q.value,ariaLabel:`Unpriced refusals (402) over time, fleet-wide`},null,8,[`labels`,`datasets`])]),_:1})]),_:1})]),o(ce)]))}});export{ve as default};",
+		),
+	},
+	"SpendPage-COAWCgvN.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{An as e,At as t,C as n,Dt as r,Et as i,It as a,K as o,Lt as s,Or as c,Ot as l,Qn as u,Rr as d,S as f,Sn as p,Xt as m,_ as h,b as g,d as _,di as v,g as y,gt as b,h as x,kt as S,lt as C,rr as w,s as T,si as E,t as ee,u as D,v as O,vn as te,wn as k,x as A,y as ne,zt as j}from"./nav-Dzb0OTN_.js";import{t as M}from"./CardDescription-IdOt317c.js";import{n as re,r as ie,t as ae}from"./tabs-BbGJyCRr.js";import{a as N,d as P,i as oe,n as se,o as ce,r as le,t as F}from"./index-BiTQ_gCE.js";import{t as I}from"./DataTable-DVueNFuA.js";import{a as L,d as ue,i as de,o as R,r as z,t as B}from"./badge-ns0j8OUr.js";import{t as V}from"./CompactNumber-B1ihQZH7.js";import{a as fe,i as H,n as pe,o as U,r as me,s as he,t as ge}from"./burndown-CqtdXSYk.js";import{t as W}from"./EntityLink-CovsFjEl.js";import{t as _e}from"./ClampedRangeNotice-Bvhm1e-B.js";import{t as ve}from"./TimeSeriesChart-BP5IcUyg.js";import{o as G}from"./kpi-CU52LDmq.js";import{t as ye}from"./catalog-C-TfKLVZ.js";import{i as K,r as q,t as J}from"./series-NIRVBXMP.js";var be=[`model`,`provider`,`group`];function xe(e){return be.includes(e)}var Se=[`cost`,`req`,`tokin`,`tokout`],Y={cost:`Cost`,req:`Requests`,tokin:`Tokens in`,tokout:`Tokens out`};function Ce(e){return Se.includes(e)}var X=100,Z=100,we=6e4,Te=C(`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,error:``,breakdownReqId:0,rankingReqId:0,pricingHealthReqId:0,burndownReqId:0,drilldownReqId:0,poller:void 0}),getters:{burndownAvailable:()=>De(F().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(){ne().isAuthenticated&&await Promise.all([this.fetchModelRanking().then(()=>this.fetchBreakdown()),this.fetchPricingHealthRanking(),this.fetchBurndown(),this.fetchDrilldown()])},async fetchModelRanking(){let e=F(),t=++this.rankingReqId;try{let n=await O(`/admin/api/usage/models?metric=${this.metric}&window=${e.window}&span=${e.span}&limit=${X}&detail=1`);if(t!==this.rankingReqId)return;this.modelRanking=n.models}catch(e){if(t!==this.rankingReqId||Q(e))return;this.error=$(e)}},async fetchPricingHealthRanking(){let e=F(),t=++this.pricingHealthReqId;try{let n=await O(`/admin/api/usage/models?metric=req&window=${e.window}&span=${e.span}&limit=${X}&detail=1`);if(t!==this.pricingHealthReqId)return;this.pricingHealthRanking=n.models}catch(e){if(t!==this.pricingHealthReqId||Q(e))return;this.error=$(e)}},async fetchBreakdown(){let e=F(),t=++this.breakdownReqId;this.loading=!0;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.error=``,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.error=$(e)}finally{t===this.breakdownReqId&&(this.loading=!1)}},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=J(i,[]);return}let a=await this.fetchSeries(r,this.metric,e,t,0);if(n!==this.breakdownReqId)return;let o=q(a.series,10);this.breakdown=o,this.otherPoints=J(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=K(i.series),this.otherPoints=null;return}let a=await O(_({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]=K(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 O(D({scope:e,metric:t,window:n,span:r,offset:i||void 0}))},async fetchBurndown(){let e=F(),t=++this.burndownReqId,n=De(e.scope);if(n===null){this.burndownBuckets=[],this.burndownPoints=[],this.burndownBudgetMicros=null;return}try{let e=pe(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=Oe(n)}catch(e){if(t!==this.burndownReqId||Q(e))return;this.error=$(e)}},async fetchDrilldown(){let e=F(),t=++this.drilldownReqId,n=Ee(this.drill);try{let r=n.kind===`usermodel`?{kind:`usermodel`,...T(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 O(_(r));if(t!==this.drilldownReqId)return;this.drilldownRows=i.rows,this.drilldownMetrics=i.metrics,this.drilldownDisabled=!1}catch(e){if(t!==this.drilldownReqId||Q(e))return;if(e instanceof h&&e.status===404){this.drilldownRows=[],this.drilldownMetrics=[],this.drilldownDisabled=!0;return}this.error=$(e)}},startPolling(){this.poller||(this.poller=y({intervalMs:we,tick:()=>void this.refresh()}),this.poller.start())},stopPolling(){this.poller?.stop(),this.poller=void 0}}});function Ee(e){return e===``?{kind:`group`}:e.startsWith(`group:`)?{kind:`user`,group:e.slice(6)}:{kind:`usermodel`,user:e.slice(5)}}function De(e){return e===`all`?`total`:e.startsWith(`group:`)||e.startsWith(`user:`)?e:null}function Oe(e){let t=x();if(e===`total`){let e=G(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 h&&(e.status===401||e.status===403)}function $(e){return e instanceof Error?e.message:String(e)}var ke={"aria-label":`Breadcrumb`,class:`flex flex-wrap items-center gap-1.5 text-sm text-muted-foreground`},Ae=[`disabled`],je={class:`font-medium text-foreground`},Me={class:`font-medium text-foreground`},Ne={key:1,class:`text-sm text-muted-foreground`},Pe=j({__name:`AttributionDrilldown`,props:{rows:{},metrics:{},drill:{},disabled:{type:Boolean},userModelStatsEnabled:{type:Boolean},window:{},span:{}},emits:[`update:drill`],setup(e,{emit:u}){let p=e,h=u,_=i(()=>p.drill===``?{kind:`group`}:p.drill.startsWith(`group:`)?{kind:`user`,group:p.drill.slice(6)}:{kind:`usermodel`,user:p.drill.slice(5)}),y=c(``);function x(){h(`update:drill`,``)}function C(){y.value&&h(`update:drill`,`group:${y.value}`)}function T(e){let t=_.value;t.kind===`group`?h(`update:drill`,`group:${e}`):t.kind===`user`&&p.userModelStatsEnabled&&(y.value=t.group,h(`update:drill`,`user:${e}`))}let E=i(()=>_.value.kind===`group`?`Group`:_.value.kind===`user`?`User`:`Model`);function ee(e){let t=_.value;return t.kind===`usermodel`?m(W,{label:e.id,kind:`model`,id:e.id}):t.kind===`group`||p.userModelStatsEnabled?m(`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:()=>T(e.id)},[e.id,m(P,{icon:o,class:`size-3`,"aria-hidden":`true`})]):m(`span`,{},e.id)}let D=i(()=>[{id:`id`,header:E.value,accessorFn:e=>e.id,cell:({row:e})=>ee(e.original)},...p.metrics.map(e=>({id:e,header:Y[e]??e,meta:{align:`right`},accessorFn:t=>t.values[e]??0,cell:({row:t})=>{let n=t.original.values[e]??0;return e===`cost`?R(n):m(V,{value:n})}}))]),O=i(()=>_.value.kind===`user`&&(!p.userModelStatsEnabled||p.disabled));return(i,c)=>(k(),l(d(n),null,{default:w(()=>[s(d(A),null,{default:w(()=>[s(d(g),null,{default:w(()=>[...c[0]||=[a(`Attribution`,-1)]]),_:1}),s(d(M),null,{default:w(()=>[...c[1]||=[a(`Drill from groups into users into the models they used.`,-1)]]),_:1}),r(`nav`,ke,[r(`button`,{type:`button`,class:`hover:text-foreground hover:underline`,disabled:_.value.kind===`group`,onClick:x},` All groups `,8,Ae),_.value.kind===`user`?(k(),t(b,{key:0},[s(d(P),{icon:d(o),class:`size-3`,"aria-hidden":`true`},null,8,[`icon`]),r(`span`,je,v(_.value.group),1)],64)):S(``,!0),_.value.kind===`usermodel`?(k(),t(b,{key:1},[s(d(P),{icon:d(o),class:`size-3`,"aria-hidden":`true`},null,8,[`icon`]),y.value?(k(),t(`button`,{key:0,type:`button`,class:`hover:text-foreground hover:underline`,onClick:C},v(y.value),1)):S(``,!0),s(d(P),{icon:d(o),class:`size-3`,"aria-hidden":`true`},null,8,[`icon`]),r(`span`,Me,v(_.value.user),1)],64)):S(``,!0)])]),_:1}),s(d(f),{class:`flex flex-col gap-3`},{default:w(()=>[_.value.kind===`usermodel`?(k(),l(_e,{key:0,window:e.window,span:e.span},null,8,[`window`,`span`])):S(``,!0),O.value?(k(),t(`p`,Ne,[...c[2]||=[a(` Per-model attribution for this user needs `,-1),r(`code`,{class:`font-mono text-xs`},`admin.stats.userModel`,-1),a(` enabled. `,-1)]])):(k(),l(I,{key:2,columns:D.value,data:e.rows,"empty-message":_.value.kind===`group`?`No group has spend in this range.`:`Nothing in this range.`},null,8,[`columns`,`data`,`empty-message`]))]),_:1})]),_:1}))}}),Fe={class:`grid grid-cols-2 gap-4 text-sm sm:grid-cols-3`},Ie={key:0},Le={class:`text-lg font-semibold tabular-nums`},Re={key:1},ze={key:0,class:`text-sm text-muted-foreground`},Be={key:0,class:`text-sm text-muted-foreground`},Ve=j({__name:`BurnDownChart`,props:{buckets:{},points:{},budgetMicros:{},now:{}},setup(e){let o=e,c=i(()=>o.buckets.map(e=>z(e,`day`))),u=i(()=>ge(o.points)),p=i(()=>u.value.at(-1)??0),m=i(()=>[{label:`Spent (MTD)`,data:u.value,color:`--chart-cost`}]),h=i(()=>o.budgetMicros===null?[]:[{label:`Budget`,data:Array(u.value.length).fill(o.budgetMicros),color:`--destructive`}]),_=i(()=>o.budgetMicros===null?null:me(p.value,o.budgetMicros,o.now)),y=i(()=>o.budgetMicros!==null&&p.value>=o.budgetMicros);return(i,o)=>(k(),l(d(n),null,{default:w(()=>[s(d(A),null,{default:w(()=>[s(d(g),null,{default:w(()=>[...o[0]||=[a(`Burn-down`,-1)]]),_:1}),s(d(M),null,{default:w(()=>[...o[1]||=[a(`Cumulative spend this UTC calendar month against the configured budget.`,-1)]]),_:1})]),_:1}),s(d(f),{class:`flex flex-col gap-4`},{default:w(()=>[r(`div`,Fe,[r(`div`,null,[o[2]||=r(`p`,{class:`text-muted-foreground`},`Spent so far`,-1),r(`p`,{class:E([`text-lg font-semibold tabular-nums`,y.value?`text-destructive`:void 0])},v(d(R)(p.value)),3)]),e.budgetMicros===null?S(``,!0):(k(),t(`div`,Ie,[o[3]||=r(`p`,{class:`text-muted-foreground`},`Budget`,-1),r(`p`,Le,v(d(R)(e.budgetMicros)),1)])),e.budgetMicros===null?S(``,!0):(k(),t(`div`,Re,[o[4]||=r(`p`,{class:`text-muted-foreground`},`Projected run-out`,-1),_.value===null?(k(),t(`p`,ze,`not enough data yet`)):(k(),t(`p`,{key:1,class:E([`text-lg font-semibold tabular-nums`,y.value?`text-destructive`:void 0])},v(_.value.toLocaleDateString(void 0,{month:`short`,day:`numeric`})),3))]))]),e.budgetMicros===null?(k(),t(`p`,Be,`No budget configured for this scope.`)):S(``,!0),s(ve,{labels:c.value,datasets:m.value,"comparison-datasets":h.value,"value-formatter":d(R),ariaLabel:`Cumulative spend this month against the configured budget`},null,8,[`labels`,`datasets`,`comparison-datasets`,`value-formatter`])]),_:1})]),_:1}))}});function He(e){return e.filter(e=>e.free).map(e=>({tokensIn:e.tokensIn??0,tokensOut:e.tokensOut??0}))}function Ue(e,t,n){let r=0;for(let i of e)r+=i.tokensIn*t+i.tokensOut*n;return Math.round(r)}var We=new Set([`free`,`unpriced`]);function Ge(e,t){let n=null;for(let r of e){if(r.requests===void 0)continue;let e=t.get(r.id);!e||We.has(e.priceSource)||(n===null||r.requests>(n.requests??0))&&(n=r)}return n?.id??null}var Ke={key:0,class:`flex flex-col gap-1`},qe={key:0,class:`text-sm text-muted-foreground`},Je={key:1,class:`text-lg font-semibold tabular-nums text-chart-requests`},Ye={key:0},Xe={key:0,class:`text-lg font-semibold tabular-nums text-muted-foreground`},Ze={key:1,class:`text-lg font-semibold tabular-nums text-chart-requests`},Qe={key:2,class:`text-xs text-status-warn`},$e=j({__name:`CostAvoidedCard`,props:{models:{},catalog:{},refModel:{},cacheStatsEnabled:{type:Boolean},cacheSavingsAvailable:{type:Boolean},cacheSavingsNote:{}},emits:[`update:refModel`],setup(o,{emit:c}){let u=o,p=c,m=i(()=>{let e=[];for(let t of u.models){let n=u.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)}),h=i(()=>Ge(u.models,u.catalog)),_=i(()=>u.refModel||h.value),y=i(()=>_.value?u.catalog.get(_.value):void 0),x=i(()=>{let e=y.value;return!e||e.inputPerMTokUsd===void 0||e.outputPerMTokUsd===void 0?null:Ue(He(u.models),e.inputPerMTokUsd,e.outputPerMTokUsd)}),C=i(()=>{let e=0;for(let t of u.models)e+=t.cacheSavedMicroUsd??0;return e});function T(e){typeof e==`string`&&p(`update:refModel`,e)}return(i,c)=>(k(),l(d(n),null,{default:w(()=>[s(d(A),{class:`flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between`},{default:w(()=>[r(`div`,null,[s(d(g),null,{default:w(()=>[...c[0]||=[a(`Cost avoided`,-1)]]),_:1}),s(d(M),null,{default:w(()=>[...c[1]||=[a(`What free-tier traffic in range would have cost at a real model's own rates.`,-1)]]),_:1})]),m.value.length>0?(k(),t(`div`,Ke,[c[2]||=r(`label`,{id:`cost-avoided-ref-label`,class:`text-xs font-medium text-muted-foreground`},`Reference model`,-1),s(d(ce),{"model-value":_.value??void 0,"onUpdate:modelValue":T},{default:w(()=>[s(d(le),{"aria-labelledby":`cost-avoided-ref-label`,class:`w-56`},{default:w(()=>[s(d(se),{placeholder:`Pick a reference model`})]),_:1}),s(d(N),null,{default:w(()=>[(k(!0),t(b,null,e(m.value,e=>(k(),l(d(oe),{key:e.id,value:e.id},{default:w(()=>[a(v(e.id),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])):S(``,!0)]),_:1}),s(d(f),{class:`grid grid-cols-2 gap-4 text-sm`},{default:w(()=>[r(`div`,null,[c[3]||=r(`p`,{class:`text-muted-foreground`},`Cost avoided (free-tier traffic)`,-1),x.value===null?(k(),t(`p`,qe,v(m.value.length===0?`No priced model served in range to compare against.`:`Pick a reference model above.`),1)):(k(),t(`p`,Je,v(d(R)(x.value)),1))]),o.cacheStatsEnabled?(k(),t(`div`,Ye,[c[4]||=r(`p`,{class:`text-muted-foreground`},`Cache savings`,-1),o.cacheSavingsAvailable?(k(),t(`p`,Ze,v(d(R)(C.value)),1)):(k(),t(`p`,Xe,`n/a`)),o.cacheSavingsNote?(k(),t(`p`,Qe,v(o.cacheSavingsNote),1)):S(``,!0)])):S(``,!0)]),_:1})]),_:1}))}});function et(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 tt={unpriced:0,override:1,builtin:2,litellm:3,free:4};function nt(e){return[...e].sort((e,t)=>{let n=tt[e.priceSource]-tt[t.priceSource];return n===0?t.requests-e.requests:n})}var rt={class:`flex justify-end`},it=j({__name:`PricingHealthTable`,props:{models:{},catalog:{}},setup(e){let t=e,o=i(()=>nt(et(t.models,t.catalog))),c=i(()=>o.value.filter(e=>e.priceSource===`unpriced`).length),u={unpriced:`destructive`,free:`secondary`,override:`outline`,builtin:`outline`,litellm:`outline`};function p(e){return m(B,{as:`span`,variant:u[e.priceSource],class:`font-normal`},()=>e.priceSource)}function h(e){return e.inputPerMTokUsd===void 0||e.outputPerMTokUsd===void 0?m(`span`,{class:`text-muted-foreground`},`—`):m(`span`,{},ue(e.inputPerMTokUsd,e.outputPerMTokUsd))}let _=[{id:`id`,header:`Model`,accessorFn:e=>e.id,cell:({row:e})=>m(W,{label:e.original.id,kind:`model`,id:e.original.id})},{id:`source`,header:`Source`,accessorFn:e=>e.priceSource,cell:({row:e})=>p(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})=>m(`span`,{class:`tabular-nums`},e.original.contextTokens===void 0?`—`:L(e.original.contextTokens))},{id:`requests`,header:`Requests`,meta:{align:`right`},accessorFn:e=>e.requests,cell:({row:e})=>m(V,{value:e.original.requests})},{id:`tokensIn`,header:`Tokens in`,meta:{align:`right`},accessorFn:e=>e.tokensIn,cell:({row:e})=>m(V,{value:e.original.tokensIn})},{id:`tokensOut`,header:`Tokens out`,meta:{align:`right`},accessorFn:e=>e.tokensOut,cell:({row:e})=>m(V,{value:e.original.tokensOut})},{id:`cost`,header:`Cost`,meta:{align:`right`},accessorFn:e=>e.costMicroUsd,cell:({row:e})=>R(e.original.costMicroUsd)}];function y(){return H([`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(e,t)=>(k(),l(d(n),null,{default:w(()=>[s(d(A),null,{default:w(()=>[s(d(g),{class:`flex items-center gap-2`},{default:w(()=>[t[0]||=a(` Pricing health `,-1),c.value>0?(k(),l(d(B),{key:0,variant:`destructive`,class:`font-normal`},{default:w(()=>[a(v(c.value)+` unpriced`,1)]),_:1})):S(``,!0)]),_:1}),s(d(M),null,{default:w(()=>[...t[1]||=[a(`Every model served in range, joined with its billing price source.`,-1)]]),_:1})]),_:1}),s(d(f),{class:`flex flex-col gap-3`},{default:w(()=>[s(I,{columns:_,data:o.value,"empty-message":`No model served any traffic in this range.`},null,8,[`data`]),r(`div`,rt,[s(U,{filename:`pricing-health.csv`,build:y})])]),_:1})]),_:1}))}});function at(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 ot={class:`flex flex-col gap-4`},st={class:`flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between`},ct={class:`flex flex-wrap items-center gap-3`},lt={class:`flex flex-col gap-1`},ut={class:`flex flex-col gap-1`},dt={class:`text-right`},ft={class:`text-xs font-medium text-muted-foreground`},pt={class:`text-2xl font-semibold tabular-nums`},mt={key:0,class:`text-sm text-muted-foreground`},ht={class:`font-mono text-xs`},gt={key:1,class:`text-sm text-destructive`},_t={key:2,class:`text-sm text-destructive`},vt={key:3,class:`text-sm text-muted-foreground`},yt={class:`grid grid-cols-1 gap-4 lg:grid-cols-2`},bt=j({__name:`SpendPage`,setup(n){let o={model:`By model`,provider:`By provider`,group:`By group`},c=ee(),f=F(),m=x(),h=ye(),g=Te(),{now:_,start:y,stop:C}=fe(),T=i(()=>c.params.by&&xe(c.params.by)?c.params.by:`model`),E=i(()=>c.params.metric&&Ce(c.params.metric)?c.params.metric:`cost`),D=i(()=>c.params.ref??``),O=i(()=>c.params.drill??``);function A(e){let t={by:e.by??T.value,metric:e.metric??E.value,ref:e.ref??D.value,drill:e.drill??O.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),c.goTo(`spend`,n)}function ne(e){typeof e==`string`&&xe(e)&&A({by:e})}function j(e){typeof e==`string`&&Ce(e)&&A({metric:e})}function M(e){A({ref:e})}function P(e){A({drill:e})}let I=i(()=>f.scope!==`all`);u([T,E,O],([e,t,n])=>{g.setSelection({by:e,metric:t,drill:n})}),u(()=>[f.range,f.cmp,f.scope],()=>void g.refresh()),te(()=>{g.$patch({by:T.value,metric:E.value,drill:O.value}),h.ensureLoaded(),g.startPolling(),y()}),p(()=>{g.stopPolling(),C()});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 ue(e){return L[e%L.length]}function B(e){return e.startsWith(`model:`)||e.startsWith(`group:`)?e.slice(6):e.startsWith(`provider:`)?e.slice(9):e}let V=i(()=>g.buckets.map(e=>z(e,f.window))),H=i(()=>{let e=g.breakdown.map((e,t)=>({label:B(e.scope),data:e.points,color:ue(t)}));return g.otherPoints&&e.push({label:`Other`,data:g.otherPoints,color:`--muted-foreground`}),e}),pe=i(()=>g.comparisonPoints?[{label:`Total`,data:g.comparisonPoints,color:`--foreground`,labelSuffix:` (previous period)`}]:[]),U=i(()=>E.value===`cost`?R:de),me=i(()=>g.totalPoints.reduce((e,t)=>e+t,0)),ge=i(()=>{if(f.scope===`all`)return m.usage?.total.costPerMonthMicroUsd??0;if(f.scope.startsWith(`group:`)){let e=f.scope.slice(6);return m.usage?.groups.find(t=>t.id===e)?.costPerMonthMicroUsd??0}if(f.scope.startsWith(`user:`)){let e=f.scope.slice(5);return m.usage?.users.find(t=>t.id===e)?.costPerMonthMicroUsd??0}return 0}),W=i(()=>{if(f.scope===`all`){let e=(m.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(f.scope.startsWith(`group:`)){let e=f.scope.slice(6);return m.overview?.groups.find(t=>t.name===e)?.limits}if(f.scope.startsWith(`user:`)){let e=f.scope.slice(5);return m.usage?.users.find(t=>t.id===e)?.limits}}),_e=i(()=>f.scope===`all`||f.scope.startsWith(`group:`)||f.scope.startsWith(`user:`)),G=i(()=>m.overview?.features.userModelStats??!1),K=i(()=>m.overview?.features.cacheStats??!1),q=i(()=>at(f.window)),J=i(()=>q.value.available),X=i(()=>q.value.note);return(n,i)=>(k(),t(`div`,ot,[r(`div`,st,[r(`div`,ct,[r(`div`,lt,[i[0]||=r(`span`,{class:`text-xs font-medium text-muted-foreground`},`Breakdown`,-1),s(d(ie),{"model-value":T.value,"onUpdate:modelValue":ne},{default:w(()=>[s(d(re),null,{default:w(()=>[(k(!0),t(b,null,e(d(be),e=>(k(),l(d(ae),{key:e,value:e,disabled:I.value},{default:w(()=>[a(v(o[e]),1)]),_:2},1032,[`value`,`disabled`]))),128))]),_:1})]),_:1},8,[`model-value`])]),r(`div`,ut,[i[1]||=r(`label`,{id:`spend-metric-label`,class:`text-xs font-medium text-muted-foreground`},`Metric`,-1),s(d(ce),{"model-value":E.value,"onUpdate:modelValue":j},{default:w(()=>[s(d(le),{"aria-labelledby":`spend-metric-label`,class:`w-40`},{default:w(()=>[s(d(se))]),_:1}),s(d(N),null,{default:w(()=>[(k(!0),t(b,null,e(d(Se),e=>(k(),l(d(oe),{key:e,value:e},{default:w(()=>[a(v(d(Y)[e]),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])])]),r(`div`,dt,[r(`p`,ft,v(d(Y)[E.value])+` in range`,1),r(`p`,pt,v(U.value(me.value)),1)])]),I.value?(k(),t(`p`,mt,[i[2]||=a(` Showing `,-1),r(`span`,ht,v(d(f).scope),1),i[3]||=a(` directly — clear the scope filter to break spend down by model, provider, or group. `,-1)])):S(``,!0),d(g).error?(k(),t(`p`,gt,v(d(g).error),1)):S(``,!0),d(h).error?(k(),t(`p`,_t,v(d(h).error),1)):S(``,!0),d(f).cmpSpec.requested&&d(g).comparisonUnavailableReason?(k(),t(`p`,vt,v(d(g).comparisonUnavailableReason),1)):S(``,!0),s(ve,{labels:V.value,datasets:H.value,"comparison-datasets":pe.value,stacked:``,"value-formatter":U.value,ariaLabel:`${d(Y)[E.value]} breakdown ${o[T.value].toLowerCase()} over time`},null,8,[`labels`,`datasets`,`comparison-datasets`,`value-formatter`,`ariaLabel`]),r(`div`,yt,[d(g).burndownAvailable?(k(),l(Ve,{key:0,buckets:d(g).burndownBuckets,points:d(g).burndownPoints,"budget-micros":d(g).burndownBudgetMicros,now:d(_)},null,8,[`buckets`,`points`,`budget-micros`,`now`])):S(``,!0),_e.value?(k(),l(he,{key:1,"mtd-micros":ge.value,limits:W.value,now:d(_)},null,8,[`mtd-micros`,`limits`,`now`])):S(``,!0)]),s($e,{models:d(g).modelRanking,catalog:d(h).modelsById,"ref-model":D.value,"cache-stats-enabled":K.value,"cache-savings-available":J.value,"cache-savings-note":X.value,"onUpdate:refModel":M},null,8,[`models`,`catalog`,`ref-model`,`cache-stats-enabled`,`cache-savings-available`,`cache-savings-note`]),s(it,{models:d(g).pricingHealthRanking,catalog:d(h).modelsById},null,8,[`models`,`catalog`]),s(Pe,{rows:d(g).drilldownRows,metrics:d(g).drilldownMetrics,drill:O.value,disabled:d(g).drilldownDisabled,"user-model-stats-enabled":G.value,window:d(f).window,span:d(f).span,"onUpdate:drill":P},null,8,[`rows`,`metrics`,`drill`,`disabled`,`user-model-stats-enabled`,`window`,`span`])]))}});export{bt as default};",
+		),
+	},
+	"TargetsPage-Bi0CL-u6.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{At as e,C as t,Er as n,Et as r,It as i,Lt as a,Or as o,Ot as s,Qn as c,Rr as l,S as u,Xt as d,b as f,br as p,d as m,di as h,h as g,kt as _,rr as v,s as y,t as b,v as x,wn as S,x as C,zt as w}from"./nav-Dzb0OTN_.js";import{t as T}from"./CardDescription-IdOt317c.js";import{t as E}from"./index-BiTQ_gCE.js";import{t as D}from"./DataTable-DVueNFuA.js";import{l as O,s as k,t as A}from"./badge-ns0j8OUr.js";import{t as j}from"./CompactNumber-B1ihQZH7.js";import{n as M,t as N}from"./useSearchQuery-DysBt-In.js";import{t as P}from"./ClampedRangeNotice-Bvhm1e-B.js";function F(e,t,n){return{id:e,header:t,accessorFn:n,meta:{align:`right`},cell:({row:e})=>d(j,{value:n(e.original)})}}var I=`not observed yet — no traffic and probes disabled or not yet run`;function L(e){let t=k(e.lastCheck);return t?`unhealthy (${t})`:`unhealthy`}function R(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 z(e){let t=k(e.lastCheck);return t?e.source?`${t} via ${e.source}`:t:e.source?`via ${e.source}`:``}function B(e){if(e.consecutiveFailures<=0&&!e.lastError)return I;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 V(e){if(e.state===`unhealthy`)return d(A,{as:`span`,variant:`destructive`,class:`font-normal`,title:R(e)},()=>L(e));if(e.state===`healthy`){let t=e.latencyMs===void 0?``:` · ${O(e.latencyMs)}`;return d(`span`,{class:`text-muted-foreground`,title:z(e)},`healthy${t}`)}return d(A,{as:`span`,variant:`outline`,class:`font-normal`,title:B(e)},()=>`unknown`)}function H(e){return[{id:`name`,header:`Name`,accessorFn:e=>e.name,cell:({row:t})=>e?d(`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):d(`span`,{class:`font-medium`},t.original.name)},{id:`url`,header:`URL`,accessorFn:e=>e.url,cell:({row:e})=>d(`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})=>V(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?d(`span`,{class:`text-muted-foreground`},`All groups`):t.length===0?d(`span`,{class:`text-muted-foreground`},`No groups`):d(`div`,{class:`flex flex-wrap gap-1.5`},t.map(e=>d(A,{key:e,as:`span`,variant:`secondary`,class:`font-mono font-normal`},()=>e)))}},F(`reqMin`,`req/min`,e=>e.counters.requestsPerMinute),F(`reqDay`,`req/day`,e=>e.counters.requestsPerDay),F(`reqMonth`,`req/month`,e=>e.counters.requestsPerMonth)]}function U(e,t){return`${e}/${t}`}function W(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 G(e){let t=[];return e&&t.push({id:`target`,header:`Target`,accessorFn:e=>{let t=W(e.id);return`${t.kind}/${t.target}`},cell:({row:e})=>{let t=W(e.original.id);return d(`span`,{class:`font-mono text-xs text-muted-foreground`},`${t.kind}/${t.target}`)}}),t.push({id:`caller`,header:`Caller`,accessorFn:e=>W(e.id).caller||e.id,cell:({row:e})=>{let t=W(e.original.id).caller;return d(`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})=>d(j,{value:e.original.values.req??0})}),t}var K={key:0,class:`text-sm text-destructive`},q=w({__name:`TargetCallers`,props:{target:{},title:{},limit:{default:10}},setup(n){let d=n,p=E(),g=o([]),b=o(!1),w=o(!1),O=o(``),k=0;async function A(){let e=++k;b.value=!0;try{let{window:t,span:n}=y(p.window,p.span),r=await x(m({kind:`targetcaller`,window:t,span:n,metrics:[`req`],limit:d.limit,target:d.target}));if(e!==k)return;g.value=r.rows,O.value=``}catch(t){if(e!==k)return;O.value=t instanceof Error?t.message:String(t)}finally{e===k&&(b.value=!1,w.value=!0)}}c([()=>d.target,()=>p.window,()=>p.span],()=>void A(),{immediate:!0});let j=r(()=>G(!d.target)),M=r(()=>w.value?`no callers recorded in this window`:`loading…`);return(r,o)=>(S(),s(l(t),null,{default:v(()=>[a(l(C),null,{default:v(()=>[a(l(f),null,{default:v(()=>[i(h(n.title),1)]),_:1}),a(l(T),null,{default:v(()=>[...o[0]||=[i(`Ranked by requests, most recent day/month window available for the current range.`,-1)]]),_:1})]),_:1}),a(l(u),{class:`flex flex-col gap-3`},{default:v(()=>[a(P,{window:l(p).window,span:l(p).span},null,8,[`window`,`span`]),O.value?(S(),e(`p`,K,h(O.value),1)):_(``,!0),a(D,{columns:j.value,data:g.value,"empty-message":M.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1}))}}),J={class:`flex flex-col gap-6`},Y=w({__name:`TargetsView`,emits:[`select`],setup(n,{emit:o}){let s=g(),c=r(()=>s.targets),d=o;function m(e){return t=>d(`select`,U(e,t.name),t.name)}let{query:h,normalized:_,hasQuery:y}=N();function b(e){return e.name.toLowerCase().includes(_.value)}let x=r(()=>{let e=c.value?.mcpServers??[];return y.value?e.filter(b):e}),w=r(()=>{let e=c.value?.agents??[];return y.value?e.filter(b):e});function E(e,t){return e?y.value&&t===0?`no targets match "${h.value}"`:`none`:`none configured`}let O=r(()=>E(c.value?.mcpServers.length??0,x.value.length)),k=r(()=>E(c.value?.agents.length??0,w.value.length)),A=H(m(`mcp`)),j=H(m(`agent`));return(n,r)=>(S(),e(`div`,J,[a(M,{modelValue:l(h),"onUpdate:modelValue":r[0]||=e=>p(h)?h.value=e:null,placeholder:`Filter MCP servers or agents`,class:`max-w-sm`},null,8,[`modelValue`]),a(l(t),null,{default:v(()=>[a(l(C),null,{default:v(()=>[a(l(f),null,{default:v(()=>[...r[1]||=[i(`MCP servers`,-1)]]),_:1}),a(l(T),null,{default:v(()=>[...r[2]||=[i(` Configured MCP proxy targets, the groups allowed to reach them, and their request counters. Click a name to see its callers. `,-1)]]),_:1})]),_:1}),a(l(u),null,{default:v(()=>[a(D,{columns:l(A),data:x.value,"empty-message":O.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1}),a(l(t),null,{default:v(()=>[a(l(C),null,{default:v(()=>[a(l(f),null,{default:v(()=>[...r[3]||=[i(`Agents`,-1)]]),_:1}),a(l(T),null,{default:v(()=>[...r[4]||=[i(` 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}),a(l(u),null,{default:v(()=>[a(D,{columns:l(j),data:w.value,"empty-message":k.value},null,8,[`columns`,`data`,`empty-message`])]),_:1})]),_:1})]))}}),X={class:`flex flex-col gap-6`},Z=w({__name:`TargetsPage`,setup(t){let i=b(),o=r(()=>i.params.target??``),c=n({}),l=r(()=>c[o.value]??o.value);function u(e,t){c[e]=t,i.goTo(`targets`,{...i.params,target:e})}return(t,n)=>(S(),e(`div`,X,[a(Y,{onSelect:u}),o.value?(S(),s(q,{key:0,target:o.value,title:`Callers of ${l.value}`},null,8,[`target`,`title`])):_(``,!0),a(q,{title:`Top callers, across every target`})]))}});export{Z as default};",
+		),
+	},
+	"TimeSeriesChart-BP5IcUyg.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{At as e,Dt as t,Et as n,Lt as r,Nr as i,Or as a,Qn as o,Rr as s,Sn as c,Wn as l,Xt as u,_r as d,di as f,dn as p,jr as m,mn as h,vn as g,wn as _,zt as v}from"./nav-Dzb0OTN_.js";import{c as y}from"./badge-ns0j8OUr.js";function b(e){return e+.5|0}var x=(e,t,n)=>Math.max(Math.min(e,n),t);function S(e){return x(b(e*2.55),0,255)}function C(e){return x(b(e*255),0,255)}function w(e){return x(b(e/2.55)/100,0,1)}function T(e){return x(b(e*100),0,100)}var E={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},D=[...`0123456789ABCDEF`],ee=e=>D[e&15],te=e=>D[(e&240)>>4]+D[e&15],ne=e=>(e&240)>>4==(e&15),re=e=>ne(e.r)&&ne(e.g)&&ne(e.b)&&ne(e.a);function ie(e){var t=e.length,n;return e[0]===`#`&&(t===4||t===5?n={r:255&E[e[1]]*17,g:255&E[e[2]]*17,b:255&E[e[3]]*17,a:t===5?E[e[4]]*17:255}:(t===7||t===9)&&(n={r:E[e[1]]<<4|E[e[2]],g:E[e[3]]<<4|E[e[4]],b:E[e[5]]<<4|E[e[6]],a:t===9?E[e[7]]<<4|E[e[8]]:255})),n}var ae=(e,t)=>e<255?t(e):``;function oe(e){var t=re(e)?ee:te;return e?`#`+t(e.r)+t(e.g)+t(e.b)+ae(e.a,t):void 0}var se=/^(hsla?|hwb|hsv)\(\s*([-+.e\d]+)(?:deg)?[\s,]+([-+.e\d]+)%[\s,]+([-+.e\d]+)%(?:[\s,]+([-+.e\d]+)(%)?)?\s*\)$/;function ce(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 le(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 ue(e,t,n){let r=ce(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 de(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 fe(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=de(t,n,r,l,i),s=s*60+.5),[s|0,c||0,o]}function pe(e,t,n,r){return(Array.isArray(t)?e(t[0],t[1],t[2]):e(t,n,r)).map(C)}function me(e,t,n){return pe(ce,e,t,n)}function he(e,t,n){return pe(ue,e,t,n)}function ge(e,t,n){return pe(le,e,t,n)}function _e(e){return(e%360+360)%360}function ve(e){let t=se.exec(e),n=255,r;if(!t)return;t[5]!==r&&(n=t[6]?S(+t[5]):C(+t[5]));let i=_e(+t[2]),a=t[3]/100,o=t[4]/100;return r=t[1]===`hwb`?he(i,a,o):t[1]===`hsv`?ge(i,a,o):me(i,a,o),{r:r[0],g:r[1],b:r[2],a:n}}function ye(e,t){var n=fe(e);n[0]=_e(n[0]+t),n=me(n),e.r=n[0],e.g=n[1],e.b=n[2]}function be(e){if(!e)return;let t=fe(e),n=t[0],r=T(t[1]),i=T(t[2]);return e.a<255?`hsla(${n}, ${r}%, ${i}%, ${w(e.a)})`:`hsl(${n}, ${r}%, ${i}%)`}var xe={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`},Se={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 Ce(){let e={},t=Object.keys(Se),n=Object.keys(xe),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,xe[a]);a=parseInt(Se[o],16),e[s]=[a>>16&255,a>>8&255,a&255]}return e}var we;function Te(e){we||(we=Ce(),we.transparent=[0,0,0,0]);let t=we[e.toLowerCase()];return t&&{r:t[0],g:t[1],b:t[2],a:t.length===4?t[3]:255}}var Ee=/^rgba?\(\s*([-+.\d]+)(%)?[\s,]+([-+.e\d]+)(%)?[\s,]+([-+.e\d]+)(%)?(?:[\s,/]+([-+.e\d]+)(%)?)?\s*\)$/;function De(e){let t=Ee.exec(e),n=255,r,i,a;if(t){if(t[7]!==r){let e=+t[7];n=t[8]?S(e):x(e*255,0,255)}return r=+t[1],i=+t[3],a=+t[5],r=255&(t[2]?S(r):x(r,0,255)),i=255&(t[4]?S(i):x(i,0,255)),a=255&(t[6]?S(a):x(a,0,255)),{r,g:i,b:a,a:n}}}function Oe(e){return e&&(e.a<255?`rgba(${e.r}, ${e.g}, ${e.b}, ${w(e.a)})`:`rgb(${e.r}, ${e.g}, ${e.b})`)}var ke=e=>e<=.0031308?e*12.92:e**(1/2.4)*1.055-.055,Ae=e=>e<=.04045?e/12.92:((e+.055)/1.055)**2.4;function je(e,t,n){let r=Ae(w(e.r)),i=Ae(w(e.g)),a=Ae(w(e.b));return{r:C(ke(r+n*(Ae(w(t.r))-r))),g:C(ke(i+n*(Ae(w(t.g))-i))),b:C(ke(a+n*(Ae(w(t.b))-a))),a:e.a+n*(t.a-e.a)}}function Me(e,t,n){if(e){let r=fe(e);r[t]=Math.max(0,Math.min(r[t]+r[t]*n,t===0?360:1)),r=me(r),e.r=r[0],e.g=r[1],e.b=r[2]}}function Ne(e,t){return e&&Object.assign(t||{},e)}function Pe(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=C(e[3]))):(t=Ne(e,{r:0,g:0,b:0,a:1}),t.a=C(t.a)),t}function Fe(e){return e.charAt(0)===`r`?De(e):ve(e)}var Ie=class e{constructor(t){if(t instanceof e)return t;let n=typeof t,r;n===`object`?r=Pe(t):n===`string`&&(r=ie(t)||Te(t)||Fe(t)),this._rgb=r,this._valid=!!r}get valid(){return this._valid}get rgb(){var e=Ne(this._rgb);return e&&(e.a=w(e.a)),e}set rgb(e){this._rgb=Pe(e)}rgbString(){return this._valid?Oe(this._rgb):void 0}hexString(){return this._valid?oe(this._rgb):void 0}hslString(){return this._valid?be(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=je(this._rgb,e._rgb,t)),this}clone(){return new e(this.rgb)}alpha(e){return this._rgb.a=C(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=b(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 Me(this._rgb,2,e),this}darken(e){return Me(this._rgb,2,-e),this}saturate(e){return Me(this._rgb,1,e),this}desaturate(e){return Me(this._rgb,1,-e),this}rotate(e){return ye(this._rgb,e),this}};function O(){}var Le=(()=>{let e=0;return()=>e++})();function k(e){return e==null}function A(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 j(e){return e!==null&&Object.prototype.toString.call(e)===`[object Object]`}function M(e){return(typeof e==`number`||e instanceof Number)&&isFinite(+e)}function N(e,t){return M(e)?e:t}function P(e,t){return e===void 0?t:e}var Re=(e,t)=>typeof e==`string`&&e.endsWith(`%`)?parseFloat(e)/100*t:+e;function F(e,t,n){if(e&&typeof e.call==`function`)return e.apply(n,t)}function I(e,t,n,r){let i,a,o;if(A(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(j(e))for(o=Object.keys(e),a=o.length,i=0;i<a;i++)t.call(n,e[o[i]],o[i])}function ze(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 Be(e){if(A(e))return e.map(Be);if(j(e)){let t=Object.create(null),n=Object.keys(e),r=n.length,i=0;for(;i<r;++i)t[n[i]]=Be(e[n[i]]);return t}return e}function Ve(e){return[`__proto__`,`prototype`,`constructor`].indexOf(e)===-1}function He(e,t,n,r){if(!Ve(e))return;let i=t[e],a=n[e];j(i)&&j(a)?Ue(i,a,r):t[e]=Be(a)}function Ue(e,t,n){let r=A(t)?t:[t],i=r.length;if(!j(e))return e;n||={};let a=n.merger||He,o;for(let t=0;t<i;++t){if(o=r[t],!j(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 We(e,t){return Ue(e,t,{merger:Ge})}function Ge(e,t,n){if(!Ve(e))return;let r=t[e],i=n[e];j(r)&&j(i)?We(r,i):Object.prototype.hasOwnProperty.call(t,e)||(t[e]=Be(i))}var Ke={"":e=>e,x:e=>e.x,y:e=>e.y};function qe(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 Je(e){let t=qe(e);return e=>{for(let n of t){if(n===``)break;e&&=e[n]}return e}}function Ye(e,t){return(Ke[t]||(Ke[t]=Je(t)))(e)}function Xe(e){return e.charAt(0).toUpperCase()+e.slice(1)}var Ze=e=>e!==void 0,Qe=e=>typeof e==`function`,$e=(e,t)=>{if(e.size!==t.size)return!1;for(let n of e)if(!t.has(n))return!1;return!0};function et(e){return e.type===`mouseup`||e.type===`click`||e.type===`contextmenu`}var L=Math.PI,R=2*L,tt=R+L,nt=1/0,rt=L/180,z=L/2,it=L/4,at=L*2/3,B=Math.log10,ot=Math.sign;function st(e,t,n){return Math.abs(e-t)<n}function ct(e){let t=Math.round(e);e=st(e,t,e/1e3)?t:e;let n=10**Math.floor(B(e)),r=e/n;return(r<=1?1:r<=2?2:r<=5?5:10)*n}function lt(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 ut(e){return typeof e==`symbol`||typeof e==`object`&&!!e&&!(Symbol.toPrimitive in e||`toString`in e||`valueOf`in e)}function dt(e){return!ut(e)&&!isNaN(parseFloat(e))&&isFinite(e)}function ft(e,t){let n=Math.round(e);return n-t<=e&&n+t>=e}function pt(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 mt(e){return L/180*e}function ht(e){return 180/L*e}function gt(e){if(!M(e))return;let t=1,n=0;for(;Math.round(e*t)/t!==e;)t*=10,n++;return n}function _t(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*L&&(a+=R),{angle:a,distance:i}}function vt(e,t){return Math.sqrt((t.x-e.x)**2+(t.y-e.y)**2)}function yt(e,t){return(e-t+tt)%R-L}function V(e){return(e%R+R)%R}function bt(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 xt(e){return H(e,-32768,32767)}function St(e,t,n,r=1e-6){return e>=Math.min(t,n)-r&&e<=Math.max(t,n)+r}function Ct(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 wt=(e,t,n,r)=>Ct(e,n,r?r=>{let i=e[r][t];return i<n||i===n&&e[r+1][t]===n}:r=>e[r][t]<n),Tt=(e,t,n)=>Ct(e,n,r=>e[r][t]>=n);function Et(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 Dt=[`push`,`pop`,`shift`,`splice`,`unshift`];function Ot(e,t){if(e._chartjs){e._chartjs.listeners.push(t);return}Object.defineProperty(e,"_chartjs",{configurable:!0,enumerable:!1,value:{listeners:[t]}}),Dt.forEach(t=>{let n=`_onData`+Xe(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 kt(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)&&(Dt.forEach(t=>{delete e[t]}),delete e._chartjs)}function At(e){let t=new Set(e);return t.size===e.length?e:Array.from(t)}var jt=function(){return typeof window>`u`?function(e){return e()}:window.requestAnimationFrame}();function Mt(e,t){let n=[],r=!1;return function(...i){n=i,r||(r=!0,jt.call(window,()=>{r=!1,e.apply(t,n)}))}}function Nt(e,t){let n;return function(...r){return t?(clearTimeout(n),n=setTimeout(e,t,r)):e.apply(this,r),t}}var Pt=e=>e===`start`?`left`:e===`end`?`right`:`center`,U=(e,t,n)=>e===`start`?t:e===`end`?n:(t+n)/2,Ft=(e,t,n,r)=>e===(r?`left`:`right`)?n:e===`center`?(t+n)/2:t;function It(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(wt(c,u,d).lo,n?r:wt(t,u,o.getPixelForValue(d)).lo),l){let e=c.slice(0,i+1).reverse().findIndex(e=>!k(e[s.axis]));i-=Math.max(0,e)}i=H(i,0,r-1)}if(m){let e=Math.max(wt(c,o.axis,f,!0).hi+1,n?0:wt(t,u,o.getPixelForValue(f),!0).hi+1);if(l){let t=c.slice(e-1).findIndex(e=>!k(e[s.axis]));e+=Math.max(0,t)}a=H(e,i,r)-i}else a=r-i}return{start:i,count:a}}function Lt(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 Rt=e=>e===0||e===1,zt=(e,t,n)=>-(2**(10*--e)*Math.sin((e-t)*R/n)),Bt=(e,t,n)=>2**(-10*e)*Math.sin((e-t)*R/n)+1,Vt={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*z)+1,easeOutSine:e=>Math.sin(e*z),easeInOutSine:e=>-.5*(Math.cos(L*e)-1),easeInExpo:e=>e===0?0:2**(10*(e-1)),easeOutExpo:e=>e===1?1:-(2**(-10*e))+1,easeInOutExpo:e=>Rt(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=>Rt(e)?e:zt(e,.075,.3),easeOutElastic:e=>Rt(e)?e:Bt(e,.075,.3),easeInOutElastic(e){let t=.1125,n=.45;return Rt(e)?e:e<.5?.5*zt(e*2,t,n):.5+.5*Bt(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-Vt.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?Vt.easeInBounce(e*2)*.5:Vt.easeOutBounce(e*2-1)*.5+.5};function Ht(e){if(e&&typeof e==`object`){let t=e.toString();return t===`[object CanvasPattern]`||t===`[object CanvasGradient]`}return!1}function Ut(e){return Ht(e)?e:new Ie(e)}function Wt(e){return Ht(e)?e:new Ie(e).saturate(.5).darken(.1).hexString()}var Gt=[`x`,`y`,`borderWidth`,`radius`,`tension`],Kt=[`color`,`borderColor`,`backgroundColor`];function qt(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:Kt},numbers:{type:`number`,properties:Gt}}),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 Jt(e){e.set(`layout`,{autoPadding:!0,padding:{top:0,right:0,bottom:0,left:0}})}var Yt=new Map;function Xt(e,t){t||={};let n=e+JSON.stringify(t),r=Yt.get(n);return r||(r=new Intl.NumberFormat(e,t),Yt.set(n,r)),r}function Zt(e,t,n){return Xt(t,n).format(e)}var Qt={values(e){return A(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=$t(e,n)}let o=B(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),Zt(e,r,c)},logarithmic(e,t,n){if(e===0)return`0`;let r=n[t].significand||e/10**Math.floor(B(e));return[1,2,3,5,10,15].includes(r)||t>.8*n.length?Qt.numeric.call(this,e,t,n):``}};function $t(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 en={formatters:Qt};function tn(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:en.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 nn=Object.create(null),rn=Object.create(null);function an(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 on(e,t,n){return typeof t==`string`?Ue(an(e,t),n):Ue(an(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)=>Wt(t.backgroundColor),this.hoverBorderColor=(e,t)=>Wt(t.borderColor),this.hoverColor=(e,t)=>Wt(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 on(this,e,t)}get(e){return an(this,e)}describe(e,t){return on(rn,e,t)}override(e,t){return on(nn,e,t)}route(e,t,n,r){let i=an(this,e),a=an(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 j(e)?Object.assign({},t,e):P(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}},[qt,Jt,tn]);function sn(e){return!e||k(e.size)||k(e.family)?null:(e.style?e.style+` `:``)+(e.weight?e.weight+` `:``)+e.size+`px `+e.family}function cn(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 ln(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&&!A(d))o=cn(e,i,a,o,d);else if(A(d))for(l=0,u=d.length;l<u;l++)f=d[l],f!=null&&!A(f)&&(o=cn(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 un(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 dn(e,t){!t&&!e||(t||=e.getContext(`2d`),t.save(),t.resetTransform(),t.clearRect(0,0,e.width,e.height),t.restore())}function fn(e,t,n,r){pn(e,t,n,r,null)}function pn(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)*rt;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,R):e.arc(n,r,h,0,R),e.closePath();break;case`triangle`:u=i?i/2:h,e.moveTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=at,e.lineTo(n+Math.sin(g)*u,r-Math.cos(g)*h),g+=at,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+it)*c,d=Math.cos(g+it)*(i?i/2-l:c),s=Math.sin(g+it)*c,f=Math.sin(g+it)*(i?i/2-l:c),e.arc(n-d,r-s,l,g-L,g-z),e.arc(n+f,r-o,l,g-z,g),e.arc(n+d,r+s,l,g,g+z),e.arc(n-f,r+o,l,g+z,g+L),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+=it;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+=it;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+=it,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 mn(e,t){e.save(),e.beginPath(),e.rect(t.left,t.top,t.right-t.left,t.bottom-t.top),e.clip()}function hn(e){e.restore()}function gn(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 _n(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 vn(e,t){t.translation&&e.translate(t.translation[0],t.translation[1]),k(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 yn(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 bn(e,t){let n=e.fillStyle;e.fillStyle=t.color,e.fillRect(t.left,t.top,t.width,t.height),e.fillStyle=n}function xn(e,t,n,r,i,a={}){let o=A(t)?t:[t],s=a.strokeWidth>0&&a.strokeColor!==``,c,l;for(e.save(),e.font=i.string,vn(e,a),c=0;c<o.length;++c)l=o[c],a.backdrop&&bn(e,a.backdrop),s&&(a.strokeColor&&(e.strokeStyle=a.strokeColor),k(a.strokeWidth)||(e.lineWidth=a.strokeWidth),e.strokeText(l,n,r,a.maxWidth)),e.fillText(l,n,r,a.maxWidth),yn(e,n,r,l,a),r+=Number(i.lineHeight);e.restore()}function Sn(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*L,L,!0),e.lineTo(n,r+a-o.bottomLeft),e.arc(n+o.bottomLeft,r+a-o.bottomLeft,o.bottomLeft,L,z,!0),e.lineTo(n+i-o.bottomRight,r+a),e.arc(n+i-o.bottomRight,r+a-o.bottomRight,o.bottomRight,z,0,!0),e.lineTo(n+i,r+o.topRight),e.arc(n+i-o.topRight,r+o.topRight,o.topRight,0,-z,!0),e.lineTo(n+o.topLeft,r)}var Cn=/^(normal|(\d+(?:\.\d+)?)(px|em|%)?)$/,wn=/^(normal|italic|initial|inherit|unset|(oblique( -?[0-9]?[0-9]deg)?))$/;function Tn(e,t){let n=(``+e).match(Cn);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 En=e=>+e||0;function Dn(e,t){let n={},r=j(t),i=r?Object.keys(t):t,a=j(e)?r?n=>P(e[n],e[t[n]]):t=>e[t]:()=>e;for(let e of i)n[e]=En(a(e));return n}function On(e){return Dn(e,{top:`y`,right:`x`,bottom:`y`,left:`x`})}function kn(e){return Dn(e,[`topLeft`,`topRight`,`bottomLeft`,`bottomRight`])}function K(e){let t=On(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=P(e.size,t.size);typeof n==`string`&&(n=parseInt(n,10));let r=P(e.style,t.style);r&&!(``+r).match(wn)&&(console.warn(`Invalid font style specified: "`+r+`"`),r=void 0);let i={family:P(e.family,t.family),lineHeight:Tn(P(e.lineHeight,t.lineHeight),n),size:n,style:r,weight:P(e.weight,t.weight),string:``};return i.string=sn(i),i}function An(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&&A(s)&&(s=s[n%s.length],i=!1),s!==void 0))return r&&!i&&(r.cacheable=!1),s}function jn(e,t,n){let{min:r,max:i}=e,a=Re(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 Mn(e,t){return Object.assign(Object.create(e),t)}function Nn(e,t=[``],n,r,i=()=>e[0]){let a=n||e;return r===void 0&&(r=Yn(`_fallback`,e)),new Proxy({[Symbol.toStringTag]:`Object`,_cacheable:!0,_scopes:e,_rootScopes:a,_fallback:r,_getTarget:i,override:n=>Nn([n,...e],t,a,r)},{deleteProperty(t,n){return delete t[n],delete t._keys,delete e[0][n],!0},get(n,r){return Rn(n,r,()=>Jn(r,t,e,n))},getOwnPropertyDescriptor(e,t){return Reflect.getOwnPropertyDescriptor(e._scopes[0],t)},getPrototypeOf(){return Reflect.getPrototypeOf(e[0])},has(e,t){return Xn(e).includes(t)},ownKeys(e){return Xn(e)},set(e,t,n){let r=e._storage||=i();return e[t]=r[t]=n,delete e._keys,!0}})}function Pn(e,t,n,r){let i={_cacheable:!1,_proxy:e,_context:t,_subProxy:n,_stack:new Set,_descriptors:Fn(e,r),setContext:t=>Pn(e,t,n,r),override:i=>Pn(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 Rn(e,t,()=>zn(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 Fn(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:Qe(n)?n:()=>n,isIndexable:Qe(r)?r:()=>r}}var In=(e,t)=>e?e+Xe(t):t,Ln=(e,t)=>j(t)&&e!==`adapters`&&(Object.getPrototypeOf(t)===null||t.constructor===Object);function Rn(e,t,n){if(Object.prototype.hasOwnProperty.call(e,t)||t===`constructor`)return e[t];let r=n();return e[t]=r,r}function zn(e,t,n){let{_proxy:r,_context:i,_subProxy:a,_descriptors:o}=e,s=r[t];return Qe(s)&&o.isScriptable(t)&&(s=Bn(t,s,e,n)),A(s)&&s.length&&(s=Vn(t,s,e,o.isIndexable)),Ln(t,s)&&(s=Pn(s,i,a&&a[t],o)),s}function Bn(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),Ln(e,c)&&(c=Gn(i._scopes,i,e,c)),c}function Vn(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(j(t[0])){let n=t,r=i._scopes.filter(e=>e!==n);t=[];for(let c of n){let n=Gn(r,i,e,c);t.push(Pn(n,a,o&&o[e],s))}}return t}function Hn(e,t,n){return Qe(e)?e(t,n):e}var Un=(e,t)=>e===!0?t:typeof e==`string`?Ye(t,e):void 0;function Wn(e,t,n,r,i){for(let a of t){let t=Un(n,a);if(t){e.add(t);let a=Hn(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 Gn(e,t,n,r){let i=t._rootScopes,a=Hn(t._fallback,n,r),o=[...e,...i],s=new Set;s.add(r);let c=Kn(s,o,n,a||n,r);return c===null||a!==void 0&&a!==n&&(c=Kn(s,o,a,c,r),c===null)?!1:Nn(Array.from(s),[``],i,a,()=>qn(t,n,r))}function Kn(e,t,n,r,i){for(;n;)n=Wn(e,t,n,r,i);return n}function qn(e,t,n){let r=e._getTarget();t in r||(r[t]={});let i=r[t];return A(i)&&j(n)?n:i||{}}function Jn(e,t,n,r){let i;for(let a of t)if(i=Yn(In(a,e),n),i!==void 0)return Ln(e,i)?Gn(n,r,e,i):i}function Yn(e,t){for(let n of t){if(!n)continue;let t=n[e];if(t!==void 0)return t}}function Xn(e){let t=e._keys;return t||=e._keys=Zn(e._scopes),t}function Zn(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 Qn=2**-52||1e-14,$n=(e,t)=>t<e.length&&!e[t].skip&&e[t],er=e=>e===`x`?`y`:`x`;function tr(e,t,n,r){let i=e.skip?t:e,a=t,o=n.skip?t:n,s=vt(a,i),c=vt(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 nr(e,t,n){let r=e.length,i,a,o,s,c,l=$n(e,0);for(let u=0;u<r-1;++u)if(c=l,l=$n(e,u+1),!(!c||!l)){if(st(t[u],0,Qn)){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 rr(e,t,n=`x`){let r=er(n),i=e.length,a,o,s,c=$n(e,0);for(let l=0;l<i;++l){if(o=s,s=c,c=$n(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 ir(e,t=`x`){let n=er(t),r=e.length,i=Array(r).fill(0),a=Array(r),o,s,c,l=$n(e,0);for(o=0;o<r;++o)if(s=c,c=l,l=$n(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?ot(i[o-1])===ot(i[o])?(i[o-1]+i[o])/2:0:i[o-1]:i[o]}nr(e,i,a),rr(e,a,t)}function ar(e,t,n){return Math.max(Math.min(e,n),t)}function or(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=ar(i.cp1x,t.left,t.right),i.cp1y=ar(i.cp1y,t.top,t.bottom)),s&&(i.cp2x=ar(i.cp2x,t.left,t.right),i.cp2y=ar(i.cp2y,t.top,t.bottom)))}function sr(e,t,n,r,i){let a,o,s,c;if(t.spanGaps&&(e=e.filter(e=>!e.skip)),t.cubicInterpolationMode===`monotone`)ir(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=tr(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&&or(e,n)}function cr(){return typeof window<`u`&&typeof document<`u`}function lr(e){let t=e.parentNode;return t&&t.toString()===`[object ShadowRoot]`&&(t=t.host),t}function ur(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 dr=e=>e.ownerDocument.defaultView.getComputedStyle(e,null);function fr(e,t){return dr(e).getPropertyValue(t)}var pr=[`top`,`right`,`bottom`,`left`];function mr(e,t,n){let r={};n=n?`-`+n:``;for(let i=0;i<4;i++){let a=pr[i];r[a]=parseFloat(e[t+`-`+a+n])||0}return r.width=r.left+r.right,r.height=r.top+r.bottom,r}var hr=(e,t,n)=>(e>0||t>0)&&(!n||!n.shadowRoot);function gr(e,t){let n=e.touches,r=n&&n.length?n[0]:e,{offsetX:i,offsetY:a}=r,o=!1,s,c;if(hr(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 _r(e,t){if(`native`in e)return e;let{canvas:n,currentDevicePixelRatio:r}=t,i=dr(n),a=i.boxSizing===`border-box`,o=mr(i,`padding`),s=mr(i,`border`,`width`),{x:c,y:l,box:u}=gr(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 vr(e,t,n){let r,i;if(t===void 0||n===void 0){let a=e&&lr(e);if(!a)t=e.clientWidth,n=e.clientHeight;else{let e=a.getBoundingClientRect(),o=dr(a),s=mr(o,`border`,`width`),c=mr(o,`padding`);t=e.width-c.width-s.width,n=e.height-c.height-s.height,r=ur(o.maxWidth,a,`clientWidth`),i=ur(o.maxHeight,a,`clientHeight`)}}return{width:t,height:n,maxWidth:r||nt,maxHeight:i||nt}}var yr=e=>Math.round(e*10)/10;function br(e,t,n,r){let i=dr(e),a=mr(i,`margin`),o=ur(i.maxWidth,e,`clientWidth`)||nt,s=ur(i.maxHeight,e,`clientHeight`)||nt,c=vr(e,t,n),{width:l,height:u}=c;if(i.boxSizing===`content-box`){let e=mr(i,`border`,`width`),t=mr(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=yr(Math.min(l,o,c.maxWidth)),u=yr(Math.min(u,s,c.maxHeight)),l&&!u&&(u=yr(l/2)),(t!==void 0||n!==void 0)&&r&&c.height&&u>c.height&&(u=c.height,l=yr(Math.floor(u*r))),{width:l,height:u}}function xr(e,t,n){let r=t||1,i=yr(e.height*r),a=yr(e.width*r);e.height=yr(e.height),e.width=yr(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 Sr=function(){let e=!1;try{let t={get passive(){return e=!0,!1}};cr()&&(window.addEventListener(`test`,null,t),window.removeEventListener(`test`,null,t))}catch{}return e}();function Cr(e,t){let n=fr(e,t),r=n&&n.match(/^(\d+)(\.\d+)?px$/);return r?+r[1]:void 0}function wr(e,t,n,r){return{x:e.x+n*(t.x-e.x),y:e.y+n*(t.y-e.y)}}function Tr(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 Er(e,t,n,r){let i={x:e.cp2x,y:e.cp2y},a={x:t.cp1x,y:t.cp1y},o=wr(e,i,n),s=wr(i,a,n),c=wr(a,t,n);return wr(wr(o,s,n),wr(s,c,n),n)}var Dr=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}}},Or=function(){return{x(e){return e},setWidth(e){},textAlign(e){return e},xPlus(e,t){return e+t},leftForLtr(e,t){return e}}};function kr(e,t,n){return e?Dr(t,n):Or()}function Ar(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 jr(e,t){t!==void 0&&(delete e.prevTextDirection,e.canvas.style.setProperty(`direction`,t[0],t[1]))}function Mr(e){return e===`angle`?{between:bt,compare:yt,normalize:V}:{between:St,compare:(e,t)=>e-t,normalize:e=>e}}function Nr({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 Pr(e,t,n){let{property:r,start:i,end:a}=n,{between:o,normalize:s}=Mr(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 Fr(e,t,n){if(!n)return[e];let{property:r,start:i,end:a}=n,o=t.length,{compare:s,between:c,normalize:l}=Mr(r),{start:u,end:d,loop:f,style:p}=Pr(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(Nr({start:g,end:e,loop:f,count:o,style:p})),g=null),n=e,y=_));return g!==null&&m.push(Nr({start:g,end:d,loop:f,count:o,style:p})),m}function Ir(e,t){let n=[],r=e.segments;for(let i=0;i<r.length;i++){let a=Fr(r[i],e.points,t);a.length&&n.push(...a)}return n}function Lr(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 Rr(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 zr(e,t){let n=e.points,r=e.options.spanGaps,i=n.length;if(!i)return[];let a=!!e._loop,{start:o,end:s}=Lr(n,i,a,r);return r===!0?Br(e,[{start:o,end:s,loop:a}],n,t):Br(e,Rr(n,o,s<o?s+i:s,!!e._fullLoop&&o===0&&s===i-1),n,t)}function Br(e,t,n,r){return!r||!r.setContext||!n?t:Vr(e,t,n,r)}function Vr(e,t,n,r){let i=e._chart.getContext(),a=Hr(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=Hr(r.setContext(Mn(i,{type:`segment`,p0:t,p1:s,p0DataIndex:(f-1)%c,p1DataIndex:f%c,datasetIndex:o}))),Ur(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 Hr(e){return{backgroundColor:e.backgroundColor,borderCapStyle:e.borderCapStyle,borderDash:e.borderDash,borderDashOffset:e.borderDashOffset,borderJoinStyle:e.borderJoinStyle,borderWidth:e.borderWidth,borderColor:e.borderColor}}function Ur(e,t){if(!t)return!1;let n=[],r=function(e,t){return Ht(t)?(n.includes(t)||n.push(t),n.indexOf(t)):t};return JSON.stringify(e,r)!==JSON.stringify(t,r)}function Wr(e,t,n){return e.options.clip?e[n]:t[n]}function Gr(e,t){let{xScale:n,yScale:r}=e;return n&&r?{left:Wr(n,t,`left`),right:Wr(n,t,`right`),top:Wr(r,t,`top`),bottom:Wr(r,t,`bottom`)}:t}function Kr(e,t){let n=t._clip;if(n.disabled)return!1;let r=Gr(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,jt.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)}},qr=`transparent`,Jr={boolean(e,t,n){return n>.5?t:e},color(e,t,n){let r=Ut(e||qr),i=r.valid&&Ut(t||qr);return i&&i.valid?i.mix(r,n).hexString():t},number(e,t,n){return e+(t-e)*n}},Yr=class{constructor(e,t,n,r){let i=t[n];r=An([e.to,r,i,e.from]);let a=An([e.from,i,r]);this._active=!0,this._fn=e.fn||Jr[e.type||typeof a],this._easing=Vt[e.easing]||Vt.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=An([e.to,t,r,e.from]),this._from=An([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]()}},Xr=class{constructor(e,t){this._chart=e,this._properties=new Map,this.configure(t)}configure(e){if(!j(e))return;let t=Object.keys(W.animation),n=this._properties;Object.getOwnPropertyNames(e).forEach(r=>{let i=e[r];if(!j(i))return;let a={};for(let e of t)a[e]=i[e];(A(i.properties)&&i.properties||[r]).forEach(e=>{(e===r||!n.has(e))&&n.set(e,a)})})}_animateOptions(e,t){let n=t.options,r=Qr(e,n);if(!r)return[];let i=this._createAnimations(r,n);return n.$shared&&Zr(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 Yr(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 Zr(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 Qr(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 $r(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 ei(e,t,n){if(n===!1)return!1;let r=$r(e,n),i=$r(t,n);return{top:i.end,right:r.end,bottom:i.start,left:r.start}}function ti(e){let t,n,r,i;return j(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 ni(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 ri(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],M(l)&&(a||t===0||ot(t)===ot(l))&&(t+=l)}return!u&&!r.all?0:t}function ii(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 ai(e,t){let n=e&&e.options.stacked;return n||n===void 0&&t.stack!==void 0}function oi(e,t,n){return`${e.id}.${t.id}.${n.stack||n.type}`}function si(e){let{min:t,max:n,minDefined:r,maxDefined:i}=e.getUserBounds();return{min:r?t:-1/0,max:i?n:1/0}}function ci(e,t,n){let r=e[t]||(e[t]={});return r[n]||(r[n]={})}function li(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 ui(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=oi(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]=ci(i,u,a),f[s]=d,f._top=li(f,o,!0,r.type),f._bottom=li(f,o,!1,r.type);let m=f._visualValues||(f._visualValues={});m[s]=d}}function di(e,t){let n=e.scales;return Object.keys(n).filter(e=>n[e].axis===t).shift()}function fi(e,t){return Mn(e,{active:!1,dataset:void 0,datasetIndex:t,index:t,mode:`default`,type:`dataset`})}function pi(e,t,n){return Mn(e,{active:!1,dataIndex:t,parsed:void 0,raw:void 0,element:n,index:t,mode:`default`,type:`data`})}function mi(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 hi=e=>e===`reset`||e===`none`,gi=(e,t)=>t?e:Object.assign({},e),_i=(e,t,n)=>e&&!t.hidden&&t._stacked&&{keys:ni(n,!0),values:null},vi=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=ai(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&&mi(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=P(n.xAxisID,di(e,`x`)),a=t.yAxisID=P(n.yAxisID,di(e,`y`)),o=t.rAxisID=P(n.rAxisID,di(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&&kt(this._data,this),e._stacked&&mi(e)}_dataCheck(){let e=this.getDataset(),t=e.data||=[],n=this._data;if(j(t)){let e=this._cachedMeta;this._data=ii(t,e)}else if(n!==t){if(n){kt(n,this);let e=this._cachedMeta;mi(e),e._parsed=[]}t&&Object.isExtensible(t)&&Ot(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=ai(t.vScale,t),t.stack!==n.stack&&(r=!0,mi(t),t.stack=n.stack),this._resyncElements(e),(r||i!==t._stacked)&&(ui(this,t._parsed),t._stacked=ai(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=A(r[e])?this.parseArrayData(n,r,e,t):j(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&&ui(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(Ye(f,o),d),y:a.parse(Ye(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 ri({keys:ni(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=ri(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=_i(t,n,this.chart),c={min:1/0,max:-1/0},{min:l,max:u}=si(o),d,f;function p(){f=r[d];let t=f[o.axis];return!M(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],M(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=ti(P(this.options.clip,ei(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||=pi(this.getContext(),e,t),i.parsed=this.getParsed(e),i.raw=r.data[e],i.index=i.dataIndex=e}else i=this.$context||=fi(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&&Ze(n);if(o)return gi(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(gi(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 Xr(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||hi(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){hi(r)?Object.assign(e,n):this._resolveAnimations(t,r).update(e,n)}updateSharedOptions(e,t,n){e&&!hi(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&&mi(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])}},yi=class extends vi{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}=It(t,r,a);this._drawStart=o,this._drawCount=s,Lt(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=dt(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=k(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 bi(){throw Error(`This method is not implemented: Check that a complete date adapter is provided.`)}var xi={_date:class e{static override(t){Object.assign(e.prototype,t)}options;constructor(e){this.options=e||{}}init(){}formats(){return bi()}parse(){return bi()}format(){return bi()}add(){return bi()}diff(){return bi()}startOf(){return bi()}endOf(){return bi()}}};function Si(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?Tt:wt;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=>!k(e[t.axis]));r.lo-=Math.max(0,a);let o=n.slice(r.hi).findIndex(e=>!k(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 Ci(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}=Si(a[e],t,o,i);for(let e=c;e<=l;++e){let t=s[e];t.skip||r(t,n,e)}}}function wi(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 Ti(e,t,n,r,i){let a=[];return!i&&!e.isPointInArea(t)||Ci(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 Ei(e,t,n,r){let i=[];function a(e,n,a){let{startAngle:o,endAngle:s}=e.getProps([`startAngle`,`endAngle`],r),{angle:c}=_t(e,{x:t.x,y:t.y});bt(c,o,s)&&i.push({element:e,datasetIndex:n,index:a})}return Ci(e,n,t,a),i}function Di(e,t,n,r,i,a){let o=[],s=wi(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 Ci(e,n,t,l),o}function Oi(e,t,n,r,i,a){return!a&&!e.isPointInArea(t)?[]:n===`r`&&!r?Ei(e,t,n,i):Di(e,t,n,r,i,a)}function ki(e,t,n,r,i){let a=[],o=n===`x`?`inXRange`:`inYRange`,s=!1;return Ci(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 Ai={evaluateInteractionItems:Ci,modes:{index(e,t,n,r){let i=_r(t,e),a=n.axis||`x`,o=n.includeInvisible||!1,s=n.intersect?Ti(e,i,a,r,o):Oi(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=_r(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1,s=n.intersect?Ti(e,i,a,r,o):Oi(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 Ti(e,_r(t,e),n.axis||`xy`,r,n.includeInvisible||!1)},nearest(e,t,n,r){let i=_r(t,e),a=n.axis||`xy`,o=n.includeInvisible||!1;return Oi(e,i,a,n.intersect,r,o)},x(e,t,n,r){return ki(e,_r(t,e),`x`,n.intersect,r)},y(e,t,n,r){return ki(e,_r(t,e),`y`,n.intersect,r)}}},ji=[`left`,`top`,`right`,`bottom`];function Mi(e,t){return e.filter(e=>e.pos===t)}function Ni(e,t){return e.filter(e=>ji.indexOf(e.pos)===-1&&e.box.axis===t)}function Pi(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 Fi(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 Ii(e){let t={};for(let n of e){let{stack:e,pos:r,stackWeight:i}=n;if(!e||!ji.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 Li(e,t){let n=Ii(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 Ri(e){let t=Fi(e),n=Pi(t.filter(e=>e.box.fullSize),!0),r=Pi(Mi(t,`left`),!0),i=Pi(Mi(t,`right`)),a=Pi(Mi(t,`top`),!0),o=Pi(Mi(t,`bottom`)),s=Ni(t,`x`),c=Ni(t,`y`);return{fullSize:n,leftAndTop:r.concat(a),rightAndBottom:i.concat(c).concat(o).concat(s),chartArea:Mi(t,`chartArea`),vertical:r.concat(i).concat(c),horizontal:a.concat(o).concat(s)}}function zi(e,t,n,r){return Math.max(e[n],t[n])+Math.max(e[r],t[r])}function Bi(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 Vi(e,t,n,r){let{pos:i,box:a}=n,o=e.maxPadding;if(!j(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&&Bi(o,a.getPadding());let s=Math.max(0,t.outerWidth-zi(o,e,`left`,`right`)),c=Math.max(0,t.outerHeight-zi(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 Hi(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 Ui(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 Wi(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,Ui(s.horizontal,t));let{same:o,other:d}=Vi(t,n,s,r);l|=o&&i.length,u||=d,c.fullSize||i.push(s)}return l&&Wi(i,t,n,r)||u}function Gi(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 Ki(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;Ze(c.start)&&(o=c.start),e.fullSize?Gi(e,i.left,o,n.outerWidth-i.right-i.left,a):Gi(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;Ze(c.start)&&(a=c.start),e.fullSize?Gi(e,a,i.top,o,n.outerHeight-i.bottom-i.top):Gi(e,a,t.top+c.placed,o,r),c.start=a,c.placed+=r,a=e.right}}t.x=a,t.y=o}var qi={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=Ri(e.boxes),c=s.vertical,l=s.horizontal;I(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);Bi(f,K(r));let p=Object.assign({maxPadding:f,w:a,h:o,x:i.left,y:i.top},i),m=Li(c.concat(l),d);Wi(s.fullSize,p,d,m),Wi(c,p,d,m),Wi(l,p,d,m)&&Wi(c,p,d,m),Hi(p),Ki(s.leftAndTop,p,d,m),p.x+=p.w,p.y+=p.h,Ki(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},I(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})})}},Ji=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){}},Yi=class extends Ji{acquireContext(e){return e&&e.getContext&&e.getContext(`2d`)||null}updateConfig(e){e.options.animation=!1}},Xi=`$chartjs`,Zi={touchstart:`mousedown`,touchmove:`mousemove`,touchend:`mouseup`,pointerenter:`mouseenter`,pointerdown:`mousedown`,pointermove:`mousemove`,pointerup:`mouseup`,pointerleave:`mouseout`,pointerout:`mouseout`},Qi=e=>e===null||e===``;function $i(e,t){let n=e.style,r=e.getAttribute(`height`),i=e.getAttribute(`width`);if(e[Xi]={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`,Qi(i)){let t=Cr(e,`width`);t!==void 0&&(e.width=t)}if(Qi(r)){if(e.style.height===``)e.height=e.width/(t||2);else{let t=Cr(e,`height`);t!==void 0&&(e.height=t)}}return e}var ea=Sr?{passive:!0}:!1;function ta(e,t,n){e&&e.addEventListener(t,n,ea)}function na(e,t,n){e&&e.canvas&&e.canvas.removeEventListener(t,n,ea)}function ra(e,t){let n=Zi[e.type]||e.type,{x:r,y:i}=_r(e,t);return{type:n,chart:t,native:e,x:r===void 0?null:r,y:i===void 0?null:i}}function ia(e,t){for(let n of e)if(n===t||n.contains(t))return!0}function aa(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=ia(n.addedNodes,r),t&&=!ia(n.removedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}function oa(e,t,n){let r=e.canvas,i=new MutationObserver(e=>{let t=!1;for(let n of e)t||=ia(n.removedNodes,r),t&&=!ia(n.addedNodes,r);t&&n()});return i.observe(document,{childList:!0,subtree:!0}),i}var sa=new Map,ca=0;function la(){let e=window.devicePixelRatio;e!==ca&&(ca=e,sa.forEach((t,n)=>{n.currentDevicePixelRatio!==e&&t()}))}function ua(e,t){sa.size||window.addEventListener(`resize`,la),sa.set(e,t)}function da(e){sa.delete(e),sa.size||window.removeEventListener(`resize`,la)}function fa(e,t,n){let r=e.canvas,i=r&&lr(r);if(!i)return;let a=Mt((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),ua(e,a),o}function pa(e,t,n){n&&n.disconnect(),t===`resize`&&da(e)}function ma(e,t,n){let r=e.canvas,i=Mt(t=>{e.ctx!==null&&n(ra(t,e))},e);return ta(r,t,i),i}var ha=class extends Ji{acquireContext(e,t){let n=e&&e.getContext&&e.getContext(`2d`);return n&&n.canvas===e?($i(e,t),n):null}releaseContext(e){let t=e.canvas;if(!t[Xi])return!1;let n=t[Xi].initial;[`height`,`width`].forEach(e=>{let r=n[e];k(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[Xi],!0}addEventListener(e,t,n){this.removeEventListener(e,t);let r=e.$proxies||={};r[t]=({attach:aa,detach:oa,resize:fa}[t]||ma)(e,t,n)}removeEventListener(e,t){let n=e.$proxies||={},r=n[t];r&&(({attach:pa,detach:pa,resize:pa}[t]||na)(e,t,r),n[t]=void 0)}getDevicePixelRatio(){return window.devicePixelRatio}getMaximumSize(e,t,n,r){return br(e,t,n,r)}isAttached(e){let t=e&&lr(e);return!!(t&&t.isConnected)}};function ga(e){return!cr()||typeof OffscreenCanvas<`u`&&e instanceof OffscreenCanvas?Yi:ha}var _a=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 dt(this.x)&&dt(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 va(e,t){let n=e.options.ticks,r=ya(e),i=Math.min(n.maxTicksLimit||r,r),a=n.major.enabled?xa(t):[],o=a.length,s=a[0],c=a[o-1],l=[];if(o>i)return Sa(t,l,a,o/i),l;let u=ba(a,t,i);if(o>0){let e,n,r=o>1?Math.round((c-s)/(o-1)):null;for(Ca(t,l,u,k(r)?0:s-r,s),e=0,n=o-1;e<n;e++)Ca(t,l,u,a[e],a[e+1]);return Ca(t,l,u,c,k(r)?t.length:c+r),l}return Ca(t,l,u),l}function ya(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 ba(e,t,n){let r=wa(e),i=t.length/n;if(!r)return Math.max(i,1);let a=lt(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 xa(e){let t=[],n,r;for(n=0,r=e.length;n<r;n++)e[n].major&&t.push(n);return t}function Sa(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 Ca(e,t,n,r,i){let a=P(r,0),o=Math.min(P(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 wa(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 Ta=e=>e===`left`?`right`:e===`right`?`left`:e,Ea=(e,t,n)=>t===`top`||t===`left`?e[t]+n:e[t]-n,Da=(e,t)=>Math.min(t||e,e);function Oa(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 ka(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 Aa(e,t){I(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 ja(e){return e.drawTicks?e.tickLength:0}function Ma(e,t){if(!e.display)return 0;let n=q(e.font,t),r=K(e.padding);return(A(e.text)?e.text.length:1)*n.lineHeight+r.height}function Na(e,t){return Mn(e,{scale:t,type:`scale`})}function Pa(e,t,n){return Mn(e,{tick:n,index:t,type:`tick`})}function Fa(e,t,n){let r=Pt(e);return(n&&t!==`right`||!n&&t===`right`)&&(r=Ta(r)),r}function Ia(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),j(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:Ea(e,n,t);f=s-a}else{if(j(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:Ea(e,n,t);m=U(r,o,i),d=n===`left`?-z:z}return{titleX:p,titleY:m,maxWidth:f,rotation:d}}var La=class e extends _a{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=N(e,1/0),t=N(t,-1/0),n=N(n,1/0),r=N(r,-1/0),{min:N(e,n),max:N(t,r),minDefined:M(e),maxDefined:M(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:N(t,N(n,t)),max:N(n,N(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(){F(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=jn(this,i,r),!0),this.beforeBuildTicks(),this.ticks=this.buildTicks()||[],this.afterBuildTicks();let s=o<this.ticks.length;this._convertTicksToLabels(s?Oa(this.ticks,o):this.ticks),this.configure(),this.beforeCalculateLabelRotation(),this.calculateLabelRotation(),this.afterCalculateLabelRotation(),a.display&&(a.autoSkip||a.source===`auto`)&&(this.ticks=va(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(){F(this.options.afterUpdate,[this])}beforeSetDimensions(){F(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(){F(this.options.afterSetDimensions,[this])}_callHooks(e){this.chart.notifyPlugins(e,this.getContext()),F(this.options[e],[this])}beforeDataLimits(){this._callHooks(`beforeDataLimits`)}determineDataLimits(){}afterDataLimits(){this._callHooks(`afterDataLimits`)}beforeBuildTicks(){this._callHooks(`beforeBuildTicks`)}buildTicks(){return[]}afterBuildTicks(){this._callHooks(`afterBuildTicks`)}beforeTickToLabelConversion(){F(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=F(t.callback,[i.value,n,e],this)}afterTickToLabelConversion(){F(this.options.afterTickToLabelConversion,[this])}beforeCalculateLabelRotation(){F(this.options.beforeCalculateLabelRotation,[this])}calculateLabelRotation(){let e=this.options,t=e.ticks,n=Da(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-ja(e.grid)-t.padding-Ma(e.title,this.chart.options.font),c=Math.sqrt(u*u+d*d),a=ht(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(){F(this.options.afterCalculateLabelRotation,[this])}afterAutoSkip(){}beforeFit(){F(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=Ma(r,t.options.font);if(o?(e.width=this.maxWidth,e.height=ja(i)+a):(e.height=this.maxHeight,e.width=ja(i)+a),n.display&&this.ticks.length){let{first:t,last:r,widest:i,highest:a}=this._getLabelSizes(),s=n.padding*2,c=mt(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(){F(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++)k(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=Oa(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/Da(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,!k(p)&&!A(p))v=cn(r,g.data,g.gc,v,p),y=_;else if(A(p))for(d=0,f=p.length;d<f;++d)b=p[d],!k(b)&&!A(b)&&(v=cn(r,g.data,g.gc,v,b),y+=_);a.push(v),o.push(y),c=Math.max(v,c),l=Math.max(y,l)}Aa(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 xt(this._alignToPixels?un(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||=Pa(this.getContext(),e,n)}return this.$context||=Na(this.chart.getContext(),this)}_tickSize(){let e=this.options.ticks,t=mt(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=ja(i),d=[],f=o.setContext(this.getContext()),p=f.display?f.width:0,m=p/2,h=function(e){return un(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(j(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(j(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=P(r.ticks.maxTicksLimit,l),te=Math.max(1,Math.ceil(l/ee));for(_=0;_<l;_+=te){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=ka(this,_,s),v!==void 0&&(y=un(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=ja(n.grid),f=d+l,p=u?-l:f,m=-mt(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(j(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(j(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 te=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=A(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`?-te.highest.height/2-t*T+T:-te.highest.height+T/2:c===`near`||m!==0?T/2:c===`center`?te.highest.height/2-t*T:te.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=te.heights[g],r=te.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(-mt(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=un(e,this.left,a)-a/2,l=un(e,this.right,o)+o/2,u=d=s):(u=un(e,this.top,a)-a/2,d=un(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&&mn(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;xn(t,i,0,a,r,n)}n&&hn(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`||j(t)?(s+=a.bottom,A(n.text)&&(s+=i.lineHeight*(n.text.length-1))):s+=a.top;let{titleX:c,titleY:l,maxWidth:u,rotation:d}=Ia(this,s,t,o);xn(e,n.text,0,0,i,{color:n.color,maxWidth:u,rotation:d,textAlign:Fa(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=P(t.grid&&t.grid.z,-1),i=P(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}},Ra=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;Va(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,za(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 nn[n])}};function za(e,t,n){let r=Ue(Object.create(null),[n?W.get(n):{},W.get(t),e.defaults]);W.set(t,r),e.defaultRoutes&&Ba(t,e.defaultRoutes),e.descriptors&&W.describe(t,e.descriptors)}function Ba(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 Va(e){return`id`in e&&`defaults`in e}var Y=new class{constructor(){this.controllers=new Ra(vi,`datasets`,!0),this.elements=new Ra(_a,`elements`),this.plugins=new Ra(Object,`plugins`),this.scales=new Ra(La,`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):I(t,t=>{let r=n||this._getRegistryForType(t);this._exec(e,r,t)})})}_exec(e,t,n){let r=Xe(e);F(n[`before`+r],[],n),t[e](n),F(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}},Ha=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(F(a,[t,r,i.options],e)===!1&&r.cancelable)return!1}return!0}invalidate(){k(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=P(n.options&&n.options.plugins,{}),i=Ua(n);return r===!1&&!t?[]:Ga(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 Ua(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 Wa(e,t){return!t&&e===!1?null:e===!0?{}:e}function Ga(e,{plugins:t,localIds:n},r,i){let a=[],o=e.getContext();for(let s of t){let t=s.id,c=Wa(r[t],i);c!==null&&a.push({plugin:s,options:Ka(e.config,{plugin:s,local:n[t]},c,o)})}return a}function Ka(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 qa(e,t){let n=W.datasets[e]||{};return((t.datasets||{})[e]||{}).indexAxis||t.indexAxis||n.indexAxis||`x`}function Ja(e,t){let n=e;return e===`_index_`?n=t:e===`_value_`&&(n=t===`x`?`y`:`x`),n}function Ya(e,t){return e===t?`_index_`:`_value_`}function Xa(e){if(e===`x`||e===`y`||e===`r`)return e}function Za(e){if(e===`top`||e===`bottom`)return`x`;if(e===`left`||e===`right`)return`y`}function Qa(e,...t){if(Xa(e))return e;for(let n of t){let t=n.axis||Za(n.position)||e.length>1&&Xa(e[0].toLowerCase());if(t)return t}throw Error(`Cannot determine type of '${e}' axis. Please provide 'axis' or 'position' option.`)}function $a(e,t,n){if(n[t+`AxisID`]===e)return{axis:t}}function eo(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 $a(e,`x`,n[0])||$a(e,`y`,n[0])}return{}}function to(e,t){let n=nn[e.type]||{scales:{}},r=t.scales||{},i=qa(e.type,t),a=Object.create(null);return Object.keys(r).forEach(t=>{let o=r[t];if(!j(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=Qa(t,o,eo(t,e),W.scales[o.type]),c=Ya(s,i),l=n.scales||{};a[t]=We(Object.create(null),[{axis:s},o,l[s],l[c]])}),e.data.datasets.forEach(n=>{let i=n.type||e.type,o=n.indexAxis||qa(i,t),s=(nn[i]||{}).scales||{};Object.keys(s).forEach(e=>{let t=Ja(e,o),i=n[t+`AxisID`]||t;a[i]=a[i]||Object.create(null),We(a[i],[{axis:t},r[i],s[e]])})}),Object.keys(a).forEach(e=>{let t=a[e];We(t,[W.scales[t.type],W.scale])}),a}function no(e){let t=e.options||={};t.plugins=P(t.plugins,{}),t.scales=to(e,t)}function ro(e){return e||={},e.datasets=e.datasets||[],e.labels=e.labels||[],e}function io(e){return e||={},e.data=ro(e.data),no(e),e}var ao=new Map,oo=new Set;function so(e,t){let n=ao.get(e);return n||(n=t(),ao.set(e,n),oo.add(n)),n}var co=(e,t,n)=>{let r=Ye(t,n);r!==void 0&&e.add(r)},lo=class{constructor(e){this._config=io(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=ro(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(),no(e)}clearCache(){this._scopeCache.clear(),this._resolverCache.clear()}datasetScopeKeys(e){return so(e,()=>[[`datasets.${e}`,``]])}datasetAnimationScopeKeys(e,t){return so(`${e}.transition.${t}`,()=>[[`datasets.${e}.transitions.${t}`,`transitions.${t}`],[`datasets.${e}`,``]])}datasetElementScopeKeys(e,t){return so(`${e}-${t}`,()=>[[`datasets.${e}.elements.${t}`,`datasets.${e}`,`elements.${t}`,``]])}pluginScopeKeys(e){let t=e.id,n=this.type;return so(`${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=>co(s,e,t))),t.forEach(e=>co(s,r,e)),t.forEach(e=>co(s,nn[i]||{},e)),t.forEach(e=>co(s,W,e)),t.forEach(e=>co(s,rn,e))});let c=Array.from(s);return c.length===0&&c.push(Object.create(null)),oo.has(t)&&a.set(t,c),c}chartOptionScopes(){let{options:e,type:t}=this;return[e,nn[t]||{},W.datasets[t]||{},{type:t},W,rn]}resolveNamedOptions(e,t,n,r=[``]){let i={$shared:!0},{resolver:a,subPrefixes:o}=uo(this._resolverCache,e,r),s=a;if(po(a,t)){i.$shared=!1,n=Qe(n)?n():n;let t=this.createResolver(e,n,o);s=Pn(a,n,t)}for(let e of t)i[e]=s[e];return i}createResolver(e,t,n=[``],r){let{resolver:i}=uo(this._resolverCache,e,n);return j(t)?Pn(i,t,void 0,r):i}};function uo(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:Nn(t,n),subPrefixes:n.filter(e=>!e.toLowerCase().includes(`hover`))},r.set(i,a)),a}var fo=e=>j(e)&&Object.getOwnPropertyNames(e).some(t=>Qe(e[t]));function po(e,t){let{isScriptable:n,isIndexable:r}=Fn(e);for(let i of t){let t=n(i),a=r(i),o=(a||t)&&e[i];if(t&&(Qe(o)||fo(o))||a&&A(o))return!0}return!1}var mo=`4.5.1`,ho=[`top`,`bottom`,`left`,`right`,`chartArea`];function go(e,t){return e===`top`||e===`bottom`||ho.indexOf(e)===-1&&t===`x`}function _o(e,t){return function(n,r){return n[e]===r[e]?n[t]-r[t]:n[e]-r[e]}}function vo(e){let t=e.chart,n=t.options.animation;t.notifyPlugins(`afterRender`),F(n&&n.onComplete,[e],t)}function yo(e){let t=e.chart,n=t.options.animation;F(n&&n.onProgress,[e],t)}function bo(e){return cr()&&typeof e==`string`?e=document.getElementById(e):e&&e.length&&(e=e[0]),e&&e.canvas&&(e=e.canvas),e}var xo={},So=e=>{let t=bo(e);return Object.values(xo).filter(e=>e.canvas===t).pop()};function Co(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 wo(e,t,n,r){return!n||e.type===`mouseout`?null:r?t:e}var To=class{static defaults=W;static instances=xo;static overrides=nn;static registry=Y;static version=mo;static getChart=So;static register(...e){Y.add(...e),Eo()}static unregister(...e){Y.remove(...e),Eo()}constructor(e,t){let n=this.config=new lo(t),r=bo(e),i=So(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||(ga(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=Le(),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 Ha,this.$proxies={},this._hiddenIndices={},this.attached=!1,this._animationsDisabled=void 0,this.$context=void 0,this._doResize=Nt(e=>this.update(e),a.resizeDelay||0),this._dataChanges=[],xo[this.id]=this,!o||!s){console.error(`Failed to create chart: can't acquire context from the given item`);return}J.listen(this,`complete`,vo),J.listen(this,`progress`,yo),this._initialize(),this.attached&&this.update()}get aspectRatio(){let{options:{aspectRatio:e,maintainAspectRatio:t},width:n,height:r,_aspectRatio:i}=this;return k(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():xr(this,this.options.devicePixelRatio),this.bindEvents(),this.notifyPlugins(`afterInit`),this}clear(){return dn(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,xr(this,o,!0)&&(this.notifyPlugins(`resize`,{size:a}),F(n.onResize,[this,a],this),this.attached&&this._doResize(s)&&this.render())}ensureScalesHaveIDs(){I(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=Qa(e,n),i=r===`r`,a=r===`x`;return{options:n,dposition:i?`chartArea`:a?`bottom`:`left`,dtype:i?`radialLinear`:a?`category`:`linear`}}))),I(i,t=>{let i=t.options,a=i.id,o=Qa(a,i),s=P(i.type,t.dtype);(i.position===void 0||go(i.position,o)!==go(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)}),I(r,(e,t)=>{e||delete n[t]}),I(n,e=>{qi.configure(this,e,e.options),qi.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(_o(`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||qa(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(){I(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||I(i,e=>{e.reset()}),this._updateDatasets(e),this.notifyPlugins(`afterUpdate`,{mode:e}),this._layers.sort(_o(`z`,`_idx`));let{_active:o,_lastEvent:s}=this;s?this._eventHandler(s,!0):o.length&&this._updateHoverStyles(o,o,!0),this.render()}_updateScales(){I(this.scales,e=>{qi.removeBox(this,e)}),this.ensureScalesHaveIDs(),this.buildOrUpdateScales()}_checkEventBindings(){let e=this.options;(!$e(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)Co(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(!$e(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;qi.update(this,this.width,this.height,e);let t=this.chartArea,n=t.width<=0||t.height<=0;this._layers=[],I(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,Qe(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(),vo({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=Kr(this,e);this.notifyPlugins(`beforeDatasetDraw`,n)!==!1&&(r&&mn(t,r),e.controller.draw(),r&&hn(t),n.cancelable=!1,this.notifyPlugins(`afterDatasetDraw`,n))}isPointInArea(e){return G(e,this.chartArea,this._minPadding)}getElementsAtEventForMode(e,t,n,r){let i=Ai.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||=Mn(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);Ze(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(),dn(e,t),this.platform.releaseContext(t),this.canvas=null,this.ctx=null),delete xo[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)};I(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(){I(this._listeners,(e,t)=>{this.platform.removeEventListener(this,t,e)}),this._listeners={},I(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}});ze(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=et(e),c=wo(e,this._lastEvent,n,s);n&&(this._lastEvent=null,F(i.onHover,[e,o,this],this),s&&F(i.onClick,[e,o,this],this));let l=!ze(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 Eo(){return I(To.instances,e=>e._plugins.invalidate())}function Do(e,t,n=t){e.lineCap=P(n.borderCapStyle,t.borderCapStyle),e.setLineDash(P(n.borderDash,t.borderDash)),e.lineDashOffset=P(n.borderDashOffset,t.borderDashOffset),e.lineJoin=P(n.borderJoinStyle,t.borderJoinStyle),e.lineWidth=P(n.borderWidth,t.borderWidth),e.strokeStyle=P(n.borderColor,t.borderColor)}function Oo(e,t,n){e.lineTo(n.x,n.y)}function ko(e){return e.stepped?gn:e.tension||e.cubicInterpolationMode===`monotone`?_n:Oo}function Ao(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 jo(e,t,n,r){let{points:i,options:a}=t,{count:o,start:s,loop:c,ilen:l}=Ao(i,n,r),u=ko(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 Mo(e,t,n,r){let i=t.points,{count:a,start:o,ilen:s}=Ao(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 No(e){let t=e.options,n=t.borderDash&&t.borderDash.length;return!e._decimated&&!e._loop&&!t.tension&&t.cubicInterpolationMode!==`monotone`&&!t.stepped&&!n?Mo:jo}function Po(e){return e.stepped?Tr:e.tension||e.cubicInterpolationMode===`monotone`?Er:wr}function Fo(e,t,n,r){let i=t._path;i||(i=t._path=new Path2D,t.path(i,n,r)&&i.closePath()),Do(e,t.options),e.stroke(i)}function Io(e,t,n,r){let{segments:i,options:a}=t,o=No(t);for(let s of i)Do(e,a,s.style),e.beginPath(),o(e,t,s,{start:n,end:n+r-1})&&e.closePath(),e.stroke()}var Lo=typeof Path2D==`function`;function Ro(e,t,n,r){Lo&&!t.options.segment?Fo(e,t,n,r):Io(e,t,n,r)}var zo=class extends _a{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;sr(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||=zr(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=Ir(this,{property:t,start:r,end:r});if(!a.length)return;let o=[],s=Po(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 No(this)(e,this,t,n)}path(e,t,n){let r=this.segments,i=No(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(),Ro(e,this,n,r),e.restore()),this.animated&&(this._pointsUpdated=!1,this._path=void 0)}};function Bo(e,t,n,r){let i=e.options,{[n]:a}=e.getProps([n],r);return Math.abs(t-a)<i.radius+i.hitRadius}var Vo=class extends _a{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 Bo(this,e,`x`,t)}inYRange(e,t){return Bo(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,fn(e,n,this.x,this.y))}getRange(){let e=this.options||{};return e.radius+e.hitRadius}};function Ho(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=Go(r,s,i);let c=Uo(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=Ir(t,c);for(let t of l){let r=Uo(n,a[t.start],a[t.end],t.loop),s=Fr(e,i,r);for(let e of s)o.push({source:e,target:t,start:{[n]:Ko(c,r,`start`,Math.max)},end:{[n]:Ko(c,r,`end`,Math.min)}})}}return o}function Uo(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 Wo(e,t){let{x:n=null,y:r=null}=e||{},i=t.points,a=[];return t.segments.forEach(({start:e,end:t})=>{t=Go(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 Go(e,t,n){for(;t>e;t--){let e=n[t];if(!isNaN(e.x)&&!isNaN(e.y))break}return t}function Ko(e,t,n,r){return e&&t?r(e[n],t[n]):e?e[n]:t?t[n]:0}function qo(e,t){let n=[],r=!1;return A(e)?(r=!0,n=e):n=Wo(e,t),n.length?new zo({points:n,options:{tension:0},_loop:r,_fullLoop:r}):null}function Jo(e){return e&&e.fill!==!1}function Yo(e,t,n){let r=e[t].fill,i=[t],a;if(!n)return r;for(;r!==!1&&i.indexOf(r)===-1;){if(!M(r))return r;if(a=e[r],!a)return!1;if(a.visible)return r;i.push(r),r=a.fill}return!1}function Xo(e,t,n){let r=es(e);if(j(r))return!isNaN(r.value)&&r;let i=parseFloat(r);return M(i)&&Math.floor(i)===i?Zo(r[0],t,i,n):[`origin`,`start`,`end`,`stack`,`shape`].indexOf(r)>=0&&r}function Zo(e,t,n,r){return(e===`-`||e===`+`)&&(n=t+n),n===t||n<0||n>=r?!1:n}function Qo(e,t){let n=null;return e===`start`?n=t.bottom:e===`end`?n=t.top:j(e)?n=t.getPixelForValue(e.value):t.getBasePixel&&(n=t.getBasePixel()),n}function $o(e,t,n){let r;return r=e===`start`?n:e===`end`?t.options.reverse?t.min:t.max:j(e)?e.value:t.getBaseValue(),r}function es(e){let t=e.options,n=t.fill,r=P(n&&n.target,n);return r===void 0&&(r=!!t.backgroundColor),r===!1||r===null?!1:r===!0?`origin`:r}function ts(e){let{scale:t,index:n,line:r}=e,i=[],a=r.segments,o=r.points,s=ns(t,n);s.push(qo({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++)rs(i,o[e],s)}return new zo({points:i,options:{}})}function ns(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 rs(e,t,n){let r=[];for(let i=0;i<n.length;i++){let a=n[i],{first:o,last:s,point:c}=is(a,t,`x`);if(!(!c||o&&s)){if(o)r.unshift(c);else if(e.push(c),!s)break}}e.push(...r)}function is(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(St(i,r,l)){s=i===r,c=i===l;break}}return{first:s,last:c,point:r}}var as=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:R},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 os(e){let{chart:t,fill:n,line:r}=e;if(M(n))return ss(t,n);if(n===`stack`)return ts(e);if(n===`shape`)return!0;let i=cs(e);return i instanceof as?i:qo(i,r)}function ss(e,t){let n=e.getDatasetMeta(t);return n&&e.isDatasetVisible(t)?n.dataset:null}function cs(e){return(e.scale||{}).getPointPositionForValue?us(e):ls(e)}function ls(e){let{scale:t={},fill:n}=e,r=Qo(n,t);if(M(r)){let e=t.isHorizontal();return{x:e?r:null,y:e?null:r}}return null}function us(e){let{scale:t,fill:n}=e,r=t.options,i=t.getLabels().length,a=r.reverse?t.max:t.min,o=$o(n,t,a),s=[];if(r.grid.circular){let e=t.getPointPositionForValue(0,a);return new as({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 ds(e,t,n){let r=os(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=Kr(i,i.getDatasetMeta(a));r&&o.points.length&&(mn(e,n),fs(e,{line:o,target:r,above:f,below:p,area:n,scale:s,axis:c,clip:m}),hn(e))}function fs(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`?(ps(e,r,o.top),hs(e,{line:n,target:r,color:i,scale:s,property:l,clip:c}),e.restore(),e.save(),ps(e,r,o.bottom)):l===`y`&&(ms(e,r,o.left),hs(e,{line:n,target:r,color:a,scale:s,property:l,clip:c}),e.restore(),e.save(),ms(e,r,o.right),u=i)),hs(e,{line:n,target:r,color:u,scale:s,property:l,clip:c}),e.restore()}function ps(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[Go(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 ms(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[Go(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 hs(e,t){let{line:n,target:r,property:i,color:a,scale:o,clip:s}=t,c=Ho(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,gs(e,o,s,f&&Uo(i,u,d)),e.beginPath();let p=!!n.pathSegment(e,t),m;if(f){p?e.closePath():_s(e,r,d,i);let t=!!r.pathSegment(e,l,{move:p,reverse:!0});m=p&&t,m||_s(e,r,u,i)}e.closePath(),e.fill(m?`evenodd`:`nonzero`),e.restore()}}function gs(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 _s(e,t,n,r){let i=t.interpolate(n,r);i&&e.lineTo(i.x,i.y)}var vs={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 zo&&(c={visible:e.isDatasetVisible(o),index:o,fill:Xo(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=Yo(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&&ds(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;Jo(n)&&ds(e.ctx,n,e.chartArea)}},beforeDatasetDraw(e,t,n){let r=t.meta.$filler;!Jo(r)||n.drawTime!==`beforeDatasetDraw`||ds(e.ctx,r,e.chartArea)},defaults:{propagate:!0,drawTime:`beforeDatasetDraw`}},ys=(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)}},bs=(e,t)=>e!==null&&t!==null&&e.datasetIndex===t.datasetIndex&&e.index===t.index,xs=class extends _a{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=F(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}=ys(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}=Ss(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=kr(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;mn(e,this),this._draw(),hn(e)}}_draw(){let{options:e,columnSizes:t,lineWidths:n,ctx:r}=this,{align:i,labels:a}=e,o=W.color,s=kr(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}=ys(a,u),g=function(e,t,n){if(isNaN(p)||p<=0||isNaN(m)||m<0)return;r.save();let i=P(n.lineWidth,1);if(r.fillStyle=P(n.fillStyle,o),r.lineCap=P(n.lineCap,`butt`),r.lineDashOffset=P(n.lineDashOffset,0),r.lineJoin=P(n.lineJoin,`miter`),r.lineWidth=i,r.strokeStyle=P(n.strokeStyle,o),r.setLineDash(P(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;pn(r,o,c,l,a.pointStyleWidth&&p)}else{let a=t+Math.max((u-m)/2,0),o=s.leftForLtr(e,p),c=kn(n.borderRadius);r.beginPath(),Object.values(c).some(e=>e!==0)?Sn(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){xn(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},Ar(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=Ft(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+=Ts(o,e)+l}else f.y+=b}),jr(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=kr(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(Pt(o)),a.textBaseline=`middle`,a.strokeStyle=t.color,a.fillStyle=t.color,a.font=n.string,xn(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(St(e,this.left,this.right)&&St(t,this.top,this.bottom)){for(i=this.legendHitBoxes,n=0;n<i.length;++n)if(r=i[n],St(e,r.left,r.left+r.width)&&St(t,r.top,r.top+r.height))return this.legendItems[n]}return null}handleEvent(e){let t=this.options;if(!Es(e.type,t))return;let n=this._getLegendItemAt(e.x,e.y);if(e.type===`mousemove`||e.type===`mouseout`){let r=this._hoveredItem,i=bs(r,n);r&&!i&&F(t.onLeave,[e,r,this],this),this._hoveredItem=n,n&&!i&&F(t.onHover,[e,n,this],this)}else n&&F(t.onClick,[e,n,this],this)}};function Ss(e,t,n,r,i){return{itemWidth:Cs(r,e,t,n),itemHeight:ws(i,r,t.lineHeight)}}function Cs(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 ws(e,t,n){let r=e;return typeof t.text!=`string`&&(r=Ts(t,n)),r}function Ts(e,t){return t*(e.text?e.text.length:0)}function Es(e,t){return!!((e===`mousemove`||e===`mouseout`)&&(t.onHover||t.onLeave)||t.onClick&&(e===`click`||e===`mouseup`))}var Ds={id:`legend`,_element:xs,start(e,t,n){let r=e.legend=new xs({ctx:e.ctx,options:n,chart:e});qi.configure(e,r,n),qi.addBox(e,r)},stop(e){qi.removeBox(e,e.legend),delete e.legend},beforeUpdate(e,t,n){let r=e.legend;qi.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)}}},Os={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=vt(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&&(A(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 ks(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 As(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,I(e.title,y),n.font=c.string,I(e.beforeBody.concat(e.afterBody),y),v=t.displayColors?o+2+t.boxPadding:0,I(r,e=>{I(e.before,y),I(e.lines,y),I(e.after,y)}),v=0,n.font=u.string,I(e.footer,y),n.restore(),g+=m.width,{width:g,height:h}}function js(e,t){let{y:n,height:r}=t;return n<r/2?`top`:n>e.height-r/2?`bottom`:`center`}function Ms(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 Ns(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`),Ms(l,e,t,n)&&(l=`center`),l}function Ps(e,t,n){let r=n.yAlign||t.yAlign||js(e,n);return{xAlign:n.xAlign||t.xAlign||Ns(e,t,n,r),yAlign:r}}function Fs(e,t){let{x:n,width:r}=e;return t===`right`?n-=r:t===`center`&&(n-=r/2),n}function Is(e,t,n){let{y:r,height:i}=e;return t===`top`?r+=n:r-=t===`bottom`?i+n:i/2,r}function Ls(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}=kn(o),m=Fs(t,s),h=Is(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 Rs(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 zs(e){return X([],Z(e))}function Bs(e,t,n){return Mn(e,{tooltip:t,tooltipItems:n,type:`tooltip`})}function Vs(e,t){let n=t&&t.dataset&&t.dataset.tooltip&&t.dataset.tooltip.callbacks;return n?e.override(n):e}var Hs={beforeTitle:O,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:O,beforeBody:O,beforeLabel:O,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 k(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:O,afterBody:O,beforeFooter:O,footer:O,afterFooter:O};function Q(e,t,n,r){let i=e[t].call(n,r);return i===void 0?Hs[t].call(n,r):i}var Us=class extends _a{static positioners=Os;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 Xr(this.chart,r);return r._cacheable&&(this._cachedAnimations=Object.freeze(i)),i}getContext(){return this.$context||=Bs(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 zs(Q(t.callbacks,`beforeBody`,this,e))}getBody(e,t){let{callbacks:n}=t,r=[];return I(e,e=>{let t={before:[],lines:[],after:[]},i=Vs(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 zs(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(ks(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))),I(o,t=>{let n=Vs(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=Os[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=As(this,n),o=Object.assign({},e,t),s=Ps(this.chart,n,o),c=Ls(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}=kn(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=kr(n.rtl,this.x,this.width);for(e.x=Rs(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=Rs(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,fn(e,t,n,l),e.strokeStyle=a.borderColor,e.fillStyle=a.backgroundColor,fn(e,t,n,l)}else{e.lineWidth=j(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=kn(a.borderRadius);Object.values(o).some(e=>e!==0)?(e.beginPath(),e.fillStyle=i.multiKeyBackground,Sn(e,{x:t,y:p,w:c,h:s,radius:o}),e.fill(),e.stroke(),e.fillStyle=a.backgroundColor,e.beginPath(),Sn(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=kr(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=Rs(this,h,n),t.fillStyle=n.bodyColor,I(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=_,I(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;I(g.after,m)}f=0,d=u.lineHeight,I(this.afterBody,m),e.y-=i}drawFooter(e,t,n){let r=this.footer,i=r.length,a,o;if(i){let s=kr(n.rtl,this.x,this.width);for(e.x=Rs(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}=kn(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=Os[e.position].call(this,this._active,this._eventPosition);if(!n)return;let a=this._size=As(this,e),o=Object.assign({},n,this._size),s=Ps(t,e,o),c=Ls(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),Ar(e,t.textDirection),i.y+=a.top,this.drawTitle(i,e,t),this.drawBody(i,e,t),this.drawFooter(i,e,t),jr(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=!ze(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||!ze(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=Os[i.position].call(this,e,t);return a!==!1&&(n!==a.x||r!==a.y)}},Ws={id:`tooltip`,_element:Us,positioners:Os,afterInit(e,t,n){n&&(e.tooltip=new Us({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:Hs},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`]},Gs=(e,t,n,r)=>(typeof t==`string`?(n=e.push(t)-1,r.unshift({index:n,label:t})):isNaN(t)&&(n=null),n);function Ks(e,t,n,r){let i=e.indexOf(t);return i===-1?Gs(e,t,n,r):i===e.lastIndexOf(t)?i:n}var qs=(e,t)=>e===null?null:H(Math.round(e),0,t);function Js(e){let t=this.getLabels();return e>=0&&e<t.length?t[e]:e}var Ys=class extends La{static id=`category`;static defaults={ticks:{callback:Js}};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(k(e))return null;let n=this.getLabels();return t=isFinite(t)&&n[t]===e?t:Ks(n,e,P(t,e),this._addedLabels),qs(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 Js.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 Xs(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=!k(a),_=!k(o),v=!k(c),y=(h-m)/(u+1),b=ct((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=ct(w*b/p/f)*f),k(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&&ft((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=st(w,Math.round(w),b/1e3)?Math.round(w):Math.ceil(w));let T=Math.max(gt(b),gt(S));x=10**(k(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++,st(Math.round((S+E*b)*x)/x,a,Zs(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&&st(n[n.length-1].value,o,Zs(o,y,e))?n[n.length-1].value=o:n.push({value:o}):(!_||C===o)&&n.push({value:C}),n}function Zs(e,t,{horizontal:n,minRotation:r}){let i=mt(r),a=(n?Math.sin(i):Math.cos(i))||.001,o=.75*t*(``+e).length;return Math.min(t/a,o)}var Qs=class extends La{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 k(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=ot(r),t=ot(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=Xs({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`&&pt(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 Zt(e,this.chart.options.locale,this.options.ticks.format)}},$s=class extends Qs{static id=`linear`;static defaults={ticks:{callback:en.formatters.numeric}};determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=M(e)?e:0,this.max=M(t)?t:1,this.handleTickRangeOptions()}computeTickLimit(){let e=this.isHorizontal(),t=e?this.width:this.height,n=mt(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}},ec=e=>Math.floor(B(e)),tc=(e,t)=>10**(ec(e)+t);function nc(e){return e/10**ec(e)==1}function rc(e,t,n){let r=10**n,i=Math.floor(e/r);return Math.ceil(t/r)-i}function ic(e,t){let n=ec(t-e);for(;rc(e,t,n)>10;)n++;for(;rc(e,t,n)<10;)n--;return Math.min(n,ec(e))}function ac(e,{min:t,max:n}){t=N(e.min,t);let r=[],i=ec(t),a=ic(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=N(e.min,Math.round((c+u+d*10**a)*o)/o);for(;f<n;)r.push({value:f,major:nc(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=N(e.max,f);return r.push({value:p,major:nc(p),significand:d}),r}(class extends La{static id=`logarithmic`;static defaults={ticks:{callback:en.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=Qs.prototype.parse.apply(this,[e,t]);if(n===0){this._zero=!0;return}return M(n)&&n>0?n:null}determineDataLimits(){let{min:e,max:t}=this.getMinMax(!0);this.min=M(e)?Math.max(0,e):null,this.max=M(t)?Math.max(0,t):null,this.options.beginAtZero&&(this._zero=!0),this._zero&&this.min!==this._suggestedMin&&!M(this._userMin)&&(this.min=e===tc(this.min,0)?tc(this.min,-1):tc(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(tc(n,-1)),a(tc(r,1)))),n<=0&&i(tc(r,-1)),r<=0&&a(tc(n,1)),this.min=n,this.max=r}buildTicks(){let e=this.options,t=ac({min:this._userMin,max:this._userMax},this);return e.bounds===`ticks`&&pt(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`:Zt(e,this.chart.options.locale,this.options.ticks.format)}configure(){let e=this.min;super.configure(),this._startValue=B(e),this._valueRange=B(this.max)-B(e)}getPixelForValue(e){return(e===void 0||e===0)&&(e=this.min),e===null||isNaN(e)?NaN:this.getPixelForDecimal(e===this.min?0:(B(e)-this._startValue)/this._valueRange)}getValueForPixel(e){let t=this.getDecimalForPixel(e);return 10**(this._startValue+t*this._valueRange)}});function oc(e){let t=e.ticks;if(t.display&&e.display){let e=K(t.backdropPadding);return P(t.font&&t.font.size,W.font.size)+e.height}return 0}function sc(e,t,n){return n=A(n)?n:[n],{w:ln(e,t.string,n),h:n.length*t.lineHeight}}function cc(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 lc(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?L/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=sc(e.ctx,u,e._pointLabels[c]);r[c]=d;let f=V(e.getIndexAngle(c)+s),p=Math.round(ht(f));uc(n,t,f,cc(p,l.x,d.w,0,180),cc(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=pc(e,r,i)}function uc(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 dc(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(ht(V(c.angle+z))),u=gc(c.y,s.h,l),d=mc(l),f=hc(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 fc(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 pc(e,t,n){let r=[],i=e._pointLabels.length,a=e.options,{centerPointLabels:o,display:s}=a.pointLabels,c={extra:oc(a)/2,additionalAngle:o?L/i:0},l;for(let a=0;a<i;a++){c.padding=n[a],c.size=t[a];let i=dc(e,a,c);r.push(i),s===`auto`&&(i.visible=fc(i,l),i.visible&&(l=i))}return r}function mc(e){return e===0||e===180?`center`:e<180?`left`:`right`}function hc(e,t,n){return n===`right`?e-=t:n===`center`&&(e-=t/2),e}function gc(e,t,n){return n===90||n===270?e-=t/2:(n>270||n<90)&&(e-=t),e}function _c(e,t,n){let{left:r,top:i,right:a,bottom:o}=n,{backdropColor:s}=t;if(!k(s)){let n=kn(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(),Sn(e,{x:l,y:u,w:d,h:f,radius:n}),e.fill()):e.fillRect(l,u,d,f)}}function vc(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));_c(n,a,t);let o=q(a.font),{x:s,y:c,textAlign:l}=t;xn(n,e._pointLabels[i],s,c+o.lineHeight/2,o,{color:a.color,textAlign:l,textBaseline:`middle`})}}function yc(e,t,n,r){let{ctx:i}=e;if(n)i.arc(e.xCenter,e.yCenter,t,0,R);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 bc(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(),yc(e,n,o,r),a.closePath(),a.stroke(),a.restore())}function xc(e,t,n){return Mn(e,{label:n,index:t,type:`pointLabel`})}(class extends Qs{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:en.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(oc(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=M(e)&&!isNaN(e)?e:0,this.max=M(t)&&!isNaN(t)?t:0,this.handleTickRangeOptions()}computeTickLimit(){return Math.ceil(this.drawingArea/oc(this.options))}generateTickLabels(e){Qs.prototype.generateTickLabels.call(this,e),this._pointLabels=this.getLabels().map((e,t)=>{let n=F(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?lc(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=R/(this._pointLabels.length||1),n=this.options.startAngle||0;return V(e*t+mt(n))}getDistanceFromCenterForValue(e){if(k(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(k(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 xc(this.getContext(),e,n)}}getPointPosition(e,t,n=0){let r=this.getIndexAngle(e)-z+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(),yc(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&&vc(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);bc(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)}xn(e,r.label,0,-i,c,{color:s.color,strokeColor:s.textStrokeColor,strokeWidth:s.textStrokeWidth})}),e.restore()}drawTitle(){}});var Sc={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(Sc);function Cc(e,t){return e-t}function wc(e,t){if(k(t))return null;let n=e._adapter,{parser:r,round:i,isoWeekday:a}=e._parseOpts,o=t;return typeof r==`function`&&(o=r(o)),M(o)||(o=typeof r==`string`?n.parse(o,r):n.parse(o)),o===null?null:(i&&(o=i===`week`&&(dt(a)||a===!0)?n.startOf(o,`isoWeek`,a):n.startOf(o,i)),+o)}function Tc(e,t,n,r){let i=$.length;for(let a=$.indexOf(e);a<i-1;++a){let e=Sc[$[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 Ec(e,t,n,r,i){for(let a=$.length-1;a>=$.indexOf(n);a--){let n=$[a];if(Sc[n].common&&e._adapter.diff(i,r,n)>=t-1)return n}return $[n?$.indexOf(n):0]}function Dc(e){for(let t=$.indexOf(e)+1,n=$.length;t<n;++t)if(Sc[$[t]].common)return $[t]}function Oc(e,t,n){if(!n)e[t]=!0;else if(n.length){let{lo:r,hi:i}=Ct(n,t),a=n[r]>=t?n[r]:n[i];e[a]=!0}}function kc(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 Ac(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:kc(e,r,i,n)}var jc=class extends La{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 xi._date(e.adapters.date);r.init(t),We(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:wc(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=M(r)&&!isNaN(r)?r:+t.startOf(Date.now(),n),i=M(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=Et(r,i,a);return this._unit=t.unit||(n.autoSkip?Tc(t.minUnit,this.min,this.max,this._getLabelCapacity(i)):Ec(this,o.length,t.minUnit,this.min,this.max)),this._majorUnit=!n.major.enabled||this._unit===`year`?void 0:Dc(this._unit),this.initOffsets(r),e.reverse&&o.reverse(),Ac(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||Tc(i.minUnit,t,n,this._getLabelCapacity(t)),o=P(r.ticks.stepSize,1),s=a===`week`&&i.isoWeekday,c=dt(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++)Oc(l,d,p);return(d===n||r.bounds===`ticks`||f===1)&&Oc(l,d,p),Object.keys(l).sort(Cc).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 F(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=mt(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,Ac(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(wc(this,r[t]));return this._cache.labels=this._normalized?e:this.normalize(e)}normalize(e){return At(e.sort(Cc))}};function Mc(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}=wt(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}=wt(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 jc{static id=`timeseries`;static defaults=jc.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=Mc(t,this.min),this._tableRange=Mc(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(Mc(this._table,e)-this._minPos)/this._tableRange}getValueForPixel(e){let t=this._offsets,n=this.getDecimalForPixel(e)/t.factor-t.end;return Mc(this._table,n*this._tableRange+this._minPos,!0)}});var Nc={data:{type:Object,required:!0},options:{type:Object,default:()=>({})},plugins:{type:Array,default:()=>[]},datasetIdKey:{type:String,default:`label`},updateMode:{type:String,default:void 0}},Pc={ariaLabel:{type:String},ariaDescribedby:{type:String}},Fc={type:{type:String,required:!0},destroyDelay:{type:Number,default:0},...Nc,...Pc},Ic=(e,t)=>Object.assign(e,t);function Lc(e){return d(e)?i(e):e}function Rc(e){let t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:e;return d(t)?new Proxy(e,{}):e}function zc(e,t){let n=e.options;n&&t&&Object.assign(n,t)}function Bc(e,t){e.labels=t}function Vc(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 Hc(e,t){let n={labels:[],datasets:[]};return Bc(n,e.labels),Vc(n,e.datasets,t),n}var Uc=v({props:Fc,setup(e,t){let{expose:n,slots:r}=t,s=a(null),l=m(null);n({chart:l});let d=()=>{if(!s.value)return;let{type:t,data:n,options:r,plugins:i,datasetIdKey:a}=e,o=Rc(Hc(n,a),n);l.value=new To(s.value,{type:t,data:o,options:{...r},plugins:i})},f=()=>{let t=i(l.value);t&&(e.destroyDelay>0?setTimeout(()=>{t.destroy(),l.value=null},e.destroyDelay):(t.destroy(),l.value=null))},h=t=>{t.update(e.updateMode)};return g(d),c(f),o([()=>e.options,()=>e.data],(t,n)=>{let[r,a]=t,[o,s]=n,c=i(l.value);if(!c)return;let u=!1;if(r){let e=Lc(r),t=Lc(o);e&&e!==t&&(zc(c,e),u=!0)}if(a){let t=Lc(a.labels),n=Lc(s.labels),r=Lc(a.datasets),i=Lc(s.datasets);t!==n&&(Bc(c.config.data,t),u=!0),r&&r!==i&&(Vc(c.config.data,r,e.datasetIdKey),u=!0)}u&&p(()=>{h(c)})},{deep:!0}),()=>u(`canvas`,{role:`img`,"aria-label":e.ariaLabel,"aria-describedby":e.ariaDescribedby,ref:s},[u(`p`,{},[r.default?r.default():``])])}});function Wc(e,t){return To.register(t),v({props:Nc,setup(t,n){let{expose:r}=n,i=m(null),a=m(null);o(()=>a.value?.chart??null,e=>{i.value=e},{flush:`sync`}),r({chart:i});let s=e=>{a.value=e};return()=>u(Uc,Ic({ref:s},{type:e,...t}))}})}var Gc=Wc(`line`,yi);To.register(Ys,$s,Ds,Ws,yi,zo,Vo,vs);function Kc(){let e=a(``),t=a(``),n=a(``);function r(){let r=getComputedStyle(document.documentElement);e.value=r.getPropertyValue(`--foreground`).trim(),t.value=r.getPropertyValue(`--muted-foreground`).trim(),n.value=r.getPropertyValue(`--border`).trim()}let i;return g(()=>{r(),i=window.matchMedia(`(prefers-color-scheme: dark)`),i.addEventListener(`change`,r)}),h(()=>{i?.removeEventListener(`change`,r)}),{foreground:e,mutedForeground:t,border:n}}var qc=[`aria-label`],Jc=v({__name:`TimeSeriesChart`,props:{labels:{},datasets:{},comparisonDatasets:{default:()=>[]},stacked:{type:Boolean,default:!1},valueFormatter:{type:Function,default:y},ariaLabel:{}},setup(i){let a=i,o=`timeseries-chart-desc-${l()}`,c=n(()=>a.datasets.length===0||a.labels.length===0?`No data for this range.`:a.datasets.map(e=>{let t=e.data.length>0?e.data[e.data.length-1]:0,n=e.data.reduce((e,t)=>e+t,0);return`${e.label}: latest ${a.valueFormatter(t)}, total ${a.valueFormatter(n)} over ${a.labels.length} buckets.`}).join(` `)),{foreground:u,mutedForeground:d,border:p}=Kc();function m(e){return getComputedStyle(document.documentElement).getPropertyValue(e).trim()}let h=n(()=>{u.value;let e=a.datasets.map(e=>{let t=m(e.color);return{label:e.label,data:e.data,borderColor:t,backgroundColor:t,fill:a.stacked,stack:a.stacked?`main`:void 0,tension:.2,pointRadius:2,borderWidth:2}}),t=a.comparisonDatasets.map(e=>{let t=m(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:a.labels,datasets:[...e,...t]}}),g=n(()=>({responsive:!0,maintainAspectRatio:!1,animation:!1,interaction:{mode:`index`,intersect:!1},scales:{x:{stacked:a.stacked,grid:{color:p.value,display:!1},ticks:{color:d.value}},y:{stacked:a.stacked,beginAtZero:!0,grid:{color:p.value},ticks:{color:d.value,callback:e=>a.valueFormatter(Number(e))}}},plugins:{legend:{display:a.datasets.length>1||a.comparisonDatasets.length>0,labels:{color:u.value}},tooltip:{callbacks:{label:e=>`${e.dataset.label}: ${a.valueFormatter(e.parsed.y??0)}`}}}}));return(n,a)=>(_(),e(`div`,{class:`h-72 w-full`,role:`img`,"aria-label":i.ariaLabel,"aria-describedby":o},[r(s(Gc),{data:h.value,options:g.value},null,8,[`data`,`options`]),t(`p`,{id:o,class:`sr-only`},f(c.value),1)],8,qc))}});export{Jc as t};",
+		),
+	},
+	"badge-ns0j8OUr.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"aW1wb3J0e0IgYXMgZSxOIGFzIHQsT3QgYXMgbixSciBhcyByLGpuIGFzIGkscnIgYXMgYSx1biBhcyBvLHcgYXMgcyx3biBhcyBjLHogYXMgbCx6dCBhcyB1fWZyb20iLi9uYXYtRHpiME9UTl8uanMiO2Z1bmN0aW9uIGQoZSx0KXtyZXR1cm5gJHtlfS8ke3R9YH1mdW5jdGlvbiBmKGUpe3JldHVybmAkJHsoZS8xZTYpLnRvRml4ZWQoNCl9YH1mdW5jdGlvbiBwKGUpe3JldHVybiBlLnRvTG9jYWxlU3RyaW5nKGBlbi1VU2ApfWZ1bmN0aW9uIG0oZSl7bGV0IHQ9TWF0aC5hYnMoZSk7aWYodDwxZTQpcmV0dXJuIHAoZSk7bGV0IG49ZTwwP2AtYDpgYCxbcixpXT10PDFlNj9bMWUzLGBrYF06dDwxZTk/WzFlNixgTWBdOlsxZTksYEJgXSxhPXQvcixvPTMtKE1hdGguZmxvb3IoYSk+PTEwMD8zOk1hdGguZmxvb3IoYSk+PTEwPzI6MSkscz0xMCoqbyxjPShNYXRoLmZsb29yKHQqcy9yKS9zKS50b0ZpeGVkKG8pO3JldHVybiBvPjAmJihjPWMucmVwbGFjZSgvMCskLyxgYCkucmVwbGFjZSgvXC4kLyxgYCkpLGAke259JHtjfSR7aX1gfWZ1bmN0aW9uIGgoZSl7cmV0dXJuIGU+MCYmIShlJmUtMSl9ZnVuY3Rpb24gZyhlKXtyZXR1cm4gZTwxMDI0P2Ake2V9YDpoKGUpP2U8MTA0ODU3Nj9gJHtNYXRoLnJvdW5kKGUvMTAyNCl9a2A6YCR7TWF0aC5yb3VuZChlLzEwNDg1NzYpfU1gOmU8MWU2P2Ake01hdGgucm91bmQoZS8xZTMpfWtgOmAke01hdGgucm91bmQoZS8xZTYpfU1gfWZ1bmN0aW9uIF8oZSl7cmV0dXJuYCQke2UudG9GaXhlZCgyKX1gfWZ1bmN0aW9uIHYoZSx0KXtyZXR1cm4gZT09PTAmJnQ9PT0wP2BmcmVlYDpgaW4gJHtfKGUpfSAvIG91dCAke18odCl9IHBlciBNVG9rYH1mdW5jdGlvbiB5KGUpe3JldHVybiBlPDFlMz9gJHtNYXRoLnJvdW5kKGUpfW1zYDpgJHsoZS8xZTMpLnRvRml4ZWQoMSl9c2B9ZnVuY3Rpb24gYihlLHQpe2lmKCFlfHxlPT09YDAwMDEtMDEtMDFUMDA6MDA6MDBaYClyZXR1cm4gbnVsbDtsZXQgbj1uZXcgRGF0ZShlKS5nZXRUaW1lKCk7cmV0dXJuIE51bWJlci5pc05hTihuKT9udWxsOk1hdGgubWF4KDAsTWF0aC5yb3VuZCgodC1uKS8xZTMpKX1mdW5jdGlvbiB4KGUpe2xldCB0PWIoZSxEYXRlLm5vdygpKTtyZXR1cm4gdD09PW51bGw/YGA6YCAoJHt0fXMgYWdvKWB9ZnVuY3Rpb24gUyhlLHQ9RGF0ZS5ub3coKSl7bGV0IG49YihlLHQpO3JldHVybiBuPT09bnVsbD9gYDpgJHtufXMgYWdvYH1mdW5jdGlvbiBDKGUpe2lmKCFlfHxlPT09YDAwMDEtMDEtMDFUMDA6MDA6MDBaYClyZXR1cm5gYDtsZXQgdD1uZXcgRGF0ZShlKS5nZXRUaW1lKCk7aWYoTnVtYmVyLmlzTmFOKHQpKXJldHVybmBgO2xldCBuPU1hdGgucm91bmQoKHQtRGF0ZS5ub3coKSkvMWUzKTtyZXR1cm4gbjw9MD9gYDpgaW4gJHtufXNgfWZ1bmN0aW9uIHcoZSl7aWYoIWV8fGU9PT1gMDAwMS0wMS0wMVQwMDowMDowMFpgKXJldHVybmBuZXZlcmA7bGV0IHQ9bmV3IERhdGUoZSk7cmV0dXJuIE51bWJlci5pc05hTih0LmdldFRpbWUoKSk/ZTp0LnRvTG9jYWxlU3RyaW5nKCl9ZnVuY3Rpb24gVChlLHQpe3JldHVybiBlP3godCk/YHJlZnJlc2hlZGA6YHBlbmRpbmdgOmBvZmZgfWZ1bmN0aW9uIEUoZSx0KXtzd2l0Y2goVChlLHQpKXtjYXNlYG9mZmA6cmV0dXJuYGRpc2NvdmVyeSBvZmZgO2Nhc2VgcGVuZGluZ2A6cmV0dXJuYHBlbmRpbmdgO2Nhc2VgcmVmcmVzaGVkYDpyZXR1cm5gcmVmcmVzaGVkJHt4KHQpfWB9fWZ1bmN0aW9uIEQoZSx0KXtzd2l0Y2goVChlLHQpKXtjYXNlYG9mZmA6cmV0dXJuYGRpc2NvdmVyeSBvZmZgO2Nhc2VgcGVuZGluZ2A6cmV0dXJuYHBlbmRpbmdgO2Nhc2VgcmVmcmVzaGVkYDpyZXR1cm4gdyh0KX19ZnVuY3Rpb24gTyhlKXtpZighZSlyZXR1cm5gbm9uZWA7bGV0IHQ9W107cmV0dXJuIGUucmVxdWVzdHNQZXJNaW51dGUmJnQucHVzaChgcmVxL21pbiAke2UucmVxdWVzdHNQZXJNaW51dGV9YCksZS5yZXF1ZXN0c1BlckRheSYmdC5wdXNoKGByZXEvZGF5ICR7ZS5yZXF1ZXN0c1BlckRheX1gKSxlLnRva2Vuc1BlckRheSYmdC5wdXNoKGB0b2svZGF5ICR7ZS50b2tlbnNQZXJEYXl9YCksZS50b2tlbnNQZXJNb250aCYmdC5wdXNoKGB0b2svbW9udGggJHtlLnRva2Vuc1Blck1vbnRofWApLGUuY29zdFBlckRheVVTRCYmdC5wdXNoKGBjb3N0L2RheSAkJHtlLmNvc3RQZXJEYXlVU0R9YCksZS5jb3N0UGVyTW9udGhVU0QmJnQucHVzaChgY29zdC9tb250aCAkJHtlLmNvc3RQZXJNb250aFVTRH1gKSx0Lmxlbmd0aD90LmpvaW4oYCwgYCk6YG5vbmVgfWZ1bmN0aW9uIGsoZSx0KXtzd2l0Y2godCl7Y2FzZWBob3VyYDpyZXR1cm5gJHtlLnNsaWNlKDgsMTApfTowMCBVVENgO2Nhc2VgZGF5YDp7bGV0IHQ9TnVtYmVyKGUuc2xpY2UoMCw0KSksbj1OdW1iZXIoZS5zbGljZSg0LDYpKSxyPU51bWJlcihlLnNsaWNlKDYsOCkpO3JldHVybiBuZXcgRGF0ZSh0LG4tMSxyKS50b0xvY2FsZURhdGVTdHJpbmcodm9pZCAwLHttb250aDpgc2hvcnRgLGRheTpgbnVtZXJpY2B9KX1jYXNlYG1vbnRoYDp7bGV0IHQ9TnVtYmVyKGUuc2xpY2UoMCw0KSksbj1OdW1iZXIoZS5zbGljZSg0LDYpKTtyZXR1cm4gbmV3IERhdGUodCxuLTEsMSkudG9Mb2NhbGVEYXRlU3RyaW5nKHZvaWQgMCx7bW9udGg6YHNob3J0YCx5ZWFyOmBudW1lcmljYH0pfX19dmFyIEE9dSh7X19uYW1lOmBCYWRnZWAscHJvcHM6e2FzQ2hpbGQ6e3R5cGU6Qm9vbGVhbn0sYXM6e30sdmFyaWFudDp7fSxjbGFzczp7dHlwZTpbQm9vbGVhbixudWxsLFN0cmluZyxPYmplY3QsQXJyYXldfX0sc2V0dXAoZSl7bGV0IHU9ZSxkPXQodSxgY2xhc3NgKTtyZXR1cm4odCxmKT0+KGMoKSxuKHIocyksbyh7ImRhdGEtc2xvdCI6YGJhZGdlYCwiZGF0YS12YXJpYW50IjplLnZhcmlhbnQsY2xhc3M6cihsKShyKGopKHt2YXJpYW50OmUudmFyaWFudH0pLHUuY2xhc3MpfSxyKGQpKSx7ZGVmYXVsdDphKCgpPT5baSh0LiRzbG90cyxgZGVmYXVsdGApXSksXzozfSwxNixbYGRhdGEtdmFyaWFudGAsYGNsYXNzYF0pKX19KSxqPWUoYGgtNSBnYXAtMSByb3VuZGVkLTR4bCBib3JkZXIgYm9yZGVyLXRyYW5zcGFyZW50IHB4LTIgcHktMC41IHRleHQteHMgZm9udC1tZWRpdW0gdHJhbnNpdGlvbi1hbGwgaGFzLWRhdGEtW2ljb249aW5saW5lLWVuZF06cHItMS41IGhhcy1kYXRhLVtpY29uPWlubGluZS1zdGFydF06cGwtMS41IFsmPnN2Z106c2l6ZS0zISBncm91cC9iYWRnZSBpbmxpbmUtZmxleCB3LWZpdCBzaHJpbmstMCBpdGVtcy1jZW50ZXIganVzdGlmeS1jZW50ZXIgb3ZlcmZsb3ctaGlkZGVuIHdoaXRlc3BhY2Utbm93cmFwIGZvY3VzLXZpc2libGU6Ym9yZGVyLXJpbmcgZm9jdXMtdmlzaWJsZTpyaW5nLTMgZm9jdXMtdmlzaWJsZTpyaW5nLXJpbmcvNTAgYXJpYS1pbnZhbGlkOmJvcmRlci1kZXN0cnVjdGl2ZSBhcmlhLWludmFsaWQ6cmluZy1kZXN0cnVjdGl2ZS8yMCBkYXJrOmFyaWEtaW52YWxpZDpyaW5nLWRlc3RydWN0aXZlLzQwIFsmPnN2Z106cG9pbnRlci1ldmVudHMtbm9uZWAse3ZhcmlhbnRzOnt2YXJpYW50OntkZWZhdWx0OmBiZy1wcmltYXJ5IHRleHQtcHJpbWFyeS1mb3JlZ3JvdW5kIFthXTpob3ZlcjpiZy1wcmltYXJ5LzgwYCxzZWNvbmRhcnk6YGJnLXNlY29uZGFyeSB0ZXh0LXNlY29uZGFyeS1mb3JlZ3JvdW5kIFthXTpob3ZlcjpiZy1zZWNvbmRhcnkvODBgLGRlc3RydWN0aXZlOmBiZy1kZXN0cnVjdGl2ZS8xMCBbYV06aG92ZXI6YmctZGVzdHJ1Y3RpdmUvMjAgZm9jdXMtdmlzaWJsZTpyaW5nLWRlc3RydWN0aXZlLzIwIGRhcms6Zm9jdXMtdmlzaWJsZTpyaW5nLWRlc3RydWN0aXZlLzQwIHRleHQtZGVzdHJ1Y3RpdmUgZGFyazpiZy1kZXN0cnVjdGl2ZS8yMGAsb3V0bGluZTpgYm9yZGVyLWJvcmRlciB0ZXh0LWZvcmVncm91bmQgW2FdOmhvdmVyOmJnLW11dGVkIFthXTpob3Zlcjp0ZXh0LW11dGVkLWZvcmVncm91bmRgLGdob3N0OmBob3ZlcjpiZy1tdXRlZCBob3Zlcjp0ZXh0LW11dGVkLWZvcmVncm91bmQgZGFyazpob3ZlcjpiZy1tdXRlZC81MGAsbGluazpgdGV4dC1wcmltYXJ5IHVuZGVybGluZS1vZmZzZXQtNCBob3Zlcjp1bmRlcmxpbmVgfX0sZGVmYXVsdFZhcmlhbnRzOnt2YXJpYW50OmBkZWZhdWx0YH19KTtleHBvcnR7ZyBhcyBhLHAgYXMgYyx2IGFzIGQsdyBhcyBmLGQgYXMgZyxFIGFzIGgsbSBhcyBpLHkgYXMgbCxEIGFzIG0seCBhcyBuLGYgYXMgbyxDIGFzIHAsayBhcyByLFMgYXMgcyxBIGFzIHQsTyBhcyB1fTs=",
+		),
+	},
+	"burndown-CqtdXSYk.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"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",
+		),
+	},
+	"catalog-C-TfKLVZ.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"aW1wb3J0e18gYXMgZSxsdCBhcyB0LHYgYXMgbix5IGFzIHJ9ZnJvbSIuL25hdi1EemIwT1ROXy5qcyI7dmFyIGk9M2U1LGE9dChgY2F0YWxvZ2Ase3N0YXRlOigpPT4oe2RhdGE6bnVsbCxmZXRjaGVkQXQ6bnVsbCxsb2FkaW5nOiExLGVycm9yOmBgLHJlcUlkOjB9KSxnZXR0ZXJzOntzdGFsZShlKXtyZXR1cm4hZS5mZXRjaGVkQXR8fERhdGUubm93KCktZS5mZXRjaGVkQXQuZ2V0VGltZSgpPml9LG1vZGVsc0J5SWQoZSl7bGV0IHQ9bmV3IE1hcDtmb3IobGV0IG4gb2YgZS5kYXRhPy5wcm92aWRlcnM/P1tdKWZvcihsZXQgZSBvZiBuLm1vZGVscyl0LnNldChlLmlkLGUpO3JldHVybiB0fX0sYWN0aW9uczp7YXN5bmMgZW5zdXJlTG9hZGVkKGU9ITEpeyFlJiZ0aGlzLmRhdGEmJiF0aGlzLnN0YWxlfHxhd2FpdCB0aGlzLmZldGNoKCl9LGFzeW5jIGZldGNoKCl7aWYoIXIoKS5pc0F1dGhlbnRpY2F0ZWQpcmV0dXJuO2xldCB0PSsrdGhpcy5yZXFJZDt0aGlzLmxvYWRpbmc9ITA7dHJ5e2xldCBlPWF3YWl0IG4oYC9hZG1pbi9hcGkvY2F0YWxvZ2ApO2lmKHQhPT10aGlzLnJlcUlkKXJldHVybjt0aGlzLmRhdGE9ZSx0aGlzLmZldGNoZWRBdD1uZXcgRGF0ZSx0aGlzLmVycm9yPWBgfWNhdGNoKG4pe2lmKHQhPT10aGlzLnJlcUlkfHxuIGluc3RhbmNlb2YgZSYmKG4uc3RhdHVzPT09NDAxfHxuLnN0YXR1cz09PTQwMykpcmV0dXJuO3RoaXMuZXJyb3I9biBpbnN0YW5jZW9mIEVycm9yP24ubWVzc2FnZTpTdHJpbmcobil9ZmluYWxseXt0PT09dGhpcy5yZXFJZCYmKHRoaXMubG9hZGluZz0hMSl9fX19KTtleHBvcnR7YSBhcyB0fTs=",
+		),
+	},
+	"clipboard-B73fZ0c1.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"YXN5bmMgZnVuY3Rpb24gZShlLHQpe2lmKG5hdmlnYXRvci5jbGlwYm9hcmQ/LndyaXRlVGV4dCl0cnl7cmV0dXJuIGF3YWl0IG5hdmlnYXRvci5jbGlwYm9hcmQud3JpdGVUZXh0KGUpLGBjb3BpZWRgfWNhdGNoe31pZighdClyZXR1cm5gZmFpbGVkYDtsZXQgbj1kb2N1bWVudC5jcmVhdGVSYW5nZSgpO24uc2VsZWN0Tm9kZUNvbnRlbnRzKHQpO2xldCByPXdpbmRvdy5nZXRTZWxlY3Rpb24oKTtyZXR1cm4gcj8oci5yZW1vdmVBbGxSYW5nZXMoKSxyLmFkZFJhbmdlKG4pLGBzZWxlY3RlZGApOmBmYWlsZWRgfWV4cG9ydHtlIGFzIHR9Ow==",
+		),
+	},
+	"consumers-wB-itjnf.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"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",
+		),
+	},
+	"events-BPFIBv4M.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"aW1wb3J0e18gYXMgZSxnIGFzIHQsbHQgYXMgbix2IGFzIHIseSBhcyBpfWZyb20iLi9uYXYtRHpiME9UTl8uanMiO3ZhciBhPTVlMyxvPTIwMCxzPW4oYGV2ZW50c2Ase3N0YXRlOigpPT4oe2V2ZW50czpbXSxzb3VyY2U6YHJlcGxpY2FgLHJlcGxpY2E6YGAsY2FwYWNpdHk6MCxkZWdyYWRlZDohMSxsYXN0VXBkYXRlZDpudWxsLGVycm9yOmBgLGtpbmRGaWx0ZXI6YGAsdXNlckZpbHRlcjpgYCxwb2xsZXI6dm9pZCAwLHJlZnJlc2hpbmc6ITF9KSxhY3Rpb25zOnthc3luYyByZWZyZXNoKCl7aWYoaSgpLmlzQXV0aGVudGljYXRlZCYmIXRoaXMucmVmcmVzaGluZyl7dGhpcy5yZWZyZXNoaW5nPSEwO3RyeXtsZXQgZT1hd2FpdCByKGAvYWRtaW4vYXBpL2V2ZW50cz9saW1pdD0ke299YCk7dGhpcy5ldmVudHM9ZS5ldmVudHMsdGhpcy5zb3VyY2U9ZS5zb3VyY2UsdGhpcy5yZXBsaWNhPWUucmVwbGljYSx0aGlzLmNhcGFjaXR5PWUuY2FwYWNpdHksdGhpcy5kZWdyYWRlZD1lLmRlZ3JhZGVkPz8hMSx0aGlzLmxhc3RVcGRhdGVkPW5ldyBEYXRlLHRoaXMuZXJyb3I9YGB9Y2F0Y2godCl7aWYodCBpbnN0YW5jZW9mIGUmJih0LnN0YXR1cz09PTQwMXx8dC5zdGF0dXM9PT00MDMpKXJldHVybjt0aGlzLmVycm9yPXQgaW5zdGFuY2VvZiBFcnJvcj90Lm1lc3NhZ2U6U3RyaW5nKHQpfWZpbmFsbHl7dGhpcy5yZWZyZXNoaW5nPSExfX19LHNldEtpbmRGaWx0ZXIoZSl7dGhpcy5raW5kRmlsdGVyPWV9LHNldFVzZXJGaWx0ZXIoZSl7dGhpcy51c2VyRmlsdGVyPWV9LHN0YXJ0UG9sbGluZygpe3RoaXMucG9sbGVyfHwodGhpcy5wb2xsZXI9dCh7aW50ZXJ2YWxNczphLHRpY2s6KCk9PnZvaWQgdGhpcy5yZWZyZXNoKCl9KSx0aGlzLnBvbGxlci5zdGFydCgpKX0sc3RvcFBvbGxpbmcoKXt0aGlzLnBvbGxlcj8uc3RvcCgpLHRoaXMucG9sbGVyPXZvaWQgMH19fSk7ZXhwb3J0e3MgYXMgdH07",
+		),
+	},
+	"events-filter-XFnjIaR7.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"dmFyIGU9e3JhdGVfbGltaXQ6YFJhdGUgbGltaXRgLGJ1ZGdldDpgQnVkZ2V0YCxzdG9yZV9kb3duOmBTdG9yZSBkb3duYCx1cHN0cmVhbTpgVXBzdHJlYW0gZXJyb3JgLHRpbWVvdXQ6YFRpbWVvdXRgLHVucHJpY2VkOmBVbnByaWNlZCBtb2RlbGAsY2FwYWNpdHk6YENhcGFjaXR5YH0sdD1PYmplY3Qua2V5cyhlKTtmdW5jdGlvbiBuKGUpe3N3aXRjaChlKXtjYXNlYHJhdGVfbGltaXRgOmNhc2VgYnVkZ2V0YDpjYXNlYGNhcGFjaXR5YDpyZXR1cm5gZGVzdHJ1Y3RpdmVgO2Nhc2Vgc3RvcmVfZG93bmA6Y2FzZWB1cHN0cmVhbWA6Y2FzZWB0aW1lb3V0YDpyZXR1cm5gc2Vjb25kYXJ5YDtkZWZhdWx0OnJldHVybmBvdXRsaW5lYH19ZnVuY3Rpb24gcihlLHQpe2xldCBuPXQua2luZCxyPXQudXNlci50cmltKCkudG9Mb3dlckNhc2UoKTtyZXR1cm4gZS5maWx0ZXIoZT0+e2lmKG4mJmUua2luZCE9PW4pcmV0dXJuITE7aWYoIXIpcmV0dXJuITA7bGV0IHQ9ZS51c2VyPy50b0xvd2VyQ2FzZSgpLmluY2x1ZGVzKHIpPz8hMSxpPWUuZ3JvdXA/LnRvTG93ZXJDYXNlKCkuaW5jbHVkZXMocik/PyExO3JldHVybiB0fHxpfSl9ZXhwb3J0e3IgYXMgaSxlIGFzIG4sbiBhcyByLHR9Ow==",
+		),
+	},
+	"forecast-BMSkg5Xs.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"ZnVuY3Rpb24gZShlKXtyZXR1cm4hTnVtYmVyLmlzRmluaXRlKGUpfHxlPC44P2Bub3JtYWxgOmU8MT9gYW1iZXJgOmByZWRgfXZhciB0PTFlNixuPXtyZXFNaW46YHJlcS9taW5gLHJlcURheTpgcmVxL2RheWAsdG9rRGF5OmB0b2tlbnMgKGluK291dCkvZGF5YCx0b2tNb250aDpgdG9rZW5zIChpbitvdXQpL21vbnRoYCxjb3N0RGF5OmBjb3N0L2RheWAsY29zdE1vbnRoOmBjb3N0L21vbnRoYH07ZnVuY3Rpb24gcihlLHQsbil7cmV0dXJue2lkOmUsdXNlZDp0LGxpbWl0Om4scmF0aW86dC9ufX1mdW5jdGlvbiBpKGUpe2xldCBuPWUubGltaXRzO2lmKCFufHxlLnN0b3JlRG93bilyZXR1cm5bXTtsZXQgaT1bXTtpZihuLnJlcXVlc3RzUGVyTWludXRlJiZpLnB1c2gocihgcmVxTWluYCxlLnJlcXVlc3RzUGVyTWludXRlLG4ucmVxdWVzdHNQZXJNaW51dGUpKSxuLnJlcXVlc3RzUGVyRGF5JiZpLnB1c2gocihgcmVxRGF5YCxlLnJlcXVlc3RzUGVyRGF5LG4ucmVxdWVzdHNQZXJEYXkpKSxuLnRva2Vuc1BlckRheSYmaS5wdXNoKHIoYHRva0RheWAsZS50b2tlbnNJblBlckRheStlLnRva2Vuc091dFBlckRheSxuLnRva2Vuc1BlckRheSkpLG4udG9rZW5zUGVyTW9udGgmJmkucHVzaChyKGB0b2tNb250aGAsZS50b2tlbnNJblBlck1vbnRoK2UudG9rZW5zT3V0UGVyTW9udGgsbi50b2tlbnNQZXJNb250aCkpLG4uY29zdFBlckRheVVTRCl7bGV0IGE9TWF0aC5yb3VuZChuLmNvc3RQZXJEYXlVU0QqdCk7YT4wJiZpLnB1c2gocihgY29zdERheWAsZS5jb3N0UGVyRGF5TWljcm9Vc2QsYSkpfWlmKG4uY29zdFBlck1vbnRoVVNEKXtsZXQgYT1NYXRoLnJvdW5kKG4uY29zdFBlck1vbnRoVVNEKnQpO2E+MCYmaS5wdXNoKHIoYGNvc3RNb250aGAsZS5jb3N0UGVyTW9udGhNaWNyb1VzZCxhKSl9cmV0dXJuIGl9ZnVuY3Rpb24gYShlKXtsZXQgdD1lLmdldFVUQ0Z1bGxZZWFyKCksbj1lLmdldFVUQ01vbnRoKCkscj1EYXRlLlVUQyh0LG4sMSksaT1EYXRlLlVUQyh0LG4rMSwxKTtyZXR1cm4oZS5nZXRUaW1lKCktcikvKGktcil9ZnVuY3Rpb24gbyhlLHQpe3JldHVybiB0PC4wMj9udWxsOk1hdGgucm91bmQoZS90KX1mdW5jdGlvbiBzKGUsbil7aWYoZT09PW51bGx8fG49PT12b2lkIDB8fG48PTApcmV0dXJue2xpbWl0TWljcm9zOm51bGwscmVtYWluaW5nTWljcm9zOm51bGwsd2lsbEV4Y2VlZDohMX07bGV0IHI9TWF0aC5yb3VuZChuKnQpLGk9ci1lO3JldHVybntsaW1pdE1pY3JvczpyLHJlbWFpbmluZ01pY3JvczppLHdpbGxFeGNlZWQ6aTwwfX1leHBvcnR7dCBhcyBhLG4gYXMgaSxhIGFzIG4saSBhcyBvLG8gYXMgcixlIGFzIHMscyBhcyB0fTs=",
+		),
+	},
+	"index-BiTQ_gCE.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/HomePage-9BEnKqFn.js","assets/nav-Dzb0OTN_.js","assets/badge-ns0j8OUr.js","assets/forecast-BMSkg5Xs.js","assets/EntityLink-CovsFjEl.js","assets/events-BPFIBv4M.js","assets/events-filter-XFnjIaR7.js","assets/kpi-CU52LDmq.js","assets/provider-rate-DU7OgSeB.js","assets/SpendPage-COAWCgvN.js","assets/CardDescription-IdOt317c.js","assets/tabs-BbGJyCRr.js","assets/Presence-CuQUGFyS.js","assets/DataTable-DVueNFuA.js","assets/CompactNumber-B1ihQZH7.js","assets/burndown-CqtdXSYk.js","assets/clipboard-B73fZ0c1.js","assets/ClampedRangeNotice-Bvhm1e-B.js","assets/TimeSeriesChart-BP5IcUyg.js","assets/catalog-C-TfKLVZ.js","assets/series-NIRVBXMP.js","assets/ConsumersPage-DZ5nHr-A.js","assets/search-expand-B1qnK1H5.js","assets/consumers-wB-itjnf.js","assets/useSearchQuery-DysBt-In.js","assets/ModelsPage-3Nt3gvlN.js","assets/reliability-0KiJSjTP.js","assets/ReliabilityPage-D4CjC5Gn.js","assets/ConfigPage-BPgQjjSB.js","assets/TargetsPage-Bi0CL-u6.js"])))=>i.map(i=>d[i]);
import{a as e,c as t,i as n,l as r,n as i,o as a,r as o,s,t as c,u as l}from"./Presence-CuQUGFyS.js";import{$ as u,$n as d,An as f,Ar as p,At as m,C as h,Cr as g,D as _,Dt as v,En as y,Er as b,Et as x,Fr as S,G as C,H as w,I as T,Ir as E,It as D,Lt as O,Mn as k,N as A,O as ee,Or as j,Ot as M,P as te,Pn as ne,Q as re,Qn as N,Rr as P,Rt as ie,S as ae,Sn as oe,Sr as se,T as ce,W as le,Xt as ue,Y as de,Yt as fe,a as pe,ar as me,b as he,br as ge,bt as _e,c as ve,cn as ye,ct as be,di as xe,dn as F,er as Se,f as Ce,gt as we,h as Te,hr as Ee,i as De,in as Oe,j as ke,jn as I,jr as Ae,k as je,kt as L,l as Me,li as Ne,lt as Pe,m as Fe,mn as Ie,n as Le,or as Re,ot as ze,p as Be,q as Ve,r as He,rr as R,si as Ue,t as We,tt as Ge,ui as Ke,un as z,vn as qe,w as B,wn as V,x as Je,y as Ye,z as Xe,zt as H}from"./nav-Dzb0OTN_.js";import{F as Ze,M as Qe,P as $e,a as et,c as tt,d as nt,h as rt,i as it,l as at,n as ot,o as st,s as ct,t as lt,u as ut}from"./CardDescription-IdOt317c.js";function dt(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 ft(e){if(Array.isArray(e))return e}function pt(e){if(Array.isArray(e))return dt(e)}function mt(e,t){if(!(e instanceof t))throw TypeError(`Cannot call a class as a function`)}function ht(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,Et(r.key),r)}}function gt(e,t,n){return t&&ht(e.prototype,t),n&&ht(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function _t(e,t){var n=typeof Symbol<`u`&&e[Symbol.iterator]||e[`@@iterator`];if(!n){if(Array.isArray(e)||(n=Ot(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=Et(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function vt(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function yt(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 bt(){throw TypeError(`Invalid attempt to destructure non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function xt(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function St(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?St(Object(n),!0).forEach(function(t){U(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):St(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function Ct(e,t){return ft(e)||yt(e,t)||Ot(e,t)||bt()}function wt(e){return pt(e)||vt(e)||Ot(e)||xt()}function Tt(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 Et(e){var t=Tt(e,`string`);return typeof t==`symbol`?t:t+``}function Dt(e){"@babel/helpers - typeof";return Dt=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},Dt(e)}function Ot(e,t){if(e){if(typeof e==`string`)return dt(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)?dt(e,t):void 0}}var kt=function(){},At={},jt={},Mt=null,Nt={mark:kt,measure:kt};try{typeof window<`u`&&(At=window),typeof document<`u`&&(jt=document),typeof MutationObserver<`u`&&(Mt=MutationObserver),typeof performance<`u`&&(Nt=performance)}catch{}var Pt=(At.navigator||{}).userAgent,Ft=Pt===void 0?``:Pt,It=At,G=jt,Lt=Mt,Rt=Nt;It.document;var zt=!!G.documentElement&&!!G.head&&typeof G.addEventListener==`function`&&typeof G.createElement==`function`,Bt=~Ft.indexOf(`MSIE`)||~Ft.indexOf(`Trident/`),Vt,Ht=/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)?[\-\ ]/,Ut=/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,Wt={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`}},Gt={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},Kt=[`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`,qt=`duotone`,Jt=`sharp`,Yt=`sharp-duotone`,Xt=`chisel`,Zt=`etch`,Qt=`graphite`,$t=`jelly`,en=`jelly-duo`,tn=`jelly-fill`,nn=`mosaic`,rn=`notdog`,an=`notdog-duo`,on=`pixel`,sn=`slab`,cn=`slab-duo`,ln=`slab-press`,un=`slab-press-duo`,dn=`thumbprint`,fn=`utility`,pn=`utility-duo`,mn=`utility-fill`,hn=`vellum`,gn=`whiteboard`,_n=`Classic`,vn=`Duotone`,yn=`Sharp`,bn=`Sharp Duotone`,xn=`Chisel`,Sn=`Etch`,Cn=`Graphite`,wn=`Jelly`,Tn=`Jelly Duo`,En=`Jelly Fill`,Dn=`Mosaic`,On=`Notdog`,kn=`Notdog Duo`,An=`Pixel`,jn=`Slab`,Mn=`Slab Duo`,Nn=`Slab Press`,Pn=`Slab Press Duo`,Fn=`Thumbprint`,In=`Utility`,Ln=`Utility Duo`,Rn=`Utility Fill`,zn=`Vellum`,Bn=`Whiteboard`,Vn=[K,qt,Jt,Yt,Xt,Zt,Qt,$t,en,tn,nn,rn,an,on,sn,cn,ln,un,dn,fn,pn,mn,hn,gn];Vt={},U(U(U(U(U(U(U(U(U(U(Vt,K,_n),qt,vn),Jt,yn),Yt,bn),Xt,xn),Zt,Sn),Qt,Cn),$t,wn),en,Tn),tn,En),U(U(U(U(U(U(U(U(U(U(Vt,nn,Dn),rn,On),an,kn),on,An),sn,jn),cn,Mn),ln,Nn),un,Pn),dn,Fn),fn,In),U(U(U(U(Vt,pn,Ln),mn,Rn),hn,zn),gn,Bn);var Hn={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`}},Un={"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`}},Wn=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}]]),Gn={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`}},Kn=[`fak`,`fa-kit`,`fakd`,`fa-kit-duotone`],qn={kit:{fak:`kit`,"fa-kit":`kit`},"kit-duotone":{fakd:`kit-duotone`,"fa-kit-duotone":`kit-duotone`}},Jn=[`kit`];U(U({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var Yn={kit:{"fa-kit":`fak`},"kit-duotone":{"fa-kit-duotone":`fakd`}},Xn={"Font Awesome Kit":{400:`fak`,normal:`fak`},"Font Awesome Kit Duotone":{400:`fakd`,normal:`fakd`}},Zn={kit:{fak:`fa-kit`},"kit-duotone":{fakd:`fa-kit-duotone`}},Qn={kit:{kit:`fak`},"kit-duotone":{"kit-duotone":`fakd`}},$n,er={GROUP:`duotone-group`,SWAP_OPACITY:`swap-opacity`,PRIMARY:`primary`,SECONDARY:`secondary`},tr=[`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`];$n={},U(U(U(U(U(U(U(U(U(U($n,`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($n,`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($n,`utility-duo`,`Utility Duo`),`utility-fill`,`Utility Fill`),`vellum`,`Vellum`),`whiteboard`,`Whiteboard`),U(U({},`kit`,`Kit`),`kit-duotone`,`Kit Duotone`);var nr={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`}},rr={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`]},ir={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`}},ar=`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(tr,[`fa-solid`,`fa-regular`,`fa-light`,`fa-thin`,`fa-duotone`,`fa-brands`,`fa-semibold`]),or=[`solid`,`regular`,`light`,`thin`,`duotone`,`brands`,`semibold`],sr=[1,2,3,4,5,6,7,8,9,10],cr=sr.concat([11,12,13,14,15,16,17,18,19,20]),lr=[].concat(wt(Object.keys(rr)),or,[`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`,er.GROUP,er.SWAP_OPACITY,er.PRIMARY,er.SECONDARY],sr.map(function(e){return`${e}x`}),cr.map(function(e){return`w-${e}`})),ur={"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`}},dr=`___FONT_AWESOME___`,fr=16,pr=`fa`,mr=`svg-inline--fa`,hr=`data-fa-i2svg`,gr=`data-fa-pseudo-element`,_r=`data-fa-pseudo-element-pending`,vr=`data-prefix`,yr=`data-icon`,br=`fontawesome-i2svg`,xr=`async`,Sr=[`HTML`,`HEAD`,`STYLE`,`SCRIPT`],Cr=[`::before`,`::after`,`:before`,`:after`],wr=function(){try{return!0}catch{return!1}}();function Tr(e){return new Proxy(e,{get:function(e,t){return t in e?e[t]:e[K]}})}var Er=W({},Wt);Er[K]=W(W(W(W({},{"fa-duotone":`duotone`}),Wt[K]),qn.kit),qn[`kit-duotone`]);var Dr=Tr(Er),Or=W({},Gn);Or[K]=W(W(W(W({},{duotone:`fad`}),Or[K]),Qn.kit),Qn[`kit-duotone`]);var kr=Tr(Or),Ar=W({},ir);Ar[K]=W(W({},Ar[K]),Zn.kit);var jr=Tr(Ar),Mr=W({},nr);Mr[K]=W(W({},Mr[K]),Yn.kit),Tr(Mr);var Nr=Ht,Pr=`fa-layers-text`,Fr=Ut;Tr(W({},Hn));var Ir=[`class`,`data-prefix`,`data-icon`,`data-fa-transform`,`data-fa-mask`],Lr=Gt,Rr=[].concat(wt(Jn),wt(lr)),zr=It.FontAwesomeConfig||{};function Br(e){var t=G.querySelector(`script[`+e+`]`);if(t)return t.getAttribute(e)}function Vr(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=Ct(e,2),n=t[0],r=t[1],i=Vr(Br(n));i!=null&&(zr[r]=i)});var Hr={styleDefault:`solid`,familyDefault:K,cssPrefix:pr,replacementClass:mr,autoReplaceSvg:!0,autoAddCss:!0,searchPseudoElements:!1,searchPseudoElementsWarnings:!0,searchPseudoElementsFullScan:!1,observeMutations:!0,mutateApproach:`async`,keepOriginalSource:!0,measurePerformance:!1,showMissingIcons:!0};zr.familyPrefix&&(zr.cssPrefix=zr.familyPrefix);var Ur=W(W({},Hr),zr);Ur.autoReplaceSvg||(Ur.observeMutations=!1);var q={};Object.keys(Hr).forEach(function(e){Object.defineProperty(q,e,{enumerable:!0,set:function(t){Ur[e]=t,Wr.forEach(function(e){return e(q)})},get:function(){return Ur[e]}})}),Object.defineProperty(q,"familyPrefix",{enumerable:!0,set:function(e){Ur.cssPrefix=e,Wr.forEach(function(e){return e(q)})},get:function(){return Ur.cssPrefix}}),It.FontAwesomeConfig=q;var Wr=[];function Gr(e){return Wr.push(e),function(){Wr.splice(Wr.indexOf(e),1)}}var Kr=fr,qr={size:16,x:0,y:0,rotate:0,flipX:!1,flipY:!1};function Jr(e){if(!(!e||!zt)){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 Yr=`0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ`;function Xr(){for(var e=12,t=``;e-->0;)t+=Yr[Math.random()*62|0];return t}function Zr(e){for(var t=[],n=(e||[]).length>>>0;n--;)t[n]=e[n];return t}function Qr(e){return e.classList?Zr(e.classList):(e.getAttribute(`class`)||``).split(` `).filter(function(e){return e})}function $r(e){return`${e}`.replace(/&/g,`&amp;`).replace(/"/g,`&quot;`).replace(/'/g,`&#39;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`)}function ei(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}="${$r(e[n])}" `},``).trim()}function ti(e){return Object.keys(e||{}).reduce(function(t,n){return t+`${n}: ${e[n].trim()};`},``)}function ni(e){return e.size!==qr.size||e.x!==qr.x||e.y!==qr.y||e.rotate!==qr.rotate||e.flipX||e.flipY}function ri(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 ii(e){var t=e.transform,n=e.width,r=n===void 0?fr:n,i=e.height,a=i===void 0?fr:i,o=e.startCentered,s=o!==void 0&&o,c=``;return c+=s&&Bt?`translate(${t.x/Kr-r/2}em, ${t.y/Kr-a/2}em) `:s?`translate(calc(-50% + ${t.x/Kr}em), calc(-50% + ${t.y/Kr}em)) `:`translate(${t.x/Kr}em, ${t.y/Kr}em) `,c+=`scale(${t.size/Kr*(t.flipX?-1:1)}, ${t.size/Kr*(t.flipY?-1:1)}) `,c+=`rotate(${t.rotate}deg) `,c}var ai=`: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 oi(){var e=pr,t=mr,n=q.cssPrefix,r=q.replacementClass,i=ai;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 si=!1;function ci(){q.autoAddCss&&!si&&(Jr(oi()),si=!0)}var li={mixout:function(){return{dom:{css:oi,insertCss:ci}}},hooks:function(){return{beforeDOMElementCreation:function(){ci()},beforeI2svg:function(){ci()}}}},ui=It||{};ui[dr]||(ui[dr]={}),ui[dr].styles||(ui[dr].styles={}),ui[dr].hooks||(ui[dr].hooks={}),ui[dr].shims||(ui[dr].shims=[]);var di=ui[dr],fi=[],pi=function(){G.removeEventListener(`DOMContentLoaded`,pi),mi=1,fi.map(function(e){return e()})},mi=!1;zt&&(mi=(G.documentElement.doScroll?/^loaded|^c/:/^loaded|^i|^c/).test(G.readyState),mi||G.addEventListener(`DOMContentLoaded`,pi));function hi(e){zt&&(mi?setTimeout(e,0):fi.push(e))}function gi(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`?$r(e):`<${t} ${ei(r)}>${a.map(gi).join(``)}</${t}>`}function _i(e,t,n){if(e&&e[t]&&e[t][n])return{prefix:t,iconName:n,icon:e[t][n]}}var vi=function(e,t){return function(n,r,i,a){return e.call(t,n,r,i,a)}},yi=function(e,t,n,r){var i=Object.keys(e),a=i.length,o=r===void 0?t:vi(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 bi(e){return wt(e).length===1?e.codePointAt(0).toString(16):null}function xi(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 Si(e,t){var n=(arguments.length>2&&arguments[2]!==void 0?arguments[2]:{}).skipHooks,r=n!==void 0&&n,i=xi(t);typeof di.hooks.addPack==`function`&&!r?di.hooks.addPack(e,xi(t)):di.styles[e]=W(W({},di.styles[e]||{}),i),e===`fas`&&Si(`fa`,t)}var Ci=di.styles,wi=di.shims,Ti=Object.keys(jr),Ei=Ti.reduce(function(e,t){return e[t]=Object.keys(jr[t]),e},{}),Di=null,Oi={},ki={},Ai={},ji={},Mi={};function Ni(e){return~Rr.indexOf(e)}function Pi(e,t){var n=t.split(`-`),r=n[0],i=n.slice(1).join(`-`);return r===e&&i!==``&&!Ni(i)?i:null}var Fi=function(){var e=function(e){return yi(Ci,function(t,n,r){return t[r]=yi(n,e,{}),t},{})};Oi=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}),ki=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}),Mi=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 Ci||q.autoFetchSvg,n=yi(wi,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:{}});Ai=n.names,ji=n.unicodes,Di=Wi(q.styleDefault,{family:q.familyDefault})};Gr(function(e){Di=Wi(e.styleDefault,{family:q.familyDefault})}),Fi();function Ii(e,t){return(Oi[e]||{})[t]}function Li(e,t){return(ki[e]||{})[t]}function Ri(e,t){return(Mi[e]||{})[t]}function zi(e){return Ai[e]||{prefix:null,iconName:null}}function Bi(e){var t=ji[e],n=Ii(`fas`,e);return t||(n?{prefix:`fas`,iconName:n}:null)||{prefix:null,iconName:null}}function Vi(){return Di}var Hi=function(){return{prefix:null,iconName:null,rest:[]}};function Ui(e){var t=K,n=Ti.reduce(function(e,t){return e[t]=`${q.cssPrefix}-${t}`,e},{});return Vn.forEach(function(r){(e.includes(n[r])||e.some(function(e){return Ei[r].includes(e)}))&&(t=r)}),t}function Wi(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).family,n=t===void 0?K:t,r=Dr[n][e];if(n===qt&&!e)return`fad`;var i=kr[n][e]||kr[n][r],a=e in di.styles?e:null;return i||a||null}function Gi(e){var t=[],n=null;return e.forEach(function(e){var r=Pi(q.cssPrefix,e);r?n=r:e&&t.push(e)}),{iconName:n,rest:t}}function Ki(e){return e.sort().filter(function(e,t,n){return n.indexOf(e)===t})}var qi=ar.concat(Kn);function Ji(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).skipLookups,n=t!==void 0&&t,r=null,i=Ki(e.filter(function(e){return qi.includes(e)})),a=Ki(e.filter(function(e){return!qi.includes(e)})),o=Ct(i.filter(function(e){return r=e,!Kt.includes(e)}),1)[0],s=o===void 0?null:o,c=Ui(i),l=W(W({},Gi(a)),{},{prefix:Wi(s,{family:c})});return W(W(W({},l),Qi({values:e,family:c,styles:Ci,config:q,canonical:l,givenPrefix:r})),Yi(n,r,l))}function Yi(e,t,n){var r=n.prefix,i=n.iconName;if(e||!r||!i)return{prefix:r,iconName:i};var a=t===`fa`?zi(i):{},o=Ri(r,i);return i=a.iconName||o||i,r=a.prefix||r,r===`far`&&!Ci.far&&Ci.fas&&!q.autoFetchSvg&&(r=`fas`),{prefix:r,iconName:i}}var Xi=Vn.filter(function(e){return e!==K||e!==qt}),Zi=Object.keys(ir).filter(function(e){return e!==K}).map(function(e){return Object.keys(ir[e])}).flat();function Qi(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===qt,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&&Xi.includes(n)&&(Object.keys(s).find(function(e){return Zi.includes(e)})||l.autoFetchSvg)&&(r.prefix=Wn.get(n).defaultShortPrefixId,r.iconName=Ri(r.prefix,r.iconName)||r.iconName),(r.prefix===`fa`||a===`fa`)&&(r.prefix=Vi()||`fas`),r}var $i=function(){function e(){mt(this,e),this.definitions={}}return gt(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]),Si(n,t[n]);var r=jr[K][n];r&&Si(r,t[n]),Fi()})}},{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}}])}(),ea=[],ta={},na={},ra=Object.keys(na);function ia(e,t){var n=t.mixoutsTo;return ea=e,ta={},Object.keys(na).forEach(function(e){ra.indexOf(e)===-1&&delete na[e]}),ea.forEach(function(e){var t=e.mixout?e.mixout():{};if(Object.keys(t).forEach(function(e){typeof t[e]==`function`&&(n[e]=t[e]),Dt(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){ta[e]||(ta[e]=[]),ta[e].push(r[e])})}e.provides&&e.provides(na)}),n}function aa(e,t){var n=[...arguments].slice(2);return(ta[e]||[]).forEach(function(e){t=e.apply(null,[t].concat(n))}),t}function oa(e){var t=[...arguments].slice(1);(ta[e]||[]).forEach(function(e){e.apply(null,t)})}function sa(){var e=arguments[0],t=Array.prototype.slice.call(arguments,1);return na[e]?na[e].apply(null,t):void 0}function ca(e){e.prefix===`fa`&&(e.prefix=`fas`);var t=e.iconName,n=e.prefix||Vi();if(t)return t=Ri(n,t)||t,_i(la.definitions,n,t)||_i(di.styles,n,t)}var la=new $i,J={noAuto:function(){q.autoReplaceSvg=!1,q.observeMutations=!1,oa(`noAuto`)},config:q,dom:{i2svg:function(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{};return zt?(oa(`beforeI2svg`,e),sa(`pseudoElements2svg`,e),sa(`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,hi(function(){ua({autoReplaceSvgRoot:t}),oa(`watch`,e)})}},parse:{icon:function(e){if(e===null)return null;if(Dt(e)===`object`&&e.prefix&&e.iconName)return{prefix:e.prefix,iconName:Ri(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=Wi(e[0]);return{prefix:n,iconName:Ri(n,t)||t}}if(typeof e==`string`&&(e.indexOf(`${q.cssPrefix}-`)>-1||e.match(Nr))){var r=Ji(e.split(` `),{skipLookups:!0});return{prefix:r.prefix||Vi(),iconName:Ri(r.prefix,r.iconName)||r.iconName}}if(typeof e==`string`){var i=Vi();return{prefix:i,iconName:Ri(i,e)||e}}}},library:la,findIconDefinition:ca,toHtml:gi},ua=function(){var e=(arguments.length>0&&arguments[0]!==void 0?arguments[0]:{}).autoReplaceSvgRoot,t=e===void 0?G:e;(Object.keys(di.styles).length>0||q.autoFetchSvg)&&zt&&q.autoReplaceSvg&&J.dom.i2svg({node:t})};function da(e,t){return Object.defineProperty(e,"abstract",{get:t}),Object.defineProperty(e,"html",{get:function(){return e.abstract.map(function(e){return gi(e)})}}),Object.defineProperty(e,"node",{get:function(){if(zt){var t=G.createElement(`div`);return t.innerHTML=e.html,t.children}}}),e}function fa(e){var t=e.children,n=e.main,r=e.mask,i=e.attributes,a=e.styles,o=e.transform;if(ni(o)&&n.found&&!r.found){var s={x:n.width/n.height/2,y:.5};i.style=ti(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 pa(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 ma(e){return[`aria-label`,`aria-labelledby`,`title`,`role`].some(function(t){return t in e})}function ha(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}`})};!ma(l.attributes)&&!l.attributes[`aria-hidden`]&&(g.attributes[`aria-hidden`]=`true`),d&&(g.attributes[hr]=``);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?sa(`generateAbstractMask`,_)||{children:[],attributes:{}}:sa(`generateAbstractIcon`,_)||{children:[],attributes:{}},y=v.children,b=v.attributes;return _.children=y,_.attributes=b,s?pa(_):fa(_)}function ga(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[hr]=``);var l=W({},a.styles);ni(i)&&(l.transform=ii({transform:i,startCentered:!0,width:n,height:r}),l[`-webkit-transform`]=l.transform);var u=ti(l);u.length>0&&(c.style=u);var d=[];return d.push({tag:`span`,attributes:c,children:[t]}),d}function _a(e){var t=e.content,n=e.extra,r=W(W({},n.attributes),{},{class:n.classes.join(` `)}),i=ti(n.styles);i.length>0&&(r.style=i);var a=[];return a.push({tag:`span`,attributes:r,children:[t]}),a}var va=di.styles;function ya(e){var t=e[0],n=e[1],r=Ct(e.slice(4),1)[0],i=null;return i=Array.isArray(r)?{tag:`g`,attributes:{class:`${q.cssPrefix}-${Lr.GROUP}`},children:[{tag:`path`,attributes:{class:`${q.cssPrefix}-${Lr.SECONDARY}`,fill:`currentColor`,d:r[0]}},{tag:`path`,attributes:{class:`${q.cssPrefix}-${Lr.PRIMARY}`,fill:`currentColor`,d:r[1]}}]}:{tag:`path`,attributes:{fill:`currentColor`,d:r}},{found:!0,width:t,height:n,icon:i}}var ba={found:!1,width:512,height:512};function xa(e,t){!wr&&!q.showMissingIcons&&e&&console.error(`Icon with name "${e}" and prefix "${t}" is missing.`)}function Sa(e,t){var n=t;return t===`fa`&&q.styleDefault!==null&&(t=Vi()),new Promise(function(r,i){if(n===`fa`){var a=zi(e)||{};e=a.iconName||e,t=a.prefix||t}if(e&&t&&va[t]&&va[t][e]){var o=va[t][e];return r(ya(o))}xa(e,t),r(W(W({},ba),{},{icon:q.showMissingIcons&&e&&sa(`missingIconAbstract`)||{}}))})}var Ca=function(){},wa=q.measurePerformance&&Rt&&Rt.mark&&Rt.measure?Rt:{mark:Ca,measure:Ca},Ta=`FA "7.3.1"`,Ea=function(e){return wa.mark(`${Ta} ${e} begins`),function(){return Da(e)}},Da=function(e){wa.mark(`${Ta} ${e} ends`),wa.measure(`${Ta} ${e}`,`${Ta} ${e} begins`,`${Ta} ${e} ends`)},Oa={begin:Ea,end:Da},ka=function(){};function Aa(e){return typeof(e.getAttribute?e.getAttribute(hr):null)==`string`}function ja(e){var t=e.getAttribute?e.getAttribute(vr):null,n=e.getAttribute?e.getAttribute(yr):null;return t&&n}function Ma(e){return e&&e.classList&&e.classList.contains&&e.classList.contains(q.replacementClass)}function Na(){return q.autoReplaceSvg===!0?Ra.replace:Ra[q.autoReplaceSvg]||Ra.replace}function Pa(e){return G.createElementNS(`http://www.w3.org/2000/svg`,e)}function Fa(e){return G.createElement(e)}function Ia(e){var t=(arguments.length>1&&arguments[1]!==void 0?arguments[1]:{}).ceFn,n=t===void 0?e.tag===`svg`?Pa:Fa: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(Ia(e,{ceFn:n}))}),r}function La(e){var t=` ${e.outerHTML} `;return t=`${t}Font Awesome fontawesome.com `,t}var Ra={replace:function(e){var t=e[0];if(t.parentNode){if(e[1].forEach(function(e){t.parentNode.insertBefore(Ia(e),t)}),t.getAttribute(hr)===null&&q.keepOriginalSource){var n=G.createComment(La(t));t.parentNode.replaceChild(n,t)}else t.remove()}},nest:function(e){var t=e[0],n=e[1];if(~Qr(t).indexOf(q.replacementClass))return Ra.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 gi(e)}).join(`
`);t.setAttribute(hr,``),t.innerHTML=a}};function za(e){e()}function Ba(e,t){var n=typeof t==`function`?t:ka;if(e.length===0)n();else{var r=za;q.mutateApproach===xr&&(r=It.requestAnimationFrame||za),r(function(){var t=Na(),r=Oa.begin(`mutate`);e.map(t),r(),n()})}}var Va=!1;function Ha(){Va=!0}function Ua(){Va=!1}var Wa=null;function Ga(e){if(Lt&&q.observeMutations){var t=e.treeCallback,n=t===void 0?ka:t,r=e.nodeCallback,i=r===void 0?ka:r,a=e.pseudoElementsCallback,o=a===void 0?ka:a,s=e.observeMutationsRoot,c=s===void 0?G:s;Wa=new Lt(function(e){if(!Va){var t=Vi();Zr(e).forEach(function(e){if(e.type===`childList`&&e.addedNodes.length>0&&!Aa(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`&&Aa(e.target)&&~Ir.indexOf(e.attributeName)){if(e.attributeName===`class`&&ja(e.target)){var r=Ji(Qr(e.target)),a=r.prefix,s=r.iconName;e.target.setAttribute(vr,a||t),s&&e.target.setAttribute(yr,s)}else Ma(e.target)&&i(e.target)}})}}),zt&&Wa.observe(c,{childList:!0,attributes:!0,characterData:!0,subtree:!0})}}function Ka(){Wa&&Wa.disconnect()}function qa(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 Ja(e){var t=e.getAttribute(`data-prefix`),n=e.getAttribute(`data-icon`),r=e.innerText===void 0?``:e.innerText.trim(),i=Ji(Qr(e));return i.prefix||=Vi(),t&&n&&(i.prefix=t,i.iconName=n),i.iconName&&i.prefix?i:(i.prefix&&r.length>0&&(i.iconName=Li(i.prefix,e.innerText)||Ii(i.prefix,bi(e.innerText))),!i.iconName&&q.autoFetchSvg&&e.firstChild&&e.firstChild.nodeType===Node.TEXT_NODE&&(i.iconName=e.firstChild.data),i)}function Ya(e){return Zr(e.attributes).reduce(function(e,t){return e.name!==`class`&&e.name!==`style`&&(e[t.name]=t.value),e},{})}function Xa(){return{iconName:null,prefix:null,transform:qr,symbol:!1,mask:{iconName:null,prefix:null,rest:[]},maskId:null,extra:{classes:[],styles:{},attributes:{}}}}function Za(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{styleParser:!0},n=Ja(e),r=n.iconName,i=n.prefix,a=n.rest,o=Ya(e),s=aa(`parseNodeAttributes`,{},e);return W({iconName:r,prefix:i,transform:qr,mask:{iconName:null,prefix:null,rest:[]},maskId:null,symbol:!1,extra:{classes:a,styles:t.styleParser?qa(e):[],attributes:o}},s)}var Qa=di.styles;function $a(e){var t=q.autoReplaceSvg===`nest`?Za(e,{styleParser:!1}):Za(e);return~t.extra.classes.indexOf(Pr)?sa(`generateLayersText`,e,t):sa(`generateSvgReplacementMutation`,e,t)}function eo(){return[].concat(wt(Kn),wt(ar))}function to(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;if(!zt)return Promise.resolve();var n=G.documentElement.classList,r=function(e){return n.add(`${br}-${e}`)},i=function(e){return n.remove(`${br}-${e}`)},a=q.autoFetchSvg?eo():Kt.concat(Object.keys(Qa));a.includes(`fa`)||a.push(`fa`);var o=[`.${Pr}:not([${hr}])`].concat(a.map(function(e){return`.${e}:not([${hr}])`})).join(`, `);if(o.length===0)return Promise.resolve();var s=[];try{s=Zr(e.querySelectorAll(o))}catch{}if(s.length>0)r(`pending`),i(`complete`);else return Promise.resolve();var c=Oa.begin(`onTree`),l=s.reduce(function(e,t){try{var n=$a(t);n&&e.push(n)}catch(e){wr||e.name===`MissingIcon`&&console.error(e)}return e},[]);return new Promise(function(e,n){Promise.all(l).then(function(n){Ba(n,function(){r(`active`),r(`complete`),i(`pending`),typeof t==`function`&&t(),c(),e()})}).catch(function(e){c(),n(e)})})}function no(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:null;$a(e).then(function(e){e&&Ba([e],t)})}function ro(e){return function(t){var n=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},r=(t||{}).icon?t:ca(t||{}),i=n.mask;return i&&=(i||{}).icon?i:ca(i||{}),e(r,W(W({},n),{},{mask:i}))}}var io=function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?qr: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 da(W({type:`icon`},e),function(){return oa(`beforeDOMElementCreation`,{iconDefinition:e,params:t}),ha({icons:{main:ya(v),mask:s?ya(s.icon):{found:!1,width:null,height:null,icon:{}}},prefix:g,iconName:_,transform:W(W({},qr),r),symbol:a,maskId:l,extra:{attributes:p,styles:h,classes:d}})})}},ao={mixout:function(){return{icon:ro(io)}},hooks:function(){return{mutationObserverCallbacks:function(e){return e.treeCallback=to,e.nodeCallback=no,e}}},provides:function(e){e.i2svg=function(e){var t=e.node,n=t===void 0?G:t,r=e.callback;return to(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([Sa(n,r),o.iconName?Sa(o.iconName,o.prefix):Promise.resolve({found:!1,width:512,height:512,icon:{}})]).then(function(o){var l=Ct(o,2),u=l[0],d=l[1];t([e,ha({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=ti(a);o.length>0&&(n.style=o);var s;return ni(i)&&(s=sa(`generateAbstractTransformGrouping`,{main:r,transform:i,containerWidth:r.width,iconWidth:r.width})),t.push(s||r.icon),{children:t,attributes:n}}}},oo={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 da({type:`layer`},function(){oa(`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(wt(r)).join(` `)},children:n}]})}}}},so={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 da({type:`counter`,content:e},function(){return oa(`beforeDOMElementCreation`,{content:e,params:t}),_a({content:e.toString(),title:r,extra:{attributes:s,styles:l,classes:[`${q.cssPrefix}-layers-counter`].concat(wt(a))}})})}}}},co={mixout:function(){return{text:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.transform,r=n===void 0?qr: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 da({type:`text`,content:e},function(){return oa(`beforeDOMElementCreation`,{content:e,params:t}),ga({content:e,transform:W(W({},qr),r),extra:{attributes:s,styles:l,classes:[`${q.cssPrefix}-layers-text`].concat(wt(a))}})})}}},provides:function(e){e.generateLayersText=function(e,t){var n=t.transform,r=t.extra,i=null,a=null;if(Bt){var o=parseInt(getComputedStyle(e).fontSize,10),s=e.getBoundingClientRect();i=s.width/o,a=s.height/o}return Promise.resolve([e,ga({content:e.innerHTML,width:i,height:a,transform:n,extra:r,watchable:!0})])}}},lo=RegExp(`"`,`ug`),uo=[1105920,1112319],fo=W(W(W(W({},{FontAwesome:{normal:`fas`,400:`fas`}}),Un),ur),Xn),po=Object.keys(fo).reduce(function(e,t){return e[t.toLowerCase()]=fo[t],e},{}),mo=Object.keys(po).reduce(function(e,t){var n=po[t];return e[t]=n[900]||wt(Object.entries(n))[0][1],e},{});function ho(e){return bi(wt(e.replace(lo,``))[0]||``)}function go(e){var t=e.getPropertyValue(`font-feature-settings`).includes(`ss01`),n=e.getPropertyValue(`content`).replace(lo,``),r=n.codePointAt(0),i=r>=uo[0]&&r<=uo[1],a=n.length===2&&n[0]===n[1];return i||a||t}function _o(e,t){var n=e.replace(/^['"]|['"]$/g,``).toLowerCase(),r=parseInt(t),i=isNaN(r)?`normal`:r;return(po[n]||{})[i]||mo[n]}function vo(e,t){var n=`${_r}${t.replace(`:`,`-`)}`;return new Promise(function(r,i){if(e.getAttribute(n)!==null)return r();var a=Zr(e.children).filter(function(e){return e.getAttribute(gr)===t})[0],o=It.getComputedStyle(e,t),s=o.getPropertyValue(`font-family`),c=s.match(Fr),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=_o(s,l),p=ho(d),m=c[0].startsWith(`FontAwesome`),h=go(o),g=Ii(f,p),_=g;if(m){var v=Bi(p);v.iconName&&v.prefix&&(g=v.iconName,f=v.prefix)}if(g&&!h&&(!a||a.getAttribute(vr)!==f||a.getAttribute(yr)!==_)){e.setAttribute(n,_),a&&e.removeChild(a);var y=Xa(),b=y.extra;b.attributes[gr]=t,Sa(g,f).then(function(i){var a=ha(W(W({},y),{},{icons:{main:i,mask:Hi()},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 gi(e)}).join(`
`),e.removeAttribute(n),r()}).catch(i)}else r()}else r()})}function yo(e){return Promise.all([vo(e,`::before`),vo(e,`::after`)])}function bo(e){return e.parentNode!==document.head&&!~Sr.indexOf(e.tagName.toUpperCase())&&!e.getAttribute(gr)&&(!e.parentNode||e.parentNode.tagName!==`svg`)}var xo=function(e){return!!e&&Cr.some(function(t){return e.includes(t)})},So=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=_t(n),i;try{for(r.s();!(i=r.n()).done;){var a=i.value;if(xo(a)){var o=Cr.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 Co(e){var t=arguments.length>1&&arguments[1]!==void 0&&arguments[1];if(zt){var n;if(t)n=e;else if(q.searchPseudoElementsFullScan)n=e.querySelectorAll(`*`);else{var r=new Set,i=_t(document.styleSheets),a;try{for(i.s();!(a=i.n()).done;){var o=a.value;try{var s=_t(o.cssRules),c;try{for(s.s();!(c=s.n()).done;){var l=c.value,u=_t(So(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=Zr(n).filter(bo).map(yo),i=Oa.begin(`searchPseudoElements`);Ha(),Promise.all(r).then(function(){i(),Ua(),e()}).catch(function(){i(),Ua(),t()})})}}var wo={hooks:function(){return{mutationObserverCallbacks:function(e){return e.pseudoElementsCallback=Co,e}}},provides:function(e){e.pseudoElements2svg=function(e){var t=e.node,n=t===void 0?G:t;q.searchPseudoElements&&Co(n)}}},To=!1,Eo={mixout:function(){return{dom:{unwatch:function(){Ha(),To=!0}}}},hooks:function(){return{bootstrap:function(){Ga(aa(`mutationObserverCallbacks`,{}))},noAuto:function(){Ka()},watch:function(e){var t=e.observeMutationsRoot;To?Ua():Ga(aa(`mutationObserverCallbacks`,{observeMutationsRoot:t}))}}}},Do=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})},Oo={mixout:function(){return{parse:{transform:function(e){return Do(e)}}}},hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-transform`);return n&&(e.transform=Do(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)}]}]}}}},ko={x:0,y:0,width:`100%`,height:`100%`};function Ao(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 jo(e){return e.tag===`g`?e.children:[e]}ia([li,ao,oo,so,co,wo,Eo,Oo,{hooks:function(){return{parseNodeAttributes:function(e,t){var n=t.getAttribute(`data-fa-mask`),r=n?Ji(n.split(` `).map(function(e){return e.trim()})):Hi();return r.prefix||=Vi(),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=ri({transform:o,containerWidth:l,iconWidth:s}),f={tag:`rect`,attributes:W(W({},ko),{},{fill:`white`})},p=c.children?{children:c.children.map(Ao)}:{},m={tag:`g`,attributes:W({},d.inner),children:[Ao(W({tag:c.tag,attributes:W(W({},c.attributes),d.path)},p))]},h={tag:`g`,attributes:W({},d.outer),children:[m]},g=`mask-${a||Xr()}`,_=`clip-${a||Xr()}`,v={tag:`mask`,attributes:W(W({},ko),{},{id:g,maskUnits:`userSpaceOnUse`,maskContentUnits:`userSpaceOnUse`}),children:[f,h]},y={tag:`defs`,children:[{tag:`clipPath`,attributes:{id:_},children:jo(u)},v]};return t.push(y,{tag:`rect`,attributes:W({fill:`currentColor`,"clip-path":`url(#${_})`,mask:`url(#${g})`},ko)}),{children:t,attributes:n}}}},{provides:function(e){var t=!1;It.matchMedia&&(t=It.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 Mo=J.config;J.library,J.dom;var No=J.parse;J.findIconDefinition,J.toHtml;var Po=J.icon;J.layer;var Fo=J.text;J.counter;function Io(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 Lo(e){if(Array.isArray(e))return Io(e)}function Y(e,t,n){return(t=Go(t))in e?Object.defineProperty(e,t,{value:n,enumerable:!0,configurable:!0,writable:!0}):e[t]=n,e}function Ro(e){if(typeof Symbol<`u`&&e[Symbol.iterator]!=null||e[`@@iterator`]!=null)return Array.from(e)}function zo(){throw TypeError(`Invalid attempt to spread non-iterable instance.
In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`)}function Bo(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?Bo(Object(n),!0).forEach(function(t){Y(e,t,n[t])}):Object.getOwnPropertyDescriptors?Object.defineProperties(e,Object.getOwnPropertyDescriptors(n)):Bo(Object(n)).forEach(function(t){Object.defineProperty(e,t,Object.getOwnPropertyDescriptor(n,t))})}return e}function Vo(e,t){if(e==null)return{};var n,r,i=Ho(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 Ho(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 Uo(e){return Lo(e)||Ro(e)||qo(e)||zo()}function Wo(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 Go(e){var t=Wo(e,`string`);return typeof t==`symbol`?t:t+``}function Ko(e){"@babel/helpers - typeof";return Ko=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},Ko(e)}function qo(e,t){if(e){if(typeof e==`string`)return Io(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)?Io(e,t):void 0}}function Jo(e,t){return Array.isArray(t)&&t.length>0||!Array.isArray(t)&&t?Y({},e,t):{}}function Yo(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 Xo=typeof globalThis<`u`?globalThis:typeof window<`u`?window:typeof global<`u`?global:typeof self<`u`?self:{},Zo={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})(Xo)})(Zo);var Qo=Zo.exports,$o=[`gradientFill`],es=[`class`,`style`],ts=[`type`,`stops`,`id`];function ns(e){return e.split(`;`).map(function(e){return e.trim()}).filter(function(e){return e}).reduce(function(e,t){var n=t.indexOf(`:`),r=Qo.camelize(t.slice(0,n));return e[r]=t.slice(n+1).trim(),e},{})}function rs(e){return e.split(/\s+/).reduce(function(e,t){return e[t]=!0,e},{})}function is(e,t){return ue(`stop`,X({key:`${t}-${e.offset}`,offset:e.offset,"stop-color":e.color},e.opacity!==void 0&&{"stop-opacity":e.opacity}))}function as(e){if(typeof e==`string`)return e;var t=(e.children||[]).map(as);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 os(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=Vo(t,$o),o=i||`fill`in n?as(e):e,s=(o.children||[]).map(function(e){return os(e,{},{})}),c=Object.keys(o.attributes||{}).reduce(function(e,t){var n=o.attributes[t];switch(t){case`class`:e.class=rs(n);break;case`style`:e.style=ns(n);break;default:e.attrs[t]=n}return e},{attrs:{},class:{},style:{}});n.class;var l=n.style,u=l===void 0?{}:l,d=Vo(n,es);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=Vo(i,ts),_=ue(f===`linear`?`linearGradient`:`radialGradient`,X(X({},g),{},{id:h}),m.map(is));return ue(o.tag,X(X(X(X({},a),{},{class:c.class,style:X(X({},c.style),u)},c.attrs),d),{},{fill:`url(#${h})`}),[_].concat(Uo(s)))}return ue(e.tag,X(X(X({},a),{},{class:c.class,style:X(X({},c.style),u)},c.attrs),d),s)}var ss=!1;try{ss=!0}catch{}function cs(){if(!ss&&console&&typeof console.error==`function`){var e;(e=console).error.apply(e,arguments)}}function ls(e){if(e&&Ko(e)===`object`&&e.prefix&&e.iconName&&e.icon)return e;if(No.icon)return No.icon(e);if(e===null)return null;if(Ko(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 us=H({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=x(function(){return ls(e.icon)}),i=x(function(){return Jo(`classes`,Yo(e))}),a=x(function(){return Jo(`transform`,typeof e.transform==`string`?No.transform(e.transform):e.transform)}),o=x(function(){return Jo(`mask`,ls(e.mask))}),s=x(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,Po(r.value,t)});N(s,function(e){if(!e)return cs(`Could not find one or more icon(s)`,r.value,o.value)},{immediate:!0}),e.gradientFill&&e.symbol&&cs(`gradientFill is not supported when symbol is true and will be ignored`);var c=x(function(){return s.value?os(s.value.abstract[0],{gradientFill:e.symbol?null:e.gradientFill},n):null});return function(){return c.value}}});H({name:`FontAwesomeLayers`,props:{fixedWidth:{type:Boolean,default:!1}},setup:function(e,t){var n=t.slots,r=Mo.familyPrefix,i=x(function(){return[`${r}-layers`].concat(Uo(e.fixedWidth?[`${r}-fw`]:[]))});return function(){return ue(`div`,{class:i.value},n.default?n.default():[])}}}),H({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=Mo.familyPrefix,i=x(function(){return Jo(`classes`,[].concat(Uo(e.counter?[`${r}-layers-counter`]:[]),Uo(e.position?[`${r}-layers-${e.position}`]:[])))}),a=x(function(){return Jo(`transform`,typeof e.transform==`string`?No.transform(e.transform):e.transform)}),o=x(function(){var t=Fo(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=x(function(){return os(o.value,{},n)});return function(){return s.value}}});var ds={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`]},fs=H({__name:`AlertTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(V(),m(`div`,{"data-slot":`alert-title`,class:Ue(P(Xe)(`font-medium group-has-[>svg]/alert:col-start-2 font-heading [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground`,t.class))},[I(e.$slots,`default`)],2))}});function ps(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 ms(e,t,n){let r=n.originalEvent.target,i=new CustomEvent(e,{bubbles:!1,cancelable:!0,detail:n});t&&r.addEventListener(e,t,{once:!0}),r.dispatchEvent(i)}var Q=b({layersRoot:new Set,layersWithOutsidePointerEventsDisabled:new Set,originalBodyPointerEvents:void 0,branches:new Set});function hs(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 gs(e,t,n=`.`,r){if(!hs(t))return gs(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]]:hs(a)&&hs(i[t])?gs(a,i[t],(n?`${n}.`:``)+t.toString(),r):a))}return i}function _s(e){return(...t)=>t.reduce((t,n)=>gs(t,n,``,e),{})}var vs=_s(),ys=ee(()=>{let e=j(new Map),t=j(),n=x(()=>{for(let t of e.value.values())if(t)return!0;return!1}),r=s({scrollBody:j(!0)}),i=null,a=()=>{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??``,ke&&i?.(),t.value=void 0};return N(n,(e,o)=>{if(!je)return;if(!e){o&&a();return}t.value===void 0&&(t.value=document.body.style.overflow);let s=window.innerWidth-document.documentElement.clientWidth,c={padding:s,margin:0},l=r.scrollBody?.value?typeof r.scrollBody.value==`object`?vs({padding:r.scrollBody.value.padding===!0?s:r.scrollBody.value.padding,margin:r.scrollBody.value.margin===!0?s:r.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`),ke&&(i=st(document,`touchmove`,e=>Ss(e),{passive:!1})),F(()=>{n.value&&(document.body.style.pointerEvents=`none`,document.body.style.overflow=`hidden`)})},{immediate:!0,flush:`sync`}),e});function bs(e){let t=Math.random().toString(36).substring(2,7),n=ys();n.value.set(t,e??!1);let r=x({get:()=>n.value.get(t)??!1,set:e=>n.value.set(t,e)});return T(()=>{n.value.delete(t)}),r}function xs(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:xs(t)}}function Ss(e){let t=e||window.event,n=t.target;return n instanceof Element&&xs(n)?!1:t.touches.length>1||(t.preventDefault&&t.cancelable&&t.preventDefault(),!1)}var Cs=0;function ws(){d(e=>{if(!je)return;let t=document.querySelectorAll(`[data-reka-focus-guard]`);document.body.insertAdjacentElement(`afterbegin`,t[0]??Ts()),document.body.insertAdjacentElement(`beforeend`,t[1]??Ts()),Cs++,e(()=>{Cs===1&&document.querySelectorAll(`[data-reka-focus-guard]`).forEach(e=>e.remove()),Cs--})})}function Ts(){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 Es(e){return x(()=>!E(e)||!!et(e)?.closest(`form`))}var Ds=function(e){return typeof document>`u`?null:(Array.isArray(e)?e[0]:e).ownerDocument.body},Os=new WeakMap,ks=new WeakMap,As={},js=0,Ms=function(e){return e&&(e.host||Ms(e.parentNode))},Ns=function(e,t){return t.map(function(t){if(e.contains(t))return t;var n=Ms(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})},Ps=function(e,t,n,r){var i=Ns(t,Array.isArray(e)?e:[e]);As[n]||(As[n]=new WeakMap);var a=As[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=(Os.get(e)||0)+1,l=(a.get(e)||0)+1;Os.set(e,c),a.set(e,l),o.push(e),c===1&&i&&ks.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(),js++,function(){o.forEach(function(e){var t=Os.get(e)-1,i=a.get(e)-1;Os.set(e,t),a.set(e,i),t||(ks.has(e)||e.removeAttribute(r),ks.delete(e)),i||e.removeAttribute(n)}),js--,js||(Os=new WeakMap,Os=new WeakMap,ks=new WeakMap,As={})}},Fs=function(e,t,n){n===void 0&&(n=`data-aria-hidden`);var r=Array.from(Array.isArray(e)?e:[e]),i=t||Ds(e);return i?(r.push.apply(r,Array.from(i.querySelectorAll(`[aria-live], script`))),Ps(r,i,n,`aria-hidden`)):function(){return null}};function Is(e){let t;N(()=>et(e),e=>{let n=!1;try{n=!!e?.closest(`[popover]:not(:popover-open)`)}catch{}e&&!n?t=Fs(e):t&&t()}),oe(()=>{t&&t()})}function Ls(e){let t=j(),n=x(()=>t.value?.width??0),r=x(()=>t.value?.height??0),i;return qe(()=>{let n=et(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}),oe(()=>{i?.disconnect(),i=void 0}),{width:n,height:r}}function Rs(e){let t=te(``,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=Bs(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 zs(e,t){return e.map((n,r)=>e[(t+r)%e.length])}function Bs(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=zs(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 Vs(){let e=j();return{primitiveElement:e,currentElement:x(()=>[`#text`,`#comment`].includes(e.value?.$el.nodeName)?e.value?.$el.nextElementSibling:et(e))}}var Hs=`dismissableLayer.pointerDownOutside`,Us=`dismissableLayer.focusOutside`;function Ws(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 Gs(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=j(!1),a=j(()=>{});return d(o=>{if(!je||!E(n))return;let s=async n=>{let o=n.target;if(!(!t?.value||!o)){if(Ws(t.value,o)){i.value=!1;return}if(n.target&&!i.value){let t={originalEvent:n};function i(){ms(Hs,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:()=>{E(n)&&(i.value=!0)}}}function Ks(e,t,n=!0){let r=t?.value?.ownerDocument??globalThis?.document,i=j(!1);return d(a=>{if(!je||!E(n))return;let o=async n=>{if(!t?.value)return;await F(),await F();let r=n.target;!t.value||!r||Ws(t.value,r)||n.target&&!i.value&&ms(Us,e,{originalEvent:n})};r.addEventListener(`focusin`,o),a(()=>r.removeEventListener(`focusin`,o))}),{onFocusCapture:()=>{E(n)&&(i.value=!0)},onBlurCapture:()=>{E(n)&&(i.value=!1)}}}var qs=H({__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(n,{emit:r}){let i=n,a=r,{forwardRef:o,currentElement:s}=e(),c=x(()=>s.value?.ownerDocument??globalThis.document),l=x(()=>Q.layersRoot),u=x(()=>s.value?Array.from(l.value).indexOf(s.value):-1),f=x(()=>Q.layersWithOutsidePointerEventsDisabled.size>0),p=x(()=>{let e=Array.from(l.value),[t]=[...Q.layersWithOutsidePointerEventsDisabled].slice(-1),n=e.indexOf(t);return u.value>=n}),m=Gs(async e=>{let t=[...Q.branches].some(t=>t?.contains(e.target));!i.present||!p.value||t||(a(`pointerDownOutside`,e),a(`interactOutside`,e),await F(),e.defaultPrevented||a(`dismiss`))},s),h=Ks(e=>{let t=[...Q.branches].some(t=>t?.contains(e.target));!i.present||t||(a(`focusOutside`,e),a(`interactOutside`,e),e.defaultPrevented||a(`dismiss`))},s);return it(`Escape`,e=>{i.present&&u.value===l.value.size-1&&(a(`escapeKeyDown`,e),e.defaultPrevented||a(`dismiss`))}),N([s,()=>i.disableOutsidePointerEvents,()=>i.present],([e,n,r],i,a)=>{!e||!r||n&&(Q.layersWithOutsidePointerEventsDisabled.size===0&&(Q.originalBodyPointerEvents=c.value.body.style.pointerEvents,c.value.body.style.pointerEvents=`none`),Q.layersWithOutsidePointerEventsDisabled.add(e),a(()=>{Q.layersWithOutsidePointerEventsDisabled.delete(e),Q.layersWithOutsidePointerEventsDisabled.size===0&&!t(Q.originalBodyPointerEvents)&&(c.value.body.style.pointerEvents=Q.originalBodyPointerEvents)}))},{immediate:!0}),N([s,()=>i.present],([e,t],n,r)=>{!e||!t||(l.value.add(e),r(()=>{l.value.delete(e)}))},{immediate:!0}),d(e=>{e(()=>{s.value&&(l.value.delete(s.value),Q.layersWithOutsidePointerEventsDisabled.delete(s.value))})}),(e,t)=>(V(),M(P(B),{ref:P(o),"as-child":e.asChild,as:e.as,"data-dismissable-layer":``,style:Ke({pointerEvents:f.value?p.value?`auto`:`none`:void 0}),onFocusCapture:P(h).onFocusCapture,onBlurCapture:P(h).onBlurCapture,onPointerdownCapture:P(m).onPointerDownCapture},{default:R(()=>[I(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`style`,`onFocusCapture`,`onBlurCapture`,`onPointerdownCapture`]))}}),Js=_(()=>j([]));function Ys(){let e=Js();return{add(t){let n=e.value[0];t!==n&&n?.pause(),e.value=Xs(e.value,t),e.value.unshift(t)},remove(t){e.value=Xs(e.value,t),e.value[0]?.resume()}}}function Xs(e,t){let n=[...e],r=n.indexOf(t);return r!==-1&&n.splice(r,1),n}var Zs=`focusScope.autoFocusOnMount`,Qs=`focusScope.autoFocusOnUnmount`,$s={bubbles:!1,cancelable:!0};function ec(e,{select:t=!1}={}){let n=Z();for(let r of e)if(oc(r,{select:t}),Z()!==n)return!0}function tc(e){let t=nc(e);return[rc(t,e),rc(t.reverse(),e)]}function nc(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 rc(e,t){for(let n of e)if(!ic(n,{upTo:t}))return n}function ic(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 ac(e){return e instanceof HTMLInputElement&&`select`in e}function oc(e,{select:t=!1}={}){if(e&&e.focus){let n=Z();e.focus({preventScroll:!0}),e!==n&&ac(e)&&t&&e.select()}}var sc=H({__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(t,{emit:n}){let r=t,i=n,{currentRef:a,currentElement:o}=e(),s=j(null),c=Ys(),l=b({paused:!1,pause(){this.paused=!0},resume(){this.paused=!1}});d(e=>{if(!je)return;let t=o.value;if(!r.trapped)return;function n(e){if(l.paused||!t)return;let n=e.target;t.contains(n)?s.value=n:oc(s.value,{select:!0})}function i(e){if(l.paused||!t)return;let n=e.relatedTarget;n!==null&&(t.contains(n)||oc(s.value,{select:!0}))}function a(e){let n=s.value;n!==null&&e.some(e=>e.removedNodes.length>0)&&(t.contains(n)||oc(t))}document.addEventListener(`focusin`,n),document.addEventListener(`focusout`,i);let c=new MutationObserver(a);t&&c.observe(t,{childList:!0,subtree:!0}),e(()=>{document.removeEventListener(`focusin`,n),document.removeEventListener(`focusout`,i),c.disconnect()})});function u(e,t){let n=new CustomEvent(Zs,$s),r=e=>i(`mountAutoFocus`,e);e.addEventListener(Zs,r),e.dispatchEvent(n),e.removeEventListener(Zs,r),n.defaultPrevented||(ec(nc(e),{select:!0}),Z()===t&&oc(e))}d(async e=>{let t=o.value;if(await F(),!t)return;r.present!==!1&&c.add(l);let n=Z();!t.contains(n)&&r.present!==!1&&u(t,n),e(()=>{let e=new CustomEvent(Qs,$s),r=e=>{i(`unmountAutoFocus`,e)};t.addEventListener(Qs,r),t.dispatchEvent(e),t.setAttribute(`data-focus-scope-unmounting`,``),setTimeout(()=>{e.defaultPrevented||oc(n??document.body,{select:!0}),t.removeEventListener(Qs,r),c.remove(l),t.removeAttribute(`data-focus-scope-unmounting`)},0)})}),N(()=>r.present,async(e,t)=>{if(!je)return;if(e===!1&&t===!0){c.remove(l);return}if(e!==!0||t!==!1)return;c.add(l),await F();let n=o.value;if(!n)return;let r=Z();n.contains(r)||u(n,r)});function f(e){if(!r.loop&&!r.trapped||l.paused)return;let t=e.key===`Tab`&&!e.altKey&&!e.ctrlKey&&!e.metaKey,n=Z();if(t&&n){let t=e.currentTarget,[i,a]=tc(t);i&&a?!e.shiftKey&&n===a?(e.preventDefault(),r.loop&&oc(i,{select:!0})):e.shiftKey&&n===i&&(e.preventDefault(),r.loop&&oc(a,{select:!0})):n===t&&e.preventDefault()}}return(e,t)=>(V(),M(P(B),{ref_key:`currentRef`,ref:a,tabindex:`-1`,"as-child":e.asChild,as:e.as,onKeydown:f},{default:R(()=>[I(e.$slots,`default`)]),_:3},8,[`as-child`,`as`]))}}),cc=[`Enter`,` `],lc=[`ArrowDown`,`PageUp`,`Home`],uc=[`ArrowUp`,`PageDown`,`End`];[...lc,...uc],[...cc],[...cc];function dc(e){let t=Z();for(let n of e)if(n===t||(n.focus(),Z()!==t))return}var fc=H({__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=s({}),r=x(()=>t.to??n.teleportTo?.value??`body`),i=ct();return(e,t)=>P(i)||e.forceMount?(V(),M(_e,{key:0,to:r.value,disabled:e.disabled,defer:e.defer},[I(e.$slots,`default`)],8,[`to`,`disabled`,`defer`])):L(`v-if`,!0)}}),pc=`data-reka-collection-item`;function mc(e={}){let{key:t=``,isProvider:n=!1}=e,r=`${t}CollectionProvider`,i;if(n){let e=j(new Map);i={collectionRef:j(),itemMap:e},y(r,i)}else i=Oe(r);let a=(e=!1)=>{let t=i.collectionRef.value;if(!t)return[];let n=Array.from(t.querySelectorAll(`[${pc}]`)),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=H({name:`CollectionSlot`,inheritAttrs:!1,setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=Vs();return N(a,()=>{i.collectionRef.value=a.value}),()=>ue(ce,{ref:r,...n},t)}}),s=H({name:`CollectionItem`,inheritAttrs:!1,props:{value:{validator:()=>!0}},setup(e,{slots:t,attrs:n}){let{primitiveElement:r,currentElement:a}=Vs();return d(t=>{if(a.value){let n=se(a.value);i.itemMap.value.set(n,{ref:a.value,value:e.value}),t(()=>i.itemMap.value.delete(n))}}),()=>ue(ce,{...n,[pc]:``,ref:r},t)}});return{getItems:a,reactiveItems:x(()=>Array.from(i.itemMap.value.values())),itemMapSize:x(()=>i.itemMap.value.size),CollectionSlot:o,CollectionItem:s}}var hc=H({__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)=>(V(),M(P(B),{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(()=>[I(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`aria-hidden`,`data-hidden`,`tabindex`]))}}),[gc,_c]=r(`PopperRoot`),vc=H({inheritAttrs:!1,__name:`PopperRoot`,setup(e){let t=j();return _c({anchor:t,onAnchorChange:e=>t.value=e}),(e,t)=>I(e.$slots,`default`)}}),yc=H({__name:`PopperAnchor`,props:{reference:{type:null,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(t){let n=t,{forwardRef:r,currentElement:i}=e(),a=gc();return Se(()=>{a.onAnchorChange(n.reference??i.value)}),(e,t)=>(V(),M(P(B),{ref:P(r),as:e.as,"as-child":e.asChild},{default:R(()=>[I(e.$slots,`default`)]),_:3},8,[`as`,`as-child`]))}});function bc(e){return e!==null}function xc(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]=Sc(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 Sc(e){let[t,n=`center`]=e.split(`-`);return[t,n]}var Cc=[`top`,`right`,`bottom`,`left`],wc=Math.min,Tc=Math.max,Ec=Math.round,Dc=Math.floor,Oc=e=>({x:e,y:e}),kc={left:`right`,right:`left`,bottom:`top`,top:`bottom`};function Ac(e,t,n){return Tc(e,wc(t,n))}function jc(e,t){return typeof e==`function`?e(t):e}function Mc(e){return e.split(`-`)[0]}function Nc(e){return e.split(`-`)[1]}function Pc(e){return e===`x`?`y`:`x`}function Fc(e){return e===`y`?`height`:`width`}function Ic(e){let t=e[0];return t===`t`||t===`b`?`y`:`x`}function Lc(e){return Pc(Ic(e))}function Rc(e,t,n){n===void 0&&(n=!1);let r=Nc(e),i=Lc(e),a=Fc(i),o=i===`x`?r===(n?`end`:`start`)?`right`:`left`:r===`start`?`bottom`:`top`;return t.reference[a]>t.floating[a]&&(o=qc(o)),[o,qc(o)]}function zc(e){let t=qc(e);return[Bc(e),t,Bc(t)]}function Bc(e){return e.includes(`start`)?e.replace(`start`,`end`):e.replace(`end`,`start`)}var Vc=[`left`,`right`],Hc=[`right`,`left`],Uc=[`top`,`bottom`],Wc=[`bottom`,`top`];function Gc(e,t,n){switch(e){case`top`:case`bottom`:return n?t?Hc:Vc:t?Vc:Hc;case`left`:case`right`:return t?Uc:Wc;default:return[]}}function Kc(e,t,n,r){let i=Nc(e),a=Gc(Mc(e),n===`start`,r);return i&&(a=a.map(e=>e+`-`+i),t&&(a=a.concat(a.map(Bc)))),a}function qc(e){let t=Mc(e);return kc[t]+e.slice(t.length)}function Jc(e){return{top:e.top??0,right:e.right??0,bottom:e.bottom??0,left:e.left??0}}function Yc(e){return typeof e==`number`?{top:e,right:e,bottom:e,left:e}:Jc(e)}function Xc(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 Zc(e,t,n){let{reference:r,floating:i}=e,a=Ic(t),o=Lc(t),s=Fc(o),c=Mc(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=Nc(t);return m&&(p[o]+=f*(m===`end`?1:-1)*(n&&l?-1:1)),p}async function Qc(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=Yc(f),m=o[d?u===`floating`?`reference`:`floating`:u],h=Xc(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=Xc(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 $c=50,el=async(e,t,n)=>{let{placement:r=`bottom`,strategy:i=`absolute`,middleware:a=[],platform:o}=n,s=o.detectOverflow?o:{...o,detectOverflow:Qc},c=await(o.isRTL==null?void 0:o.isRTL(t)),l=await o.getElementRects({reference:e,floating:t,strategy:i}),{x:u,y:d}=Zc(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<$c&&(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}=Zc(l,f,c)),n=-1)}return{x:u,y:d,placement:f,strategy:i,middlewareData:m}},tl=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=Yc(u),f={x:n,y:r},p=Lc(i),m=Fc(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=wc(d[_],T),D=wc(d[v],T),O=C-h[m]-D,k=C/2-h[m]/2+w,A=Ac(E,k,O),ee=!c.arrow&&Nc(i)!=null&&k!==A&&a.reference[m]/2-(k<E?E:D)-h[m]/2<0,j=ee?k<E?k-E:k-O:0;return{[p]:f[p]+j,data:{[p]:A,centerOffset:k-A-j,...ee&&{alignmentOffset:j}},reset:ee}}}),nl=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=Mc(r),_=Ic(o),v=Mc(o)===o,y=await(s.isRTL==null?void 0:s.isRTL(c.floating)),b=d||(v||!m?[qc(o)]:zc(o)),x=p!==`none`;!d&&x&&b.push(...Kc(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=Rc(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`||_===Ic(t)||T.every(e=>Ic(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=Ic(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 rl(e,t){return{top:e.top-t.height,right:e.right-t.width,bottom:e.bottom-t.height,left:e.left-t.width}}function il(e){return Cc.some(t=>e[t]>=0)}var al=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=rl(await r.detectOverflow(t,{...a,elementContext:`reference`}),n.reference);return{data:{referenceHiddenOffsets:e,referenceHidden:il(e)}}}case`escaped`:{let e=rl(await r.detectOverflow(t,{...a,altBoundary:!0}),n.floating);return{data:{escapedOffsets:e,escaped:il(e)}}}default:return{}}}}},ol=new Set([`left`,`top`]);async function sl(e,t){let{placement:n,platform:r,elements:i}=e,a=await(r.isRTL==null?void 0:r.isRTL(i.floating)),o=Mc(n),s=Nc(n),c=Ic(n)===`y`,l=ol.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 cl=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 sl(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}}}}},ll=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=Ic(i),p=Pc(f),m=u[p],h=u[f],g=(e,t)=>Ac(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}}}}}},ul=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=Ic(i),f=Pc(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=ol.has(Mc(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}}}},dl=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=Mc(n),u=Nc(n),d=Ic(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=wc(p-c[m],g),y=wc(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*Tc(c.left,c.right):S=p-2*Tc(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 fl(){return typeof window<`u`}function pl(e){return hl(e)?(e.nodeName||``).toLowerCase():`#document`}function $(e){var t;return(e==null||(t=e.ownerDocument)==null?void 0:t.defaultView)||window}function ml(e){return((hl(e)?e.ownerDocument:e.document)||window.document)?.documentElement}function hl(e){return fl()?e instanceof Node||e instanceof $(e).Node:!1}function gl(e){return fl()?e instanceof Element||e instanceof $(e).Element:!1}function _l(e){return fl()?e instanceof HTMLElement||e instanceof $(e).HTMLElement:!1}function vl(e){return!fl()||typeof ShadowRoot>`u`?!1:e instanceof ShadowRoot||e instanceof $(e).ShadowRoot}function yl(e){let{overflow:t,overflowX:n,overflowY:r,display:i}=Al(e);return/auto|scroll|overlay|hidden|clip/.test(t+r+n)&&i!==`inline`&&i!==`contents`}function bl(e){return/^(table|td|th)$/.test(pl(e))}function xl(e){try{if(e.matches(`:popover-open`))return!0}catch{}try{return e.matches(`:modal`)}catch{return!1}}var Sl=/transform|translate|scale|rotate|perspective|filter/,Cl=/paint|layout|strict|content/,wl=e=>!!e&&e!==`none`,Tl;function El(e){let t=gl(e)?Al(e):e;return wl(t.transform)||wl(t.translate)||wl(t.scale)||wl(t.rotate)||wl(t.perspective)||!Ol()&&(wl(t.backdropFilter)||wl(t.filter))||Sl.test(t.willChange||``)||Cl.test(t.contain||``)}function Dl(e){let t=Ml(e);for(;_l(t)&&!kl(t);){if(El(t))return t;if(xl(t))return null;t=Ml(t)}return null}function Ol(){return Tl??=typeof CSS<`u`&&CSS.supports&&CSS.supports(`-webkit-backdrop-filter`,`none`),Tl}function kl(e){return/^(html|body|#document)$/.test(pl(e))}function Al(e){return $(e).getComputedStyle(e)}function jl(e){return gl(e)?{scrollLeft:e.scrollLeft,scrollTop:e.scrollTop}:{scrollLeft:e.scrollX,scrollTop:e.scrollY}}function Ml(e){if(pl(e)===`html`)return e;let t=e.assignedSlot||e.parentNode||vl(e)&&e.host||ml(e);return vl(t)?t.host:t}function Nl(e){let t=Ml(e);return kl(t)?(e.ownerDocument||e).body:_l(t)&&yl(t)?t:Nl(t)}function Pl(e,t,n){t===void 0&&(t=[]),n===void 0&&(n=!0);let r=Nl(e),i=r===e.ownerDocument?.body,a=$(r);if(i){let e=Fl(a);return t.concat(a,a.visualViewport||[],yl(r)?r:[],e&&n?Pl(e):[])}return t.concat(r,Pl(r,[],n))}function Fl(e){return e.parent&&Object.getPrototypeOf(e.parent)?e.frameElement:null}function Il(e){let t=Al(e),n=parseFloat(t.width)||0,r=parseFloat(t.height)||0,i=_l(e),a=i?e.offsetWidth:n,o=i?e.offsetHeight:r,s=Ec(n)!==a||Ec(r)!==o;return s&&(n=a,r=o),{width:n,height:r,$:s}}function Ll(e){return gl(e)?e:e.contextElement}function Rl(e){let t=Ll(e);if(!_l(t))return Oc(1);let n=t.getBoundingClientRect(),{width:r,height:i,$:a}=Il(t),o=(a?Ec(n.width):n.width)/r,s=(a?Ec(n.height):n.height)/i;return(!o||!Number.isFinite(o))&&(o=1),(!s||!Number.isFinite(s))&&(s=1),{x:o,y:s}}var zl=Oc(0);function Bl(e){let t=$(e);return!Ol()||!t.visualViewport?zl:{x:t.visualViewport.offsetLeft,y:t.visualViewport.offsetTop}}function Vl(e,t,n){return t===void 0&&(t=!1),!!n&&t&&n===$(e)}function Hl(e,t,n,r){t===void 0&&(t=!1),n===void 0&&(n=!1);let i=e.getBoundingClientRect(),a=Ll(e),o=Oc(1);t&&(r?gl(r)&&(o=Rl(r)):o=Rl(e));let s=Vl(a,n,r)?Bl(a):Oc(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=gl(r)?$(r):r,n=e,i=Fl(n);for(;i&&t!==n;){let e=Rl(i),t=i.getBoundingClientRect(),r=Al(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=Fl(n)}}return Xc({width:u,height:d,x:c,y:l})}function Ul(e,t){let n=jl(e).scrollLeft;return t?t.left+n:Hl(ml(e)).left+n}function Wl(e,t){let n=e.getBoundingClientRect();return{x:n.left+t.scrollLeft-Ul(e,n),y:n.top+t.scrollTop}}function Gl(e){let{elements:t,rect:n,offsetParent:r,strategy:i}=e,a=i===`fixed`,o=ml(r),s=t?xl(t.floating):!1;if(r===o||s&&a)return n;let c={scrollLeft:0,scrollTop:0},l=Oc(1),u=Oc(0),d=_l(r);if((d||!a)&&((pl(r)!==`body`||yl(o))&&(c=jl(r)),d)){let e=Hl(r);l=Rl(r),u.x=e.x+r.clientLeft,u.y=e.y+r.clientTop}let f=o&&!d&&!a?Wl(o,c):Oc(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 Kl(e){return e.getClientRects?Array.from(e.getClientRects()):[]}function ql(e){let t=jl(e),n=e.ownerDocument.body,r=Tc(e.scrollWidth,e.clientWidth,n.scrollWidth,n.clientWidth),i=Tc(e.scrollHeight,e.clientHeight,n.scrollHeight,n.clientHeight),a=-t.scrollLeft+Ul(e),o=-t.scrollTop;return Al(n).direction===`rtl`&&(a+=Tc(e.clientWidth,n.clientWidth)-r),{width:r,height:i,x:a,y:o}}var Jl=25;function Yl(e,t,n){n===void 0&&(n=`viewport`);let r=n===`layoutViewport`,i=$(e),a=ml(e),o=i.visualViewport,s=a.clientWidth,c=a.clientHeight,l=0,u=0;if(o){let e=!Ol()||t===`fixed`;r?e||(l=-o.offsetLeft,u=-o.offsetTop):(s=o.width,c=o.height,e&&(l=o.offsetLeft,u=o.offsetTop))}if(Ul(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<=Jl&&(s-=o)}return{width:s,height:c,x:l,y:u}}function Xl(e,t){let n=Hl(e,!0,t===`fixed`),r=n.top+e.clientTop,i=n.left+e.clientLeft,a=Rl(e);return{width:e.clientWidth*a.x,height:e.clientHeight*a.y,x:i*a.x,y:r*a.y}}function Zl(e,t,n){let r;if(t===`viewport`||t===`layoutViewport`)r=Yl(e,n,t);else if(t===`document`)r=ql(ml(e));else if(gl(t))r=Xl(t,n);else{let n=Bl(e);r={x:t.x-n.x,y:t.y-n.y,width:t.width,height:t.height}}return Xc(r)}function Ql(e,t){let n=t.get(e);if(n)return n;let r=Pl(e,[],!1).filter(e=>gl(e)&&pl(e)!==`body`),i=null,a=Al(e).position===`fixed`,o=a?Ml(e):e;for(;gl(o)&&!kl(o);){let e=Al(o),t=El(o),n=i?i.position:a?`fixed`:``;!t&&(n===`fixed`||n===`absolute`&&e.position===`static`)?r=r.filter(e=>e!==o):i=e,o=Ml(o)}return t.set(e,r),r}function $l(e){let{element:t,boundary:n,rootBoundary:r,strategy:i}=e,a=[...n===`clippingAncestors`?xl(t)?[]:Ql(t,this._c):[].concat(n),r],o=Zl(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=Zl(t,a[e],i);s=Tc(n.top,s),c=wc(n.right,c),l=wc(n.bottom,l),u=Tc(n.left,u)}return{width:c-u,height:l-s,x:u,y:s}}function eu(e){let{width:t,height:n}=Il(e);return{width:t,height:n}}function tu(e,t,n){let r=_l(t),i=ml(t),a=n===`fixed`,o=Hl(e,!0,a,t),s={scrollLeft:0,scrollTop:0},c=Oc(0);if((r||!a)&&((pl(t)!==`body`||yl(i))&&(s=jl(t)),r)){let e=Hl(t,!0,a,t);c.x=e.x+t.clientLeft,c.y=e.y+t.clientTop}!r&&i&&(c.x=Ul(i));let l=i&&!r&&!a?Wl(i,s):Oc(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 nu(e){return Al(e).position===`static`}function ru(e,t){if(!_l(e)||Al(e).position===`fixed`)return null;if(t)return t(e);let n=e.offsetParent;return ml(e)===n&&(n=n.ownerDocument.body),n}function iu(e,t){let n=$(e);if(xl(e))return n;if(!_l(e)){let t=Ml(e);for(;t&&!kl(t);){if(gl(t)&&!nu(t))return t;t=Ml(t)}return n}let r=ru(e,t);for(;r&&bl(r)&&nu(r);)r=ru(r,t);return r&&kl(r)&&nu(r)&&!El(r)?n:r||Dl(e)||n}var au=async function(e){let t=this.getOffsetParent||iu,n=this.getDimensions,r=await n(e.floating);return{reference:tu(e.reference,await t(e.floating),e.strategy),floating:{x:0,y:0,width:r.width,height:r.height}}};function ou(e){return Al(e).direction===`rtl`}var su={convertOffsetParentRelativeRectToViewportRelativeRect:Gl,getDocumentElement:ml,getClippingRect:$l,getOffsetParent:iu,getElementRects:au,getClientRects:Kl,getDimensions:eu,getScale:Rl,isElement:gl,isRTL:ou};function cu(e,t){return e.x===t.x&&e.y===t.y&&e.width===t.width&&e.height===t.height}function lu(e,t,n){let r=null,i,a=ml(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=Dc(d),h=Dc(a.clientWidth-(u+f)),g=Dc(a.clientHeight-(d+p)),_=Dc(u),v={rootMargin:-m+`px `+-h+`px `+-g+`px `+-_+`px`,threshold:Tc(0,wc(1,c))||1},y=!0;function b(t){let n=t[0].intersectionRatio;if(!cu(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 uu(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=Ll(e),u=i||a?[...l?Pl(l):[],...t?Pl(t):[]]:[];u.forEach(e=>{i&&e.addEventListener(`scroll`,n),a&&e.addEventListener(`resize`,n)});let d=l&&s?lu(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?Hl(e):null;c&&g();function g(){let t=Hl(e);h&&!cu(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 du=cl,fu=ll,pu=nl,mu=dl,hu=al,gu=tl,_u=ul,vu=(e,t,n)=>{let r=new Map,i=n??{},a={...su,...i.platform,_c:r};return el(e,t,{...i,platform:a})};function yu(e){return typeof e==`object`&&!!e&&`$el`in e}function bu(e){if(yu(e)){let t=e.$el;return hl(t)&&pl(t)===`#comment`?null:t}return e}function xu(e){return typeof e==`function`?e():P(e)}function Su(e){return{name:`arrow`,options:e,fn(t){let n=bu(xu(e.element));return n==null?{}:gu({element:n,padding:e.padding}).fn(t)}}}function Cu(e){return typeof window>`u`?1:(e.ownerDocument.defaultView||window).devicePixelRatio||1}function wu(e,t){let n=Cu(e);return Math.round(t*n)/n}function Tu(e,t,n){n===void 0&&(n={});let r=n.whileElementsMounted,i=x(()=>xu(n.open)??!0),a=x(()=>xu(n.middleware)),o=x(()=>xu(n.placement)??`bottom`),s=x(()=>xu(n.strategy)??`absolute`),c=x(()=>xu(n.transform)??!0),l=x(()=>bu(e.value)),u=x(()=>bu(t.value)),d=j(0),f=j(0),m=j(s.value),h=j(o.value),_=Ae({}),v=j(!1),y=x(()=>{let e={position:m.value,left:`0`,top:`0`};if(!u.value)return e;let t=wu(u.value,d.value),n=wu(u.value,f.value);return c.value?{...e,transform:`translate(`+t+`px, `+n+`px)`,...Cu(u.value)>=1.5&&{willChange:`transform`}}:{position:m.value,left:t+`px`,top:n+`px`}}),b;function S(){if(l.value==null||u.value==null)return;let e=i.value;vu(l.value,u.value,{middleware:a.value,placement:o.value,strategy:s.value}).then(t=>{d.value=t.x,f.value=t.y,m.value=t.strategy,h.value=t.placement,_.value=t.middlewareData,v.value=e!==!1})}function C(){typeof b==`function`&&(b(),b=void 0)}function w(){if(C(),r===void 0){S();return}if(l.value!=null&&u.value!=null){b=r(l.value,u.value,S);return}}function T(){i.value||(v.value=!1)}return N([a,o,s,i],S,{flush:`sync`}),N([l,u],w,{flush:`sync`}),N(i,T,{flush:`sync`}),Ee()&&g(C),{x:p(d),y:p(f),strategy:p(m),placement:p(h),middlewareData:p(_),isPositioned:p(v),floatingStyles:y,update:S}}var Eu=[`dir`],Du={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},[Ou,ku]=r(`PopperContent`),Au=H({inheritAttrs:!1,__name:`PopperContent`,props:ye({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}},{...Du}),emits:[`placed`],setup(t,{emit:n}){let r=t,i=n,o=gc(),{forwardRef:s,currentElement:c}=e(),l=a(x(()=>r.dir)),u=j(),f=j(),{width:p,height:h}=Ls(f),g=x(()=>r.side+(r.align===`center`?``:`-${r.align}`)),_=x(()=>typeof r.collisionPadding==`number`?r.collisionPadding:{top:0,right:0,bottom:0,left:0,...r.collisionPadding}),v=x(()=>Array.isArray(r.collisionBoundary)?r.collisionBoundary:[r.collisionBoundary]),y=x(()=>({padding:_.value,boundary:v.value.filter(bc),altBoundary:v.value.length>0})),b=x(()=>({mainAxis:r.sideFlip,crossAxis:r.alignFlip})),S=x(()=>[du({mainAxis:r.sideOffset+h.value,alignmentAxis:r.alignOffset}),r.prioritizePosition&&r.avoidCollisions&&pu({...y.value,...b.value}),r.avoidCollisions&&fu({mainAxis:!0,crossAxis:!!r.prioritizePosition,limiter:r.sticky===`partial`?_u():void 0,...y.value}),!r.prioritizePosition&&r.avoidCollisions&&pu({...y.value,...b.value}),mu({...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`)}}),f.value&&Su({element:f.value,padding:r.arrowPadding}),xc({arrowWidth:p.value,arrowHeight:h.value,dir:l.value}),r.hideWhenDetached&&hu({strategy:`referenceHidden`,...y.value})]),{floatingStyles:C,placement:w,isPositioned:T,middlewareData:E,update:D}=Tu(x(()=>r.reference??o.anchor.value),u,{strategy:r.positionStrategy,placement:g,whileElementsMounted:(...e)=>uu(...e,{layoutShift:!r.disableUpdateOnLayoutShift,animationFrame:r.updatePositionStrategy===`always`}),middleware:S}),O=x(()=>Sc(w.value)[0]),k=x(()=>Sc(w.value)[1]);Se(()=>{T.value&&i(`placed`)});let A=x(()=>{let e=E.value.arrow?.centerOffset!==0;return r.hideShiftedArrow&&e}),ee=j(``);return d(()=>{c.value&&(ee.value=window.getComputedStyle(c.value).zIndex)}),ku({placedSide:O,onArrowChange:e=>f.value=e,arrowX:x(()=>E.value.arrow?.x??0),arrowY:x(()=>E.value.arrow?.y??0),shouldHideArrow:A}),(e,t)=>(V(),m(`div`,{ref_key:`floatingRef`,ref:u,"data-reka-popper-content-wrapper":``,dir:P(l),style:Ke({...P(C),transform:P(T)?P(C).transform:`translate(0, -200%)`,minWidth:`max-content`,zIndex:ee.value,"--reka-popper-transform-origin":[P(E).transformOrigin?.x,P(E).transformOrigin?.y].join(` `),...P(E).hide?.referenceHidden&&{visibility:`hidden`,pointerEvents:`none`}})},[r.memoDependencies?Re([r.asChild,r.as,O.value,k.value,P(T),...Object.values(e.$attrs),...r.memoDependencies],()=>(V(),M(P(B),z({key:0,ref:P(s)},e.$attrs,{"as-child":r.asChild,as:r.as,"data-side":O.value,"data-align":k.value,style:{animation:P(T)?void 0:`none`}}),{default:R(()=>[I(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`style`])),t,0):(V(),M(P(B),z({key:1,ref:P(s)},e.$attrs,{"as-child":r.asChild,as:r.as,"data-side":O.value,"data-align":k.value,dir:P(l),style:{animation:P(T)?void 0:`none`}}),{default:R(()=>[I(e.$slots,`default`)]),_:3},16,[`as-child`,`as`,`data-side`,`data-align`,`dir`,`style`]))],12,Eu))}});function ju(e){let t=s({nonce:j()});return x(()=>e?.value||t.nonce?.value)}var Mu=[` `,`Enter`,`ArrowUp`,`ArrowDown`],Nu=[` `,`Enter`];function Pu(e,t,n){return e===void 0?!1:Array.isArray(e)?e.some(e=>Fu(e,t,n)):Fu(e,t,n)}function Fu(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]:l(e,t)}function Iu(e){return e==null||e===``||Array.isArray(e)&&e.length===0}var Lu=[`value`],[Ru,zu]=r(`SelectRoot`),Bu=H({inheritAttrs:!1,__name:`SelectRoot`,props:{open:{type:Boolean,required:!1,default:void 0},defaultOpen:{type:Boolean,required:!1},defaultValue:{type:null,required:!1},modelValue:{type:null,required:!1,default:void 0},nullableValue:{type:String,required:!1,default:``},by:{type:[String,Function],required:!1},dir:{type:String,required:!1},multiple:{type:Boolean,required:!1},autocomplete:{type:String,required:!1},disabled:{type:Boolean,required:!1},name:{type:String,required:!1},required:{type:Boolean,required:!1}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:n}){let r=e,i=n,{required:o,disabled:s,multiple:c,dir:l}=S(r),u=at(r,`modelValue`,i,{defaultValue:r.defaultValue??(c.value?[]:void 0),passive:r.modelValue===void 0,deep:!0}),d=at(r,`open`,i,{defaultValue:r.defaultOpen,passive:r.open===void 0}),p=j(),h=j(),g=j({x:0,y:0}),_=x(()=>c.value&&Array.isArray(u.value)?u.value?.length===0:t(u.value));mc({isProvider:!0});let v=a(l),y=Es(p),b=j(new Set),C=x(()=>Array.from(b.value).map(e=>e.value).join(`;`));function w(e){if(c.value){let t=Array.isArray(u.value)?[...u.value]:[],n=t.findIndex(t=>Fu(t,e,r.by));n===-1?t.push(e):t.splice(n,1),u.value=[...t]}else u.value=e}function T(e){return Array.from(b.value).find(t=>Pu(e,t.value,r.by))}return zu({triggerElement:p,onTriggerChange:e=>{p.value=e},valueElement:h,onValueElementChange:e=>{h.value=e},contentId:``,modelValue:u,onValueChange:w,by:r.by,open:d,multiple:c,required:o,onOpenChange:e=>{d.value=e},dir:v,triggerPointerDownPosRef:g,disabled:s,isEmptyModelValue:_,optionsSet:b,onOptionAdd:e=>{let t=T(e.value);t&&b.value.delete(t),b.value.add(e)},onOptionRemove:e=>{let t=T(e.value);t&&b.value.delete(t)}}),(e,n)=>(V(),M(P(vc),null,{default:R(()=>[I(e.$slots,`default`,{modelValue:P(u),open:P(d)}),P(y)&&e.name?(V(),M(Vu,{key:C.value,"aria-hidden":`true`,tabindex:`-1`,multiple:P(c),required:P(o),name:e.name,autocomplete:e.autocomplete,disabled:P(s),value:P(u)},{default:R(()=>[P(t)(P(u))?(V(),m(`option`,{key:0,value:e.nullableValue},null,8,Lu)):L(`v-if`,!0),(V(!0),m(we,null,f(Array.from(b.value),e=>(V(),m(`option`,z({key:e.value??``},{ref_for:!0},e),null,16))),128))]),_:1},8,[`multiple`,`required`,`name`,`autocomplete`,`disabled`,`value`])):L(`v-if`,!0)]),_:3}))}}),Vu=H({__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=j(),r=Ru();N(()=>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)=>(V(),M(P(hc),{"as-child":``},{default:R(()=>[v(`select`,z({ref_key:`selectElement`,ref:n},t,{onInput:i}),[I(e.$slots,`default`)],16)]),_:3}))}}),Hu=H({__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=n(e);return(e,n)=>(V(),M(P(Au),z(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(()=>[I(e.$slots,`default`)]),_:3},16))}}),Uu={onViewportChange:()=>{},itemTextRefCallback:()=>{},itemRefCallback:()=>{}},[Wu,Gu]=r(`SelectContent`),Ku=H({__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 r=e,i=t,a=Ru();ws(),bs(r.bodyLock);let{CollectionSlot:o,getItems:s}=mc(),c=j();Is(c);let{search:l,handleTypeaheadSearch:u}=Rs(),f=j(),p=j(),m=j(),h=j(!1),g=j(!1),_=j(!1);function v(){p.value&&c.value&&dc([p.value,c.value])}N(h,()=>{v()});let{onOpenChange:y,triggerPointerDownPosRef:b}=a;d(e=>{if(!c.value)return;let t={x:0,y:0},n=e=>{t={x:Math.abs(Math.round(e.pageX)-(b.value?.x??0)),y:Math.abs(Math.round(e.pageY)-(b.value?.y??0))}},r=e=>{e.pointerType!==`touch`&&(t.x<=10&&t.y<=10?e.preventDefault():c.value?.contains(e.target)||y(!1),document.removeEventListener(`pointermove`,n),b.value=null)};b.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 S(e){let t=e.ctrlKey||e.altKey||e.metaKey;if(e.key===`Tab`&&e.preventDefault(),!t&&e.key.length===1&&u(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(()=>dc(t)),e.preventDefault()}}let C=x(()=>r.position===`popper`?r:{}),w=n(C.value);return Gu({content:c,viewport:f,onViewportChange:e=>{f.value=e},itemRefCallback:(e,t,n)=>{let r=!g.value&&!n,i=Pu(a.modelValue.value,t,a.by);if(a.multiple.value){if(_.value)return;(i||r)&&(p.value=e,i&&(_.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;(Pu(a.modelValue.value,t,a.by)||r)&&(m.value=e)},focusSelectedItem:v,position:r.position,isPositioned:h,searchRef:l}),(e,t)=>(V(),M(P(o),null,{default:R(()=>[O(P(sc),{"as-child":``,onMountAutoFocus:t[6]||=Ze(()=>{},[`prevent`]),onUnmountAutoFocus:t[7]||=e=>{i(`closeAutoFocus`,e),!e.defaultPrevented&&(P(a).triggerElement.value?.focus({preventScroll:!0}),e.preventDefault())}},{default:R(()=>[O(P(qs),{"as-child":``,"disable-outside-pointer-events":e.disableOutsidePointerEvents,onFocusOutside:t[2]||=Ze(()=>{},[`prevent`]),onDismiss:t[3]||=e=>P(a).onOpenChange(!1),onEscapeKeyDown:t[4]||=e=>i(`escapeKeyDown`,e),onPointerDownOutside:t[5]||=e=>i(`pointerDownOutside`,e)},{default:R(()=>[(V(),M(ne(e.position===`popper`?Hu:Yu),z({...e.$attrs,...P(w)},{id:P(a).contentId,ref:e=>{if(!e)return;let t=P(et)(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]||=Ze(()=>{},[`prevent`]),onPlaced:t[1]||=e=>h.value=!0,onKeydown:S}),{default:R(()=>[I(e.$slots,`default`)]),_:3},16,[`id`,`data-state`,`dir`,`onKeydown`]))]),_:3},8,[`disable-outside-pointer-events`])]),_:3})]),_:3}))}}),[qu,Ju]=r(`SelectItemAlignedPosition`),Yu=H({inheritAttrs:!1,__name:`SelectItemAlignedPosition`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`placed`],setup(t,{emit:n}){let r=t,i=n,{getItems:a}=mc(),o=Ru(),s=Wu(),c=j(!1),l=j(!0),u=j(),{forwardRef:d,currentElement:f}=e(),{viewport:p,selectedItem:h,selectedItemText:g,focusSelectedItem:_}=s;function v(){if(o.triggerElement.value&&o.valueElement.value&&u.value&&f.value&&p?.value&&h?.value&&g?.value){let e=o.triggerElement.value.getBoundingClientRect(),t=f.value.getBoundingClientRect(),n=o.valueElement.value.getBoundingClientRect(),r=g.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=ps(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=ps(a,10,Math.max(10,l-c));u.value.style.minWidth=`${s}px`,u.value.style.right=`${d}px`}let s=a().map(e=>e.ref),l=window.innerHeight-20,d=p.value.scrollHeight,m=window.getComputedStyle(f.value),_=Number.parseInt(m.borderTopWidth,10),v=Number.parseInt(m.paddingTop,10),y=Number.parseInt(m.borderBottomWidth,10),b=Number.parseInt(m.paddingBottom,10),x=_+v+d+b+y,S=Math.min(h.value.offsetHeight*5,x),C=window.getComputedStyle(p.value),w=Number.parseInt(C.paddingTop,10),T=Number.parseInt(C.paddingBottom,10),E=e.top+e.height/2-10,D=l-E,O=h.value.offsetHeight/2,k=h.value.offsetTop+O,A=_+v+k,ee=x-A;if(A<=E){let e=h.value===s.at(-1);u.value.style.bottom=`0px`;let t=f.value.clientHeight-p.value.offsetTop-p.value.offsetHeight,n=A+Math.max(D,O+(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,_+p.value.offsetTop+(e?w:0)+O)+ee;u.value.style.height=`${t}px`,p.value.scrollTop=A-E+p.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 y=j(``);qe(async()=>{await F(),v(),f.value&&(y.value=window.getComputedStyle(f.value).zIndex)});function b(e){e&&l.value===!0&&(v(),_?.(),l.value=!1)}return tt(o.triggerElement,()=>{v()}),Ju({contentWrapper:u,shouldExpandOnScrollRef:c,onScrollButtonChange:b}),(e,t)=>(V(),m(`div`,{ref_key:`contentWrapperElement`,ref:u,style:Ke({display:`flex`,flexDirection:`column`,position:`fixed`,zIndex:y.value})},[O(P(B),z({ref:P(d),style:{boxSizing:`border-box`,maxHeight:`100%`}},{...e.$attrs,...r}),{default:R(()=>[I(e.$slots,`default`)]),_:3},16)],4))}}),Xu=H({inheritAttrs:!1,__name:`SelectProvider`,props:{context:{type:Object,required:!0}},setup(e){return zu(e.context),Gu(Uu),(e,t)=>I(e.$slots,`default`)}}),Zu={key:1},Qu=H({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 n=e,r=o(n,t),i=Ru(),a=j();qe(()=>{a.value=new DocumentFragment});let s=j(),l=x(()=>n.forceMount||i.open.value),u=j(l.value),d;function f(){d&&=(clearTimeout(d),void 0)}return N(l,(e,t,n)=>{f(),d=setTimeout(()=>{u.value=l.value,d=void 0}),n(f)}),oe(f),(e,t)=>l.value||u.value||s.value?.present?(V(),M(P(c),{key:0,ref_key:`presenceRef`,ref:s,present:l.value},{default:R(()=>[O(Ku,Ne(fe({...P(r),...e.$attrs})),{default:R(()=>[I(e.$slots,`default`)]),_:3},16)]),_:3},8,[`present`])):a.value?(V(),m(`div`,Zu,[(V(),M(_e,{to:a.value},[O(Xu,{context:P(i)},{default:R(()=>[I(e.$slots,`default`)]),_:3},8,[`context`])],8,[`to`]))])):L(`v-if`,!0)}}),$u=H({__name:`SelectIcon`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){return(e,t)=>(V(),M(P(B),{"aria-hidden":`true`,as:e.as,"as-child":e.asChild},{default:R(()=>[I(e.$slots,`default`,{},()=>[t[0]||=D(`▼`)])]),_:3},8,[`as`,`as-child`]))}}),[ed,td]=r(`SelectItem`),nd=H({__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(t,{emit:n}){let r=t,a=n,{disabled:o}=S(r),s=Ru(),c=Wu(),{forwardRef:l,currentElement:u}=e(),{CollectionItem:d}=mc(),f=x(()=>Pu(s.modelValue?.value,r.value,s.by)),p=j(!1),m=j(r.textValue??``),h=i(void 0,`reka-select-item-text`);async function g(e){e.defaultPrevented||ms(`select.select`,_,{originalEvent:e,value:r.value})}async function _(e){await F(),a(`select`,e),!e.defaultPrevented&&(o.value||(s.onValueChange(r.value),s.multiple.value||s.onOpenChange(!1)))}async function v(e){await F(),!e.defaultPrevented&&(o.value?c.onItemLeave?.():e.currentTarget?.focus({preventScroll:!0}))}async function y(e){await F(),!e.defaultPrevented&&e.currentTarget===Z()&&c.onItemLeave?.()}async function b(e){await F(),!e.defaultPrevented&&(c.searchRef?.value===``||e.key!==` `)&&(Nu.includes(e.key)&&g(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 qe(()=>{u.value&&c.itemRefCallback(u.value,r.value,r.disabled)}),td({value:r.value,disabled:o,textId:h,isSelected:f,onItemTextChange:e=>{m.value=((m.value||e?.textContent)??``).trim()}}),(e,t)=>(V(),M(P(d),{value:{textValue:m.value}},{default:R(()=>[O(P(B),{ref:P(l),role:`option`,"aria-labelledby":P(h),"data-highlighted":p.value?``:void 0,"aria-selected":f.value,"data-state":f.value?`checked`:`unchecked`,"aria-disabled":P(o)||void 0,"data-disabled":P(o)?``:void 0,tabindex:P(o)?void 0:-1,as:e.as,"as-child":e.asChild,onFocus:t[0]||=e=>p.value=!0,onBlur:t[1]||=e=>p.value=!1,onPointerup:g,onPointerdown:t[2]||=e=>{e.currentTarget.focus({preventScroll:!0})},onTouchend:t[3]||=Ze(()=>{},[`prevent`,`stop`]),onPointermove:v,onPointerleave:y,onKeydown:b},{default:R(()=>[I(e.$slots,`default`)]),_:3},8,[`aria-labelledby`,`data-highlighted`,`aria-selected`,`data-state`,`aria-disabled`,`data-disabled`,`tabindex`,`as`,`as-child`])]),_:3},8,[`value`]))}}),rd=H({__name:`SelectItemIndicator`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(e){let t=e,n=ed();return(e,r)=>P(n).isSelected.value?(V(),M(P(B),z({key:0,"aria-hidden":`true`},t),{default:R(()=>[I(e.$slots,`default`)]),_:3},16)):L(`v-if`,!0)}}),id=H({inheritAttrs:!1,__name:`SelectItemText`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(t){let n=t,r=Ru(),i=Wu(),a=ed(),{forwardRef:o,currentElement:s}=e(),c=x(()=>({value:a.value,disabled:a.disabled.value,textContent:s.value?.textContent??a.value?.toString()??``}));return qe(()=>{s.value&&(a.onItemTextChange(s.value),i.itemTextRefCallback(s.value,a.value,a.disabled.value),r.onOptionAdd(c.value))}),oe(()=>{r.onOptionRemove(c.value)}),(e,t)=>(V(),M(P(B),z({id:P(a).textId,ref:P(o)},{...n,...e.$attrs}),{default:R(()=>[I(e.$slots,`default`)]),_:3},16,[`id`]))}}),ad=H({__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)=>(V(),M(P(fc),Ne(fe(t)),{default:R(()=>[I(e.$slots,`default`)]),_:3},16))}}),od=H({__name:`SelectScrollButtonImpl`,emits:[`autoScroll`],setup(e,{emit:t}){let n=t,{getItems:r}=mc(),i=Wu(),a=j(null);function o(){a.value!==null&&(window.clearInterval(a.value),a.value=null)}d(()=>{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 Ie(()=>o()),(e,t)=>(V(),M(P(B),z({"aria-hidden":`true`,style:{flexShrink:0}},e.$parent?.$props,{onPointerdown:s,onPointermove:c,onPointerleave:t[0]||=()=>{o()}}),{default:R(()=>[I(e.$slots,`default`)]),_:3},16))}}),sd=H({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(t){let n=Wu(),r=n.position===`item-aligned`?qu():void 0,{forwardRef:i,currentElement:a}=e(),o=j(!1);return d(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))}}),N(a,()=>{a.value&&r?.onScrollButtonChange(a.value)}),(e,t)=>o.value?(V(),M(od,{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(()=>[I(e.$slots,`default`)]),_:3},512)):L(`v-if`,!0)}}),cd=H({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(t){let n=Wu(),r=n.position===`item-aligned`?qu():void 0,{forwardRef:i,currentElement:a}=e(),o=j(!1);return d(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))}}),N(a,()=>{a.value&&r?.onScrollButtonChange(a.value)}),(e,t)=>o.value?(V(),M(od,{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(()=>[I(e.$slots,`default`)]),_:3},512)):L(`v-if`,!0)}}),ld=H({__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(t){let n=t,r=Ru(),{forwardRef:a,currentElement:o}=e(),s=x(()=>r.disabled?.value||n.disabled);r.contentId||=i(void 0,`reka-select-content`),qe(()=>{r.onTriggerChange(o.value)});let{getItems:c}=mc(),{search:l,handleTypeaheadSearch:u,resetTypeahead:d}=Rs();function f(){s.value||(r.onOpenChange(!0),d())}function p(e){f(),r.triggerPointerDownPosRef.value={x:Math.round(e.pageX),y:Math.round(e.pageY)}}function m(e){return e.button===0&&e.ctrlKey===!1}let h=!1;function g(e){if(e.pointerType===`touch`)return e.preventDefault();let t=e.target;t.hasPointerCapture(e.pointerId)&&t.releasePointerCapture(e.pointerId),m(e)&&(p(e),h=!0)}function _(e){m(e)&&e.preventDefault()}function v(e){h||e.currentTarget?.focus(),h=!1}return(e,t)=>(V(),M(P(yc),{"as-child":``,reference:e.reference},{default:R(()=>[O(P(B),{ref:P(a),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(Iu)(P(r).modelValue?.value)?``:void 0,"as-child":e.asChild,as:e.as,onClick:v,onPointerdown:g,onMousedown:_,onPointerup:t[0]||=Ze(e=>{e.pointerType===`touch`&&p(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(Mu).includes(e.key)&&(f(),e.preventDefault()))}},{default:R(()=>[I(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`]))}}),ud=H({__name:`SelectValue`,props:{placeholder:{type:String,required:!1,default:``},asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`span`}},setup(t){let n=t,{forwardRef:r,currentElement:i}=e(),a=Ru();qe(()=>{a.valueElement=i});let o=x(()=>{let e=[],t=Array.from(a.optionsSet.value),n=e=>t.find(t=>Pu(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=x(()=>o.value.length?o.value.join(`, `):n.placeholder);return(e,t)=>(V(),M(P(B),{ref:P(r),as:e.as,"as-child":e.asChild,style:{pointerEvents:`none`},"data-placeholder":o.value.length?void 0:n.placeholder},{default:R(()=>[I(e.$slots,`default`,{selectedLabel:o.value,modelValue:P(a).modelValue.value},()=>[D(xe(s.value),1)])]),_:3},8,[`as`,`as-child`,`data-placeholder`]))}}),dd=H({__name:`SelectViewport`,props:{nonce:{type:String,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(t){let n=t,{nonce:r}=S(n),i=ju(r),a=Wu(),o=a.position===`item-aligned`?qu():void 0,{forwardRef:s,currentElement:c}=e();qe(()=>{a?.onViewportChange(c.value)});let l=j(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)=>(V(),m(we,null,[O(P(B),z({ref:P(s),"data-reka-select-viewport":``,role:`presentation`},{...e.$attrs,...n},{style:{position:`relative`,flex:1,overflow:`hidden auto`},onScroll:u}),{default:R(()=>[I(e.$slots,`default`)]),_:3},16),O(P(B),{as:`style`,nonce:P(i)},{default:R(()=>t[0]||=[D(` /* 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))}}),fd=H({__name:`Input`,props:{defaultValue:{},modelValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=at(n,`modelValue`,t,{passive:!0,defaultValue:n.defaultValue});return(e,t)=>me((V(),m(`input`,{"onUpdate:modelValue":t[0]||=e=>ge(r)?r.value=e:null,"data-slot":`input`,class:Ue(P(Xe)(`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)),[[Qe,P(r)]])}}),pd={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`},hd={class:`flex flex-col items-center gap-1`},gd={"aria-labelledby":`authgate-security-heading`,class:`flex flex-col gap-1.5 text-xs text-muted-foreground`},_d={class:`flex items-start gap-1.5`},vd={class:`flex items-start gap-1.5`},yd={class:`flex items-start gap-1.5`},bd={class:`relative`},xd=((e,t)=>{let n=e.__vccOpts||e;for(let[e,r]of t)n[e]=r;return n})(H({__name:`AuthGate`,setup(e){let t=Ye(),n=Te(),r=j(``),i=j(!1),a=j(null),o=x(()=>r.value.trim()!==``);function s(){let e=r.value;r.value=``,t.submit(e),n.refresh()}function c(){F(()=>a.value?.$el?.focus())}return qe(c),N(()=>t.error,e=>{e&&c()}),(e,n)=>{let c=k(`FontAwesomeIcon`);return V(),m(`div`,pd,[O(P(h),null,{default:R(()=>[O(P(Je),{class:`flex flex-col items-center gap-3 text-center`},{default:R(()=>[v(`div`,md,[O(c,{icon:P(Ge),class:`size-5`,"aria-hidden":`true`},null,8,[`icon`])]),v(`div`,hd,[n[3]||=v(`span`,{class:`text-xs font-medium text-muted-foreground`},`LLM Gateway`,-1),O(P(he),{class:`text-lg font-semibold`},{default:R(()=>[...n[2]||=[D(`Admin key required`,-1)]]),_:1})]),O(P(lt),null,{default:R(()=>[...n[4]||=[D(`Enter an admin API key to continue.`,-1)]]),_:1})]),_:1}),O(P(ae),{class:`flex flex-col gap-4`},{default:R(()=>[n[10]||=v(`h2`,{id:`authgate-security-heading`,class:`sr-only`},` How this key is handled `,-1),v(`ul`,gd,[v(`li`,_d,[O(c,{icon:P(le),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[5]||=v(`span`,null,`Kept only in this tab's session storage`,-1)]),v(`li`,vd,[O(c,{icon:P(le),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[6]||=v(`span`,null,`Never written to disk`,-1)]),v(`li`,yd,[O(c,{icon:P(le),class:`mt-0.5 size-3 shrink-0`,"aria-hidden":`true`},null,8,[`icon`]),n[7]||=v(`span`,null,`Sent only to this page's own /admin/api/* requests`,-1)])]),v(`form`,{class:`flex flex-col gap-3`,onSubmit:Ze(s,[`prevent`])},[v(`div`,bd,[O(P(fd),{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:Ue([`h-10 pr-10`,{"authgate-shake":P(t).error}])},null,8,[`modelValue`,`type`,`aria-invalid`,`aria-describedby`,`class`]),O(P(ot),{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:R(()=>[O(c,{icon:i.value?P(u):P(re),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`aria-label`])]),O(P(ot),{type:`submit`,class:`w-full`,disabled:!o.value},{default:R(()=>[...n[8]||=[D(` Continue `,-1)]]),_:1},8,[`disabled`])],32),P(t).error?(V(),M(P(nt),{key:0,id:`authgate-error`,variant:`destructive`},{default:R(()=>[O(P(fs),null,{default:R(()=>[...n[9]||=[D(`Authentication failed`,-1)]]),_:1}),O(P(ut),null,{default:R(()=>[D(xe(P(t).error),1)]),_:1})]),_:1})):L(``,!0)]),_:1})]),_:1})])}}}),[[`__scopeId`,`data-v-4be6bc09`]]),Sd={class:`mt-1 list-disc space-y-0.5 pl-4 font-mono text-xs`},Cd={key:0,class:`mt-1 text-xs`},wd=H({__name:`ConfigWarningsBanner`,props:{warnings:{},warningsDropped:{}},setup(e){let t=e,n=j(!1);function r(){n.value=!n.value}return(e,i)=>{let a=k(`FontAwesomeIcon`);return t.warnings.length>0?(V(),M(P(nt),{key:0,variant:`warn`},{default:R(()=>[O(a,{icon:P(ze),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`]),O(P(fs),{class:`flex items-center justify-between gap-2`},{default:R(()=>[v(`span`,null,xe(t.warnings.length)+` configuration `+xe(t.warnings.length===1?`warning`:`warnings`),1),O(P(ot),{type:`button`,variant:`ghost`,size:`xs`,"aria-expanded":n.value,"aria-label":`${n.value?`Hide`:`Show`} configuration warning details`,onClick:r},{default:R(()=>[D(xe(n.value?`Hide`:`Show`),1)]),_:1},8,[`aria-expanded`,`aria-label`])]),_:1}),n.value?(V(),M(P(ut),{key:0},{default:R(()=>[v(`ul`,Sd,[(V(!0),m(we,null,f(t.warnings,(e,t)=>(V(),m(`li`,{key:t},xe(e),1))),128))]),t.warningsDropped?(V(),m(`p`,Cd,`and `+xe(t.warningsDropped)+` more were not kept`,1)):L(``,!0)]),_:1})):L(``,!0)]),_:1})):L(``,!0)}}}),Td=H({__name:`Select`,props:{open:{type:Boolean},defaultOpen:{type:Boolean},defaultValue:{},modelValue:{},nullableValue:{},by:{type:[String,Function]},dir:{},multiple:{type:Boolean},autocomplete:{},disabled:{type:Boolean},name:{},required:{type:Boolean}},emits:[`update:modelValue`,`update:open`],setup(e,{emit:t}){let n=o(e,t);return(e,t)=>(V(),M(P(Bu),z({"data-slot":`select`},P(n)),{default:R(t=>[I(e.$slots,`default`,Ne(fe(t)))]),_:3},16))}}),Ed=H({inheritAttrs:!1,__name:`SelectContent`,props:{forceMount:{type:Boolean},position:{default:`item-aligned`},bodyLock:{type:Boolean},memoDependencies:{},side:{},sideOffset:{},sideFlip:{type:Boolean},align:{default:`center`},alignOffset:{},alignFlip:{type:Boolean},avoidCollisions:{type:Boolean},collisionBoundary:{},collisionPadding:{},arrowPadding:{},hideShiftedArrow:{type:Boolean},sticky:{},hideWhenDetached:{type:Boolean},positionStrategy:{},updatePositionStrategy:{},disableUpdateOnLayoutShift:{type:Boolean},prioritizePosition:{type:Boolean},reference:{},dir:{},asChild:{type:Boolean},as:{},disableOutsidePointerEvents:{type:Boolean},class:{type:[Boolean,null,String,Object,Array]}},emits:[`closeAutoFocus`,`escapeKeyDown`,`pointerDownOutside`],setup(e,{emit:t}){let n=e,r=t,i=A(n,`class`),a=o(i,r);return(t,r)=>(V(),M(P(ad),null,{default:R(()=>[O(P(Qu),z({"data-slot":`select-content`,"data-align-trigger":e.position===`item-aligned`},{...t.$attrs,...P(a)},{class:P(Xe)(`bg-popover text-popover-foreground data-open:animate-in data-closed:animate-out data-closed:fade-out-0 data-open:fade-in-0 data-closed:zoom-out-95 data-open:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 ring-foreground/10 min-w-36 rounded-lg shadow-md ring-1 duration-100 data-[side=inline-start]:slide-in-from-right-2 data-[side=inline-end]:slide-in-from-left-2 cn-menu-translucent relative z-50 max-h-(--reka-select-content-available-height) origin-(--reka-select-content-transform-origin) overflow-x-hidden overflow-y-auto data-[align-trigger=true]:animate-none`,e.position===`popper`&&`data-[side=bottom]:translate-y-1 data-[side=left]:-translate-x-1 data-[side=right]:translate-x-1 data-[side=top]:-translate-y-1`,n.class)}),{default:R(()=>[O(P(Ad)),O(P(dd),{"data-position":e.position,class:Ue(P(Xe)(`data-[position=popper]:h-(--reka-select-trigger-height) data-[position=popper]:w-full data-[position=popper]:min-w-(--reka-select-trigger-width)`))},{default:R(()=>[I(t.$slots,`default`)]),_:3},8,[`data-position`,`class`]),O(P(kd))]),_:3},16,[`data-align-trigger`,`class`])]),_:3}))}}),Dd={class:`pointer-events-none absolute right-2 flex size-4 items-center justify-center`},Od=H({__name:`SelectItem`,props:{value:{},disabled:{type:Boolean},textValue:{},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,r=A(t,`class`),i=n(r);return(e,n)=>(V(),M(P(nd),z({"data-slot":`select-item`},P(i),{class:P(Xe)(`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:R(()=>[v(`span`,Dd,[O(P(rd),null,{default:R(()=>[I(e.$slots,`indicator-icon`,{},()=>[O(P(us),{icon:P(le),class:`pointer-events-none size-3.5`},null,8,[`icon`])])]),_:3})]),O(P(id),null,{default:R(()=>[I(e.$slots,`default`)]),_:3})]),_:3},16,[`class`]))}}),kd=H({__name:`SelectScrollDownButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,r=A(t,`class`),i=n(r);return(e,n)=>(V(),M(P(sd),z({"data-slot":`select-scroll-down-button`},P(i),{class:P(Xe)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:R(()=>[I(e.$slots,`default`,{},()=>[O(P(us),{icon:P(C),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),Ad=H({__name:`SelectScrollUpButton`,props:{asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,r=A(t,`class`),i=n(r);return(e,n)=>(V(),M(P(cd),z({"data-slot":`select-scroll-up-button`},P(i),{class:P(Xe)(`bg-popover z-10 flex cursor-default items-center justify-center py-1 [&_svg:not([class*=size-])]:size-4`,t.class)}),{default:R(()=>[I(e.$slots,`default`,{},()=>[O(P(us),{icon:P(Ve),class:`size-4`},null,8,[`icon`])])]),_:3},16,[`class`]))}}),jd=H({__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,r=A(t,`class`,`size`),i=n(r);return(n,r)=>(V(),M(P(ld),z({"data-slot":`select-trigger`,"data-size":e.size},P(i),{class:P(Xe)(`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(()=>[I(n.$slots,`default`),O(P($u),{"as-child":``},{default:R(()=>[O(P(us),{icon:P(C),class:`text-muted-foreground size-4 pointer-events-none`},null,8,[`icon`])]),_:1})]),_:3},16,[`data-size`,`class`]))}}),Md=H({__name:`SelectValue`,props:{placeholder:{},asChild:{type:Boolean},as:{}},setup(e){let t=e;return(e,n)=>(V(),M(P(ud),z({"data-slot":`select-value`},t),{default:R(()=>[I(e.$slots,`default`)]),_:3},16))}}),Nd={providers:`models`,usage:`consumers`,charts:`spend`,events:`reliability`,targets:`targets`};function Pd(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(Fe(r))return{page:r,query:new URLSearchParams(i)};let a=Nd[r];return a?{page:a,query:new URLSearchParams}:{page:Ce,query:new URLSearchParams(i)}}function Fd(e,t){let n=Object.entries(t).filter(([,e])=>e!==``);return n.length===0?`#${e}`:`#${e}?${new URLSearchParams(n).toString()}`}var Id=/^(all|group:.+|user:.+|provider:.+)$/;function Ld(e){let t={},n=e.get(`range`);n&&Me(n)&&(t.range=n);let r=e.get(`cmp`);r&&ve(r)&&(t.cmp=r);let i=e.get(`scope`);return i&&Id.test(i)&&(t.scope=i),t}var Rd=new Set([`range`,`cmp`,`scope`]);function zd(e){let t={};for(let[n,r]of e.entries())Rd.has(n)||r!==``&&(t[n]=r);return t}var Bd=Pe(`filters`,{state:()=>({range:`7d`,cmp:Le,scope:`all`}),getters:{window:e=>De[e.range].window,span:e=>De[e.range].span,cmpSpec:e=>{let t=pe(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)}}}),Vd={class:`flex flex-wrap items-end gap-3`},Hd={class:`flex flex-col gap-1`},Ud={class:`flex flex-col gap-1`},Wd=H({__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=Bd();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=x(()=>n.cmp!==`prev`&&!n.cmpSpec.available),o=x(()=>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=j(n.scope);N(()=>n.scope,e=>{s.value=e});function c(){let e=s.value.trim()||`all`;Id.test(e)?n.setFilters({scope:e}):s.value=n.scope}return(e,l)=>{let u=k(`FontAwesomeIcon`);return V(),m(`div`,Vd,[v(`div`,Hd,[l[1]||=v(`label`,{id:`global-filter-range-label`,class:`text-xs font-medium text-muted-foreground`},`Range`,-1),O(P(Td),{"model-value":P(n).range,"onUpdate:modelValue":r},{default:R(()=>[O(P(jd),{"aria-labelledby":`global-filter-range-label`,class:`w-36`},{default:R(()=>[O(P(Md))]),_:1}),O(P(Ed),null,{default:R(()=>[(V(!0),m(we,null,f(P(He),e=>(V(),M(P(Od),{key:e,value:e},{default:R(()=>[D(xe(t[e]),1)]),_:2},1032,[`value`]))),128))]),_:1})]),_:1},8,[`model-value`])]),O(P(ot),{type:`button`,variant:`outline`,"aria-pressed":P(n).cmp===`prev`,disabled:a.value,title:o.value,onClick:i},{default:R(()=>[O(u,{icon:P(w),class:`size-3.5`,"aria-hidden":`true`},null,8,[`icon`]),l[2]||=D(` vs previous period `,-1)]),_:1},8,[`aria-pressed`,`disabled`,`title`]),v(`div`,Ud,[l[3]||=v(`label`,{for:`global-filter-scope`,class:`text-xs font-medium text-muted-foreground`},`Scope`,-1),O(P(fd),{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:$e(c,[`enter`]),onBlur:c},null,8,[`modelValue`])])])}}}),Gd={"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`},Kd=[`aria-current`,`onClick`],qd=H({__name:`SidebarNav`,setup(e){let t=We();return(e,n)=>{let r=k(`FontAwesomeIcon`);return V(),m(`nav`,Gd,[(V(!0),m(we,null,f(P(Be),e=>(V(),m(`button`,{key:e.id,type:`button`,"aria-current":P(t).page===e.id?`page`:void 0,class:Ue([`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)},[O(r,{icon:e.icon,class:`size-4`,"aria-hidden":`true`},null,8,[`icon`]),v(`span`,null,xe(e.label),1)],10,Kd))),128))])}}});function Jd(){let e=Bd(),t=We();function n(n){let{page:r,query:i}=Pd(n),a=Ld(i);e.setFilters({range:a.range??`7d`,cmp:a.cmp??`none`,scope:a.scope??`all`}),t.goTo(r,zd(i))}let r=typeof window<`u`;r&&n(window.location.hash);let i=x(()=>{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),Fd(t.page,n)});N(i,e=>{r&&window.location.hash!==e&&window.history.replaceState(null,``,e)},{immediate:!0});function a(){n(window.location.hash)}r&&(qe(()=>window.addEventListener(`hashchange`,a)),oe(()=>window.removeEventListener(`hashchange`,a)))}var Yd=(function(){let e=typeof document<`u`&&document.createElement(`link`).relList;return e&&e.supports&&e.supports(`modulepreload`)?`modulepreload`:`preload`})(),Xd=function(e){return`/admin/`+e},Zd={},Qd=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=Xd(t,n),t=s(t),t in Zd)return;Zd[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`:Yd,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)})},$d={class:`flex w-full flex-col gap-4 px-4 py-6 sm:px-6 lg:px-8`},ef={class:`flex flex-col gap-3`},tf={class:`flex items-center justify-between gap-2`},nf={key:0,class:`flex items-center gap-1.5 text-sm text-muted-foreground`},rf={key:2,class:`flex flex-col gap-4 md:flex-row`},af={class:`min-w-0 flex-1`},of=`https://github.com/lukaszraczylo/traefik-llmgateway`,sf=rt(H({__name:`App`,setup(e){let t=Ye(),n=Te(),r=We();Jd();let i={home:ie(()=>Qd(()=>import(`./HomePage-9BEnKqFn.js`),__vite__mapDeps([0,1,2,3,4,5,6,7,8]))),spend:ie(()=>Qd(()=>import(`./SpendPage-COAWCgvN.js`),__vite__mapDeps([9,1,10,11,12,13,2,14,15,16,3,4,17,18,7,8,19,20]))),consumers:ie(()=>Qd(()=>import(`./ConsumersPage-DZ5nHr-A.js`),__vite__mapDeps([21,1,10,22,12,16,2,11,23,13,14,3,15,24,4,17,18,5]))),models:ie(()=>Qd(()=>import(`./ModelsPage-3Nt3gvlN.js`),__vite__mapDeps([25,1,10,22,12,16,2,13,14,24,4,8,19,26,20]))),reliability:ie(()=>Qd(()=>import(`./ReliabilityPage-D4CjC5Gn.js`),__vite__mapDeps([27,1,10,13,2,24,18,5,6,8,26,20]))),config:ie(()=>Qd(()=>import(`./ConfigPage-BPgQjjSB.js`),__vite__mapDeps([28,1,10,11,12,16,23]))),targets:ie(()=>Qd(()=>import(`./TargetsPage-Bi0CL-u6.js`),__vite__mapDeps([29,1,10,13,2,14,24,17])))},a=x(()=>i[r.page]),o=x(()=>{if(n.error)return`refresh failed: ${n.error}`;if(n.lastUpdated){let e=n.overview?.replica;return`last updated ${n.lastUpdated.toLocaleTimeString()}${e?` · replica ${e}`:``}`}return`loading...`});return qe(()=>{n.startPolling()}),(e,r)=>{let i=k(`FontAwesomeIcon`);return V(),m(`div`,$d,[v(`header`,ef,[v(`div`,tf,[r[0]||=v(`h1`,{class:`text-xl font-semibold tracking-tight`},`LLM Gateway — Admin`,-1),O(P(ot),{as:`a`,href:of,target:`_blank`,rel:`noopener noreferrer`,variant:`ghost`,size:`icon`,"aria-label":`GitHub repository`,class:`text-muted-foreground hover:text-foreground`},{default:R(()=>[O(i,{icon:P(ds),class:`size-4`,"aria-hidden":`true`},null,8,[`icon`])]),_:1})]),P(t).isAuthenticated?(V(),m(`p`,nf,[P(n).error?(V(),M(i,{key:0,icon:P(de),class:`size-3.5 text-destructive`,"aria-hidden":`true`},null,8,[`icon`])):L(``,!0),v(`span`,{class:Ue(P(n).error?`text-destructive`:void 0)},xe(o.value),3)])):L(``,!0),P(t).isAuthenticated?(V(),M(Wd,{key:1})):L(``,!0)]),P(t).isAuthenticated?(V(),M(wd,{key:0,warnings:P(n).overview?.warnings??[],"warnings-dropped":P(n).overview?.warningsDropped},null,8,[`warnings`,`warnings-dropped`])):L(``,!0),P(t).isAuthenticated?(V(),m(`div`,rf,[O(qd),v(`main`,af,[(V(),M(ne(a.value)))])])):(V(),M(xd,{key:1}))])}}}));sf.use(be()),sf.component(`FontAwesomeIcon`,us),sf.mount(`#app`);export{Ed as a,mc as c,us as d,Od as i,Z as l,Md as n,Td as o,jd as r,fd as s,Bd as t,fs as u};",
+		),
+	},
+	"index-DYX_qiqR.css": {
 		contentType: "text/css; charset=utf-8",
 		body: decodeAdminAsset(
-			"@keyframes authgate-shake-4be6bc09{10%,90%{transform:translate(-1px)}20%,80%{transform:translate(2px)}30%,50%,70%{transform:translate(-4px)}40%,60%{transform:translate(4px)}}@media (prefers-reduced-motion:no-preference){.authgate-shake[data-v-4be6bc09]{animation:.4s ease-in-out authgate-shake-4be6bc09}}@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){:root,:host{--shimmer-angle:20deg}*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-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-content:"";--tw-animation-delay:0s;--tw-animation-direction:normal;--tw-animation-duration:initial;--tw-animation-fill-mode:none;--tw-animation-iteration-count:1;--tw-enter-blur:0;--tw-enter-opacity:1;--tw-enter-rotate:0;--tw-enter-scale:1;--tw-enter-translate-x:0;--tw-enter-translate-y:0;--tw-exit-blur:0;--tw-exit-opacity:1;--tw-exit-rotate:0;--tw-exit-scale:1;--tw-exit-translate-x:0;--tw-exit-translate-y:0;--scroll-fade-t:0;--scroll-fade-b:0;--scroll-fade-s:0;--scroll-fade-e:0;--scroll-fade-mask:initial;--shimmer-image:initial;--shimmer-text-fill:initial}}}@layer theme{:root,:host{--font-sans:ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;--spacing:.25rem;--container-xs:20rem;--container-sm:24rem;--container-md:28rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-base:1rem;--text-base--line-height:calc(1.5 / 1);--text-lg:1.125rem;--text-lg--line-height:calc(1.75 / 1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75 / 1.25);--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--tracking-tight:-.025em;--leading-snug:1.375;--radius-md:calc(var(--radius) - 2px);--radius-4xl:2rem;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;--default-mono-font-family:ui-monospace, "SF Mono", "Cascadia Code", "Roboto Mono", Consolas, monospace}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--default-font-family,-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", "Noto Sans", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring:where(:not(iframe)){outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab, red, red)){::placeholder{color:color-mix(in oklab, currentcolor 50%, transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){appearance:button}::file-selector-button{appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}*{border-color:var(--border);outline-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){*{outline-color:color-mix(in oklab, var(--ring) 50%, transparent)}}body{background-color:var(--background);color:var(--foreground);font-variant-numeric:tabular-nums;font-family:ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif}}@layer components;@layer utilities{.\@container\/card-header{container:card-header/inline-size}.pointer-events-none{pointer-events:none}.collapse{visibility:collapse}.invisible{visibility:hidden}.visible{visibility:visible}.sr-only{clip-path:inset(50%);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.inset-y-0{inset-block:0}.top-1\/2{top:50%}.right-1{right:var(--spacing)}.right-1\.5{right:calc(var(--spacing) * 1.5)}.right-2{right:calc(var(--spacing) * 2)}.left-0{left:0}.left-2\.5{left:calc(var(--spacing) * 2.5)}.z-10{z-index:10}.z-50{z-index:50}.-mx-1\.5{margin-inline:calc(var(--spacing) * -1.5)}.mx-auto{margin-inline:auto}.mt-0\.5{margin-top:calc(var(--spacing) * .5)}.mt-1{margin-top:var(--spacing)}.mt-2{margin-top:calc(var(--spacing) * 2)}.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)}.block{display:block}.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-5{height:calc(var(--spacing) * 5)}.h-6{height:calc(var(--spacing) * 6)}.h-7{height:calc(var(--spacing) * 7)}.h-8{height:calc(var(--spacing) * 8)}.h-9{height:calc(var(--spacing) * 9)}.h-10{height:calc(var(--spacing) * 10)}.h-72{height:calc(var(--spacing) * 72)}.h-\[calc\(100\%-1px\)\]{height:calc(100% - 1px)}.max-h-\(--reka-select-content-available-height\){max-height:var(--reka-select-content-available-height)}.min-h-\[70vh\]{min-height:70vh}.w-14{width:calc(var(--spacing) * 14)}.w-40{width:calc(var(--spacing) * 40)}.w-44{width:calc(var(--spacing) * 44)}.w-56{width:calc(var(--spacing) * 56)}.w-fit{width:fit-content}.w-full{width:100%}.max-w-md{max-width:var(--container-md)}.max-w-sm{max-width:var(--container-sm)}.max-w-xs{max-width:var(--container-xs)}.min-w-0{min-width:0}.min-w-36{min-width:calc(var(--spacing) * 36)}.flex-1{flex:1}.shrink-0{flex-shrink:0}.caption-bottom{caption-side:bottom}.origin-\(--reka-select-content-transform-origin\){transform-origin:var(--reka-select-content-transform-origin)}.-translate-y-1\/2{--tw-translate-y:calc(calc(1 / 2 * 100%) * -1);translate:var(--tw-translate-x) var(--tw-translate-y)}.transform{transform:var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,)}.cursor-default{cursor:default}.cursor-pointer{cursor:pointer}.list-disc{list-style-type:disc}.auto-rows-min{grid-auto-rows:min-content}.grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.flex-col{flex-direction:column}.flex-wrap{flex-wrap:wrap}.items-center{align-items:center}.items-start{align-items:flex-start}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.justify-end{justify-content:flex-end}.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}.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-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-4{padding:calc(var(--spacing) * 4)}.px-1\.5{padding-inline:calc(var(--spacing) * 1.5)}.px-2{padding-inline:calc(var(--spacing) * 2)}.px-2\.5{padding-inline:calc(var(--spacing) * 2.5)}.px-3{padding-inline:calc(var(--spacing) * 3)}.px-4{padding-inline:calc(var(--spacing) * 4)}.py-0\.5{padding-block:calc(var(--spacing) * .5)}.py-1{padding-block:var(--spacing)}.py-2{padding-block:calc(var(--spacing) * 2)}.py-2\.5{padding-block:calc(var(--spacing) * 2.5)}.py-4{padding-block:calc(var(--spacing) * 4)}.py-6{padding-block:calc(var(--spacing) * 6)}.py-8{padding-block:calc(var(--spacing) * 8)}.py-10{padding-block:calc(var(--spacing) * 10)}.pt-0{padding-top:0}.pr-2{padding-right:calc(var(--spacing) * 2)}.pr-8{padding-right:calc(var(--spacing) * 8)}.pr-10{padding-right:calc(var(--spacing) * 10)}.pb-2\.5{padding-bottom:calc(var(--spacing) * 2.5)}.pl-1\.5{padding-left:calc(var(--spacing) * 1.5)}.pl-2\.5{padding-left:calc(var(--spacing) * 2.5)}.pl-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-base{font-size:var(--text-base);line-height:var(--tw-leading,var(--text-base--line-height))}.text-lg{font-size:var(--text-lg);line-height:var(--tw-leading,var(--text-lg--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-xl{font-size:var(--text-xl);line-height:var(--tw-leading,var(--text-xl--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.text-\[0\.8rem\]{font-size:.8rem}.leading-snug{--tw-leading:var(--leading-snug);line-height:var(--leading-snug)}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-normal{--tw-font-weight:var(--font-weight-normal);font-weight:var(--font-weight-normal)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.text-balance{text-wrap:balance}.break-all{word-break:break-all}.whitespace-nowrap{white-space:nowrap}.text-card-foreground{color:var(--card-foreground)}.text-chart-requests{color:var(--chart-requests)}.text-destructive{color:var(--destructive)}.text-foreground,.text-foreground\/60{color:var(--foreground)}@supports (color:color-mix(in lab, red, red)){.text-foreground\/60{color:color-mix(in oklab, var(--foreground) 60%, transparent)}}.text-inherit{color:inherit}.text-muted-foreground,.text-muted-foreground\/60{color:var(--muted-foreground)}@supports (color:color-mix(in lab, red, red)){.text-muted-foreground\/60{color:color-mix(in oklab, var(--muted-foreground) 60%, transparent)}}.text-popover-foreground{color:var(--popover-foreground)}.text-primary{color:var(--primary)}.text-primary-foreground{color:var(--primary-foreground)}.text-secondary-foreground{color:var(--secondary-foreground)}.text-status-warn{color:var(--status-warn)}.lowercase{text-transform:lowercase}.tabular-nums{--tw-numeric-spacing:tabular-nums;font-variant-numeric:var(--tw-ordinal,) var(--tw-slashed-zero,) var(--tw-numeric-figure,) var(--tw-numeric-spacing,) var(--tw-numeric-fraction,)}.underline-offset-4{text-underline-offset:4px}.shadow-md{--tw-shadow:0 4px 6px -1px var(--tw-shadow-color,#0000001a), 0 2px 4px -2px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ring,.ring-1{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.ring-foreground\/10{--tw-ring-color:var(--foreground)}@supports (color:color-mix(in lab, red, red)){.ring-foreground\/10{--tw-ring-color:color-mix(in oklab, var(--foreground) 10%, transparent)}}.outline-hidden{--tw-outline-style:none;outline-style:none}@media (forced-colors:active){.outline-hidden{outline-offset:2px;outline:2px solid #0000}}.outline{outline-style:var(--tw-outline-style);outline-width:1px}.filter{filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.transition-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.duration-100{--tw-duration:.1s;transition-duration:.1s}.outline-none{--tw-outline-style:none;outline-style:none}.select-none{-webkit-user-select:none;user-select:none}.select-text{-webkit-user-select:text;user-select:text}.running{animation-play-state:running}.not-last\:border-b:not(:last-child){border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.group-has-\[\>svg\]\/alert\:col-start-2:is(:where(.group\/alert):has(>svg) *){grid-column-start:2}.group-aria-expanded\/accordion-trigger\:hidden:is(:where(.group\/accordion-trigger)[aria-expanded=true] *){display:none}.group-aria-expanded\/accordion-trigger\:inline:is(:where(.group\/accordion-trigger)[aria-expanded=true] *){display:inline}.group-data-\[size\=sm\]\/card\:px-3:is(:where(.group\/card)[data-size=sm] *){padding-inline:calc(var(--spacing) * 3)}.group-data-\[size\=sm\]\/card\:text-sm:is(:where(.group\/card)[data-size=sm] *){font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.group-data-\[variant\=line\]\/tabs-list\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *){background-color:#0000}.group-data-horizontal\/tabs\:h-8:is(:where(.group\/tabs):where([data-orientation=horizontal]) *){height:calc(var(--spacing) * 8)}.group-data-vertical\/tabs\:h-fit:is(:where(.group\/tabs):where([data-orientation=vertical]) *){height:fit-content}.group-data-vertical\/tabs\:w-full:is(:where(.group\/tabs):where([data-orientation=vertical]) *){width:100%}.group-data-vertical\/tabs\:flex-col:is(:where(.group\/tabs):where([data-orientation=vertical]) *){flex-direction:column}.group-data-vertical\/tabs\:justify-start:is(:where(.group\/tabs):where([data-orientation=vertical]) *){justify-content:flex-start}.file\:inline-flex::file-selector-button{display:inline-flex}.file\:h-6::file-selector-button{height:calc(var(--spacing) * 6)}.file\:border-0::file-selector-button{border-style:var(--tw-border-style);border-width:0}.file\:bg-transparent::file-selector-button{background-color:#0000}.file\:text-sm::file-selector-button{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.file\:font-medium::file-selector-button{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.file\:text-foreground::file-selector-button{color:var(--foreground)}.placeholder\:text-muted-foreground::placeholder{color:var(--muted-foreground)}.after\:absolute:after{content:var(--tw-content);position:absolute}.after\:bg-foreground:after{content:var(--tw-content);background-color:var(--foreground)}.after\:opacity-0:after{content:var(--tw-content);opacity:0}.after\:transition-opacity:after{content:var(--tw-content);transition-property:opacity;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.group-data-horizontal\/tabs\:after\:inset-x-0:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);inset-inline:0}.group-data-horizontal\/tabs\:after\:bottom-\[-5px\]:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);bottom:-5px}.group-data-horizontal\/tabs\:after\:h-0\.5:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);height:calc(var(--spacing) * .5)}.group-data-vertical\/tabs\:after\:inset-y-0:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);inset-block:0}.group-data-vertical\/tabs\:after\:-right-1:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);right:calc(var(--spacing) * -1)}.group-data-vertical\/tabs\:after\:w-0\.5:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);width:calc(var(--spacing) * .5)}@media (hover:hover){.hover\:bg-accent:hover{background-color:var(--accent)}.hover\:bg-destructive\/20:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.hover\:bg-destructive\/20:hover{background-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.hover\:bg-muted:hover,.hover\:bg-muted\/50:hover{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.hover\:bg-muted\/50:hover{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.hover\:bg-secondary\/80:hover{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){.hover\:bg-secondary\/80:hover{background-color:color-mix(in oklab, var(--secondary) 80%, transparent)}}.hover\:text-accent-foreground:hover{color:var(--accent-foreground)}.hover\:text-foreground:hover{color:var(--foreground)}.hover\:text-muted-foreground:hover{color:var(--muted-foreground)}.hover\:text-primary:hover{color:var(--primary)}.hover\:underline:hover{text-decoration-line:underline}}.focus\:bg-accent:focus{background-color:var(--accent)}.focus\:text-accent-foreground:focus,:is(.not-data-\[variant\=destructive\]\:focus\:\*\*\:text-accent-foreground:not([data-variant=destructive]):focus *){color:var(--accent-foreground)}.focus-visible\:border-destructive\/40:focus-visible{border-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.focus-visible\:border-destructive\/40:focus-visible{border-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}.focus-visible\:border-ring:focus-visible{border-color:var(--ring)}.focus-visible\:ring-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 (width>=40rem){.sm\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.sm\:grid-cols-4{grid-template-columns:repeat(4,minmax(0,1fr))}.sm\:grid-cols-5{grid-template-columns:repeat(5,minmax(0,1fr))}.sm\:flex-row{flex-direction:row}.sm\:items-center{align-items:center}.sm\:justify-between{justify-content:space-between}.sm\:px-6{padding-inline:calc(var(--spacing) * 6)}}@media (width>=48rem){.md\:text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.md\:text-pretty{text-wrap:pretty}}@media (width>=64rem){.lg\:px-8{padding-inline:calc(var(--spacing) * 8)}}@media (prefers-color-scheme:dark){.dark\:border-input{border-color:var(--input)}.dark\:bg-destructive\/20{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:bg-destructive\/20{background-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.dark\:bg-input\/30{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:bg-input\/30{background-color:color-mix(in oklab, var(--input) 30%, transparent)}}.dark\:text-muted-foreground{color:var(--muted-foreground)}@media (hover:hover){.dark\:hover\:bg-destructive\/30:hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:hover\:bg-destructive\/30:hover{background-color:color-mix(in oklab, var(--destructive) 30%, transparent)}}.dark\:hover\:bg-input\/50:hover{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:hover\:bg-input\/50:hover{background-color:color-mix(in oklab, var(--input) 50%, transparent)}}.dark\:hover\:bg-muted\/50:hover{background-color:var(--muted)}@supports (color:color-mix(in lab, red, red)){.dark\:hover\:bg-muted\/50:hover{background-color:color-mix(in oklab, var(--muted) 50%, transparent)}}.dark\:hover\:text-foreground:hover{color:var(--foreground)}}.dark\:focus-visible\:ring-destructive\/40:focus-visible{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:focus-visible\:ring-destructive\/40:focus-visible{--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}.dark\:disabled\:bg-input\/80:disabled{background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:disabled\:bg-input\/80:disabled{background-color:color-mix(in oklab, var(--input) 80%, transparent)}}.dark\:aria-invalid\:border-destructive\/50[aria-invalid=true]{border-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:aria-invalid\:border-destructive\/50[aria-invalid=true]{border-color:color-mix(in oklab, var(--destructive) 50%, transparent)}}.dark\:aria-invalid\:ring-destructive\/40[aria-invalid=true]{--tw-ring-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.dark\:aria-invalid\:ring-destructive\/40[aria-invalid=true]{--tw-ring-color:color-mix(in oklab, var(--destructive) 40%, transparent)}}}.data-open\:animate-accordion-down:where([data-state=open]),.data-open\:animate-accordion-down:where([data-open]:not([data-open=false])){animation:accordion-down var(--tw-animation-duration,var(--tw-duration,.2s))var(--tw-ease,ease-out)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-open\:animate-in:where([data-state=open]),.data-open\:animate-in:where([data-open]:not([data-open=false])){animation:enter var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-open\:fade-in-0:where([data-state=open]),.data-open\:fade-in-0:where([data-open]:not([data-open=false])){--tw-enter-opacity:0}.data-open\:zoom-in-95:where([data-state=open]),.data-open\:zoom-in-95:where([data-open]:not([data-open=false])){--tw-enter-scale:.95}.data-closed\:animate-accordion-up:where([data-state=closed]),.data-closed\:animate-accordion-up:where([data-closed]:not([data-closed=false])){animation:accordion-up var(--tw-animation-duration,var(--tw-duration,.2s))var(--tw-ease,ease-out)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-closed\:animate-out:where([data-state=closed]),.data-closed\:animate-out:where([data-closed]:not([data-closed=false])){animation:exit var(--tw-animation-duration,var(--tw-duration,.15s))var(--tw-ease,ease)var(--tw-animation-delay,0s)var(--tw-animation-iteration-count,1)var(--tw-animation-direction,normal)var(--tw-animation-fill-mode,none)}.data-closed\:fade-out-0:where([data-state=closed]),.data-closed\:fade-out-0:where([data-closed]:not([data-closed=false])){--tw-exit-opacity:0}.data-closed\:zoom-out-95:where([data-state=closed]),.data-closed\:zoom-out-95:where([data-closed]:not([data-closed=false])){--tw-exit-scale:.95}.data-active\:bg-background:where([data-state=active]),.data-active\:bg-background:where([data-active]:not([data-active=false])){background-color:var(--background)}.data-active\:text-foreground:where([data-state=active]),.data-active\:text-foreground:where([data-active]:not([data-active=false])){color:var(--foreground)}.group-data-\[variant\=default\]\/tabs-list\:data-active\:shadow-sm:is(:where(.group\/tabs-list)[data-variant=default] *):where([data-state=active]),.group-data-\[variant\=default\]\/tabs-list\:data-active\:shadow-sm:is(:where(.group\/tabs-list)[data-variant=default] *):where([data-active]:not([data-active=false])){--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){background-color:#0000}.group-data-\[variant\=line\]\/tabs-list\:data-active\:shadow-none:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.group-data-\[variant\=line\]\/tabs-list\:data-active\:shadow-none:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){--tw-shadow:0 0 #0000;box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}:is(.group-data-\[variant\=line\]\/tabs-list\:data-active\:after\:opacity-100:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.group-data-\[variant\=line\]\/tabs-list\:data-active\:after\:opacity-100:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false]))):after{content:var(--tw-content);opacity:1}@media (prefers-color-scheme:dark){.dark\:data-active\:border-input:where([data-state=active]),.dark\:data-active\:border-input:where([data-active]:not([data-active=false])){border-color:var(--input)}.dark\:data-active\:bg-input\/30:where([data-state=active]),.dark\:data-active\:bg-input\/30:where([data-active]:not([data-active=false])){background-color:var(--input)}@supports (color:color-mix(in lab, red, red)){.dark\:data-active\:bg-input\/30:where([data-state=active]),.dark\:data-active\:bg-input\/30:where([data-active]:not([data-active=false])){background-color:color-mix(in oklab, var(--input) 30%, transparent)}}.dark\:data-active\:text-foreground:where([data-state=active]),.dark\:data-active\:text-foreground:where([data-active]:not([data-active=false])){color:var(--foreground)}.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:border-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:border-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){border-color:#0000}.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-state=active]),.dark\:group-data-\[variant\=line\]\/tabs-list\:data-active\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *):where([data-active]:not([data-active=false])){background-color:#0000}}.data-horizontal\:flex-col:where([data-orientation=horizontal]){flex-direction:column}.\[\&_a\]\:underline a{text-decoration-line:underline}.\[\&_a\]\:underline-offset-3 a{text-underline-offset:3px}@media (hover:hover){.\[\&_a\]\:hover\:text-foreground a:hover{color:var(--foreground)}}.\[\&_p\:not\(\:last-child\)\]\:mb-4 p:not(:last-child){margin-bottom:calc(var(--spacing) * 4)}.\[\&_svg\]\:pointer-events-none svg{pointer-events:none}.\[\&_svg\]\:shrink-0 svg{flex-shrink:0}.\[\&_svg\:not\(\[class\*\=size-\]\)\]\:size-3 svg:not([class*=size-]){width:calc(var(--spacing) * 3);height:calc(var(--spacing) * 3)}.\[\&_svg\:not\(\[class\*\=size-\]\)\]\:size-3\.5 svg:not([class*=size-]){width:calc(var(--spacing) * 3.5);height:calc(var(--spacing) * 3.5)}.\[\&_svg\:not\(\[class\*\=size-\]\)\]\:size-4 svg:not([class*=size-]){width:calc(var(--spacing) * 4);height:calc(var(--spacing) * 4)}.\[\&_tr\]\:border-b tr{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.\[\&_tr\:last-child\]\:border-0 tr:last-child{border-style:var(--tw-border-style);border-width:0}.\[\&\:has\(\[role\=checkbox\]\)\]\:pr-0:has([role=checkbox]){padding-right:0}.\[\.border-b\]\:pb-4.border-b{padding-bottom:calc(var(--spacing) * 4)}.group-data-\[size\=sm\]\/card\:\[\.border-b\]\:pb-3:is(:where(.group\/card)[data-size=sm] *).border-b{padding-bottom:calc(var(--spacing) * 3)}@media (hover:hover){.\[a\]\:hover\:bg-destructive\/20:is(a):hover{background-color:var(--destructive)}@supports (color:color-mix(in lab, red, red)){.\[a\]\:hover\:bg-destructive\/20:is(a):hover{background-color:color-mix(in oklab, var(--destructive) 20%, transparent)}}.\[a\]\:hover\:bg-muted:is(a):hover{background-color:var(--muted)}.\[a\]\:hover\:bg-primary\/80:is(a):hover{background-color:var(--primary)}@supports (color:color-mix(in lab, red, red)){.\[a\]\:hover\:bg-primary\/80:is(a):hover{background-color:color-mix(in oklab, var(--primary) 80%, transparent)}}.\[a\]\:hover\:bg-secondary\/80:is(a):hover{background-color:var(--secondary)}@supports (color:color-mix(in lab, red, red)){.\[a\]\:hover\:bg-secondary\/80:is(a):hover{background-color:color-mix(in oklab, var(--secondary) 80%, transparent)}}.\[a\]\:hover\:text-muted-foreground:is(a):hover{color:var(--muted-foreground)}}:is(.\*\:\[img\:first-child\]\:rounded-t-xl>*):is(img:first-child){border-top-left-radius:calc(var(--radius) + 4px);border-top-right-radius:calc(var(--radius) + 4px)}:is(.\*\:\[img\:last-child\]\:rounded-b-xl>*):is(img:last-child){border-bottom-right-radius:calc(var(--radius) + 4px);border-bottom-left-radius:calc(var(--radius) + 4px)}:is(.\*\:\[span\]\:last\:flex>*):is(span):last-child{display:flex}:is(.\*\:\[span\]\:last\:items-center>*):is(span):last-child{align-items:center}:is(.\*\:\[span\]\:last\:gap-2>*):is(span):last-child{gap:calc(var(--spacing) * 2)}:is(.\*\:\[svg\]\:row-span-2>*):is(svg){grid-row:span 2/span 2}:is(.\*\:\[svg\]\:translate-y-0\.5>*):is(svg){--tw-translate-y:calc(var(--spacing) * .5);translate:var(--tw-translate-x) var(--tw-translate-y)}:is(.\*\:\[svg\]\:text-current>*):is(svg){color:currentColor}:is(.\*\:\[svg\:not\(\[class\*\=size-\]\)\]\:size-4>*):is(svg:not([class*=size-])){width:calc(var(--spacing) * 4);height:calc(var(--spacing) * 4)}.\[\&\>svg\]\:pointer-events-none>svg{pointer-events:none}.\[\&\>svg\]\:size-3\!>svg{width:calc(var(--spacing) * 3)!important;height:calc(var(--spacing) * 3)!important}}@property --tw-animation-delay{syntax:"*";inherits:false;initial-value:0s}@property --tw-animation-direction{syntax:"*";inherits:false;initial-value:normal}@property --tw-animation-duration{syntax:"*";inherits:false}@property --tw-animation-fill-mode{syntax:"*";inherits:false;initial-value:none}@property --tw-animation-iteration-count{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-enter-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-enter-translate-y{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-blur{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-opacity{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-rotate{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-scale{syntax:"*";inherits:false;initial-value:1}@property --tw-exit-translate-x{syntax:"*";inherits:false;initial-value:0}@property --tw-exit-translate-y{syntax:"*";inherits:false;initial-value:0}@property --scroll-fade-t{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-b{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-s{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-e{syntax:"<length-percentage>";inherits:false;initial-value:0}@property --scroll-fade-mask{syntax:"*";inherits:false}@property --shimmer-angle{syntax:"<angle>";inherits:true;initial-value:20deg}@property --shimmer-image{syntax:"*";inherits:false}@property --shimmer-text-fill{syntax:"*";inherits:false}@media (prefers-reduced-motion:reduce){.shimmer{-webkit-text-fill-color:currentColor;background-image:none;animation:none}}:root{--background:oklch(99% .004 75);--foreground:oklch(19% .012 75);--card:oklch(99.5% .003 75);--card-foreground:oklch(19% .012 75);--popover:oklch(99.5% .003 75);--popover-foreground:oklch(19% .012 75);--primary:oklch(46% .09 200);--primary-foreground:oklch(98% .006 200);--secondary:oklch(95% .006 75);--secondary-foreground:oklch(22% .01 75);--muted:oklch(95% .006 75);--muted-foreground:oklch(48% .012 75);--accent:oklch(93% .02 200);--accent-foreground:oklch(28% .05 200);--destructive:oklch(55% .2 25);--border:oklch(90% .007 75);--input:oklch(90% .007 75);--ring:oklch(55% .09 200);--radius:.375rem;--chart-requests:#009e73;--chart-tokens-in:#0072b2;--chart-tokens-out:#e69f00;--chart-cost:#d55e00;--status-warn:#a35c00;--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;--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-content{syntax:"*";inherits:false;initial-value:""}@keyframes enter{0%{opacity:var(--tw-enter-opacity,1);transform:translate3d(var(--tw-enter-translate-x,0),var(--tw-enter-translate-y,0),0)scale3d(var(--tw-enter-scale,1),var(--tw-enter-scale,1),var(--tw-enter-scale,1))rotate(var(--tw-enter-rotate,0));filter:blur(var(--tw-enter-blur,0))}}@keyframes exit{to{opacity:var(--tw-exit-opacity,1);transform:translate3d(var(--tw-exit-translate-x,0),var(--tw-exit-translate-y,0),0)scale3d(var(--tw-exit-scale,1),var(--tw-exit-scale,1),var(--tw-exit-scale,1))rotate(var(--tw-exit-rotate,0));filter:blur(var(--tw-exit-blur,0))}}@keyframes accordion-down{0%{height:0}to{height:var(--reka-accordion-content-height,var(--accordion-panel-height,auto))}}@keyframes accordion-up{0%{height:var(--reka-accordion-content-height,var(--accordion-panel-height,auto))}to{height:0}}
",
+			"@keyframes authgate-shake-4be6bc09{10%,90%{transform:translate(-1px)}20%,80%{transform:translate(2px)}30%,50%,70%{transform:translate(-4px)}40%,60%{transform:translate(4px)}}@media (prefers-reduced-motion:no-preference){.authgate-shake[data-v-4be6bc09]{animation:.4s ease-in-out authgate-shake-4be6bc09}}@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){:root,:host{--shimmer-angle:20deg}*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-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-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;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;--default-mono-font-family:ui-monospace, "SF Mono", "Cascadia Code", "Roboto Mono", Consolas, monospace}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--default-font-family,-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", "Noto Sans", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring:where(:not(iframe)){outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab, red, red)){::placeholder{color:color-mix(in oklab, currentcolor 50%, transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{padding-block:0}::-webkit-datetime-edit-month-field{padding-block:0}::-webkit-datetime-edit-day-field{padding-block:0}::-webkit-datetime-edit-hour-field{padding-block:0}::-webkit-datetime-edit-minute-field{padding-block:0}::-webkit-datetime-edit-second-field{padding-block:0}::-webkit-datetime-edit-millisecond-field{padding-block:0}::-webkit-datetime-edit-meridiem-field{padding-block:0}::-webkit-calendar-picker-indicator{line-height:1}:-moz-ui-invalid{box-shadow:none}button,input:where([type=button],[type=reset],[type=submit]){appearance:button}::file-selector-button{appearance:button}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[hidden]:where(:not([hidden=until-found])){display:none!important}*{border-color:var(--border);outline-color:var(--ring)}@supports (color:color-mix(in lab, red, red)){*{outline-color:color-mix(in oklab, var(--ring) 50%, transparent)}}body{background-color:var(--background);color:var(--foreground);font-variant-numeric:tabular-nums;font-family:ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif}}@layer components;@layer utilities{.\@container\/card-header{container:card-header/inline-size}.pointer-events-none{pointer-events:none}.collapse{visibility:collapse}.invisible{visibility:hidden}.visible{visibility:visible}.sr-only{clip-path:inset(50%);white-space:nowrap;border-width:0;width:1px;height:1px;margin:-1px;padding:0;position:absolute;overflow:hidden}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.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)}.left-0{left:0}.left-2\.5{left:calc(var(--spacing) * 2.5)}.z-10{z-index:10}.z-50{z-index:50}.-mx-1\.5{margin-inline:calc(var(--spacing) * -1.5)}.mx-auto{margin-inline:auto}.mt-0\.5{margin-top:calc(var(--spacing) * .5)}.mt-1{margin-top:var(--spacing)}.mt-2{margin-top:calc(var(--spacing) * 2)}.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-5{height:calc(var(--spacing) * 5)}.h-6{height:calc(var(--spacing) * 6)}.h-7{height:calc(var(--spacing) * 7)}.h-8{height:calc(var(--spacing) * 8)}.h-9{height:calc(var(--spacing) * 9)}.h-10{height:calc(var(--spacing) * 10)}.h-72{height:calc(var(--spacing) * 72)}.h-\[calc\(100\%-1px\)\]{height:calc(100% - 1px)}.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-14{width:calc(var(--spacing) * 14)}.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-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)}.transform{transform:var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,)}.cursor-default{cursor:default}.cursor-pointer{cursor:pointer}.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-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}.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}.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-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)}.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-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}.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-all{transition-property:all;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.duration-100{--tw-duration:.1s;transition-duration:.1s}.outline-none{--tw-outline-style:none;outline-style:none}.select-none{-webkit-user-select:none;user-select:none}.select-text{-webkit-user-select:text;user-select:text}.running{animation-play-state:running}.not-last\:border-b:not(:last-child){border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.group-has-\[\>svg\]\/alert\:col-start-2:is(:where(.group\/alert):has(>svg) *){grid-column-start:2}.group-aria-expanded\/accordion-trigger\:hidden:is(:where(.group\/accordion-trigger)[aria-expanded=true] *){display:none}.group-aria-expanded\/accordion-trigger\:inline:is(:where(.group\/accordion-trigger)[aria-expanded=true] *){display:inline}.group-data-\[size\=sm\]\/card\:px-3:is(:where(.group\/card)[data-size=sm] *){padding-inline:calc(var(--spacing) * 3)}.group-data-\[size\=sm\]\/card\:text-sm:is(:where(.group\/card)[data-size=sm] *){font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.group-data-\[variant\=line\]\/tabs-list\:bg-transparent:is(:where(.group\/tabs-list)[data-variant=line] *){background-color:#0000}.group-data-horizontal\/tabs\:h-8:is(:where(.group\/tabs):where([data-orientation=horizontal]) *){height:calc(var(--spacing) * 8)}.group-data-vertical\/tabs\:h-fit:is(:where(.group\/tabs):where([data-orientation=vertical]) *){height:fit-content}.group-data-vertical\/tabs\:w-full:is(:where(.group\/tabs):where([data-orientation=vertical]) *){width:100%}.group-data-vertical\/tabs\:flex-col:is(:where(.group\/tabs):where([data-orientation=vertical]) *){flex-direction:column}.group-data-vertical\/tabs\:justify-start:is(:where(.group\/tabs):where([data-orientation=vertical]) *){justify-content:flex-start}.file\:inline-flex::file-selector-button{display:inline-flex}.file\:h-6::file-selector-button{height:calc(var(--spacing) * 6)}.file\:border-0::file-selector-button{border-style:var(--tw-border-style);border-width:0}.file\:bg-transparent::file-selector-button{background-color:#0000}.file\:text-sm::file-selector-button{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.file\:font-medium::file-selector-button{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.file\:text-foreground::file-selector-button{color:var(--foreground)}.placeholder\:text-muted-foreground::placeholder{color:var(--muted-foreground)}.after\:absolute:after{content:var(--tw-content);position:absolute}.after\:bg-foreground:after{content:var(--tw-content);background-color:var(--foreground)}.after\:opacity-0:after{content:var(--tw-content);opacity:0}.after\:transition-opacity:after{content:var(--tw-content);transition-property:opacity;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.group-data-horizontal\/tabs\:after\:inset-x-0:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);inset-inline:0}.group-data-horizontal\/tabs\:after\:bottom-\[-5px\]:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);bottom:-5px}.group-data-horizontal\/tabs\:after\:h-0\.5:is(:where(.group\/tabs):where([data-orientation=horizontal]) *):after{content:var(--tw-content);height:calc(var(--spacing) * .5)}.group-data-vertical\/tabs\:after\:inset-y-0:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);inset-block:0}.group-data-vertical\/tabs\:after\:-right-1:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);right:calc(var(--spacing) * -1)}.group-data-vertical\/tabs\:after\:w-0\.5:is(:where(.group\/tabs):where([data-orientation=vertical]) *):after{content:var(--tw-content);width:calc(var(--spacing) * .5)}.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 (width>=40rem){.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-content{syntax:"*";inherits:false;initial-value:""}@keyframes enter{0%{opacity:var(--tw-enter-opacity,1);transform:translate3d(var(--tw-enter-translate-x,0),var(--tw-enter-translate-y,0),0)scale3d(var(--tw-enter-scale,1),var(--tw-enter-scale,1),var(--tw-enter-scale,1))rotate(var(--tw-enter-rotate,0));filter:blur(var(--tw-enter-blur,0))}}@keyframes exit{to{opacity:var(--tw-exit-opacity,1);transform:translate3d(var(--tw-exit-translate-x,0),var(--tw-exit-translate-y,0),0)scale3d(var(--tw-exit-scale,1),var(--tw-exit-scale,1),var(--tw-exit-scale,1))rotate(var(--tw-exit-rotate,0));filter:blur(var(--tw-exit-blur,0))}}@keyframes accordion-down{0%{height:0}to{height:var(--reka-accordion-content-height,var(--accordion-panel-height,auto))}}@keyframes accordion-up{0%{height:var(--reka-accordion-content-height,var(--accordion-panel-height,auto))}to{height:0}}
",
+		),
+	},
+	"kpi-CU52LDmq.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"aW1wb3J0e2EgYXMgZSxzIGFzIHR9ZnJvbSIuL2ZvcmVjYXN0LUJNU2tnNVhzLmpzIjtpbXBvcnR7YyBhcyBuLHMgYXMgcn1mcm9tIi4vcHJvdmlkZXItcmF0ZS1EVTdPZ1NlQi5qcyI7ZnVuY3Rpb24gaSh0KXtsZXQgbj0wO2ZvcihsZXQgciBvZiB0KXtsZXQgdD1yLmxpbWl0cz8uY29zdFBlck1vbnRoVVNEO3QmJnQ+MCYmKG4rPU1hdGgucm91bmQodCplKSl9cmV0dXJuIG59ZnVuY3Rpb24gYShlLHQpe3JldHVybiB0PD0wP251bGw6ZS90fWZ1bmN0aW9uIG8oZSl7aWYoZT09PW51bGwpcmV0dXJuYG9rYDtzd2l0Y2godChlKSl7Y2FzZWBub3JtYWxgOnJldHVybmBva2A7Y2FzZWBhbWJlcmA6cmV0dXJuYHdhcm5gO2Nhc2VgcmVkYDpyZXR1cm5gY3JpdGljYWxgfX1mdW5jdGlvbiBzKGUpe3JldHVybiBlLmZpbHRlcihlPT5lLmhlYWx0aFN0YXRlIT09YGNsb3NlZGApLmxlbmd0aH1mdW5jdGlvbiBjKGUpe2xldCB0PTAscj0wO2ZvcihsZXQgbiBvZiBlKXQrPW4uYXR0ZW1wdHNNaW51dGUscis9bi5mYWlsdXJlc01pbnV0ZTtsZXQgaT1uKHQscik7cmV0dXJue3JhdGU6aT09PW51bGw/bnVsbDoxLWksYXR0ZW1wdHM6dCxmYWlsdXJlczpyfX1mdW5jdGlvbiBsKGUpe2lmKGU9PT1udWxsKXJldHVybmBva2A7c3dpdGNoKHIoMS1lKSl7Y2FzZWBuby10cmFmZmljYDpjYXNlYGhlYWx0aHlgOnJldHVybmBva2A7Y2FzZWBkZWdyYWRlZGA6cmV0dXJuYHdhcm5gO2Nhc2Vgc2V2ZXJlYDpyZXR1cm5gY3JpdGljYWxgfX1leHBvcnR7cyBhcyBhLGMgYXMgaSxvIGFzIG4saSBhcyBvLGwgYXMgcixhIGFzIHR9Ow==",
+		),
+	},
+	"nav-Dzb0OTN_.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 ue(e){let t=``;if(_(e))t=e;else if(d(e))for(let n=0;n<e.length;n++){let r=ue(e[n]);r&&(t+=r+` `)}else if(y(e))for(let n in e)e[n]&&(t+=n+` `);return t.trim()}function de(e){if(!e)return null;let{class:t,style:n}=e;return t&&!_(t)&&(e.class=ue(t)),n&&(e.style=F(n)),e}var fe=`itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`,pe=e(fe);fe+``;function me(e){return!!e||e===``}function he(e,t){if(e.length!==t.length)return!1;let n=!0;for(let r=0;n&&r<e.length;r++)n=ge(e[r],t[r]);return n}function ge(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?he(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||!ge(e[n],t[n]))return!1}}return String(e)===String(t)}function _e(e,t){return e.findIndex(e=>ge(e,t))}var ve=e=>!!(e&&e.__v_isRef===!0),ye=e=>_(e)?e:e==null?``:d(e)||y(e)&&(e.toString===x||!g(e.toString))?ve(e)?ye(e.value):JSON.stringify(e,be,2):String(e),be=(e,t)=>ve(t)?be(e,t.value):f(t)?{[`Map(${t.size})`]:[...t.entries()].reduce((e,[t,n],r)=>(e[xe(t,r)+` =>`]=n,e),{})}:p(t)?{[`Set(${t.size})`]:[...t.values()].map(e=>xe(e))}:v(t)?xe(t):y(t)&&!d(t)&&!w(t)?String(t):t,xe=(e,t=``)=>v(e)?`Symbol(${e.description??t})`:e;function Se(e){return e==null?`initial`:typeof e==`string`?e===``?` `:e:String(e)}var L,Ce=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&&L&&(L.active?(this.parent=L,this.index=(L.scopes||(L.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=L;try{return L=this,e()}finally{L=t}}}on(){++this._on===1&&(this.prevScope=L,L=this)}off(){if(this._on>0&&--this._on===0){if(L===this)L=this.prevScope;else{let e=L;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 we(e){return new Ce(e)}function Te(){return L}function Ee(e,t=!1){L&&L.cleanups.push(e)}var R,De=new WeakSet,Oe=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,L&&(L.active?L.effects.push(this):this.flags&=-2)}pause(){this.flags|=64}resume(){this.flags&64&&(this.flags&=-65,De.has(this)&&(De.delete(this),this.trigger()))}notify(){this.flags&2&&!(this.flags&32)||this.flags&8||Me(this)}run(){if(!(this.flags&1))return this.fn();this.flags|=2,qe(this),Fe(this);let e=R,t=Ue;R=this,Ue=!0;try{return this.fn()}finally{Ie(this),R=e,Ue=t,this.flags&=-3}}stop(){if(this.flags&1){for(let e=this.deps;e;e=e.nextDep)ze(e);this.deps=this.depsTail=void 0,qe(this),this.onStop&&this.onStop(),this.flags&=-2}}trigger(){this.flags&64?De.add(this):this.scheduler?this.scheduler():this.runIfDirty()}runIfDirty(){Le(this)&&this.run()}get dirty(){return Le(this)}},ke=0,Ae,je;function Me(e,t=!1){if(e.flags|=8,t){e.next=je,je=e;return}e.next=Ae,Ae=e}function Ne(){ke++}function Pe(){if(--ke>0)return;if(je){let e=je;for(je=void 0;e;){let t=e.next;e.next=void 0,e.flags&=-9,e=t}}let e;for(;Ae;){let t=Ae;for(Ae=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 Fe(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function Ie(e){let t,n=e.depsTail,r=n;for(;r;){let e=r.prevDep;r.version===-1?(r===n&&(n=e),ze(r),Be(r)):t=r,r.dep.activeLink=r.prevActiveLink,r.prevActiveLink=void 0,r=e}e.deps=t,e.depsTail=n}function Le(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(Re(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function Re(e){if(e.flags&4&&!(e.flags&16)||(e.flags&=-17,e.globalVersion===Je)||(e.globalVersion=Je,!e.isSSR&&e.flags&128&&(!e.deps&&!e._dirty||!Le(e))))return;e.flags|=2;let t=e.dep,n=R,r=Ue;R=e,Ue=!0;try{Fe(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{R=n,Ue=r,Ie(e),e.flags&=-3}}function ze(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)ze(e,!0)}!t&&!--n.sc&&n.map&&n.map.delete(n.key)}function Be(e){let{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}function Ve(e,t){e.effect instanceof Oe&&(e=e.effect.fn);let n=new Oe(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 He(e){e.effect.stop()}var Ue=!0,We=[];function Ge(){We.push(Ue),Ue=!1}function Ke(){let e=We.pop();Ue=e===void 0||e}function qe(e){let{cleanup:t}=e;if(e.cleanup=void 0,t){let e=R;R=void 0;try{t()}finally{R=e}}}var Je=0,Ye=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}},Xe=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(!R||!Ue||R===this.computed)return;let t=this.activeLink;if(t===void 0||t.sub!==R)t=this.activeLink=new Ye(R,this),R.deps?(t.prevDep=R.depsTail,R.depsTail.nextDep=t,R.depsTail=t):R.deps=R.depsTail=t,Ze(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=R.depsTail,t.nextDep=void 0,R.depsTail.nextDep=t,R.depsTail=t,R.deps===t&&(R.deps=e)}return t}trigger(e){this.version++,Je++,this.notify(e)}notify(e){Ne();try{for(let e=this.subs;e;e=e.prevSub)e.sub.notify()&&e.sub.dep.notify()}finally{Pe()}}};function Ze(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)Ze(e)}let n=e.dep.subs;n!==e&&(e.prevSub=n,n&&(n.nextSub=e)),e.dep.subs=e}}var Qe=new WeakMap,$e=Symbol(``),et=Symbol(``),tt=Symbol(``);function z(e,t,n){if(Ue&&R){let t=Qe.get(e);t||Qe.set(e,t=new Map);let r=t.get(n);r||(t.set(n,r=new Xe),r.map=t,r.key=n),r.track()}}function nt(e,t,n,r,i,a){let o=Qe.get(e);if(!o){Je++;return}let s=e=>{e&&e.trigger()};if(Ne(),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===tt||!v(n)&&n>=e)&&s(t)})}else switch((n!==void 0||o.has(void 0))&&s(o.get(n)),a&&s(o.get(tt)),t){case`add`:i?a&&s(o.get(`length`)):(s(o.get($e)),f(e)&&s(o.get(et)));break;case`delete`:i||(s(o.get($e)),f(e)&&s(o.get(et)));break;case`set`:f(e)&&s(o.get($e))}}Pe()}function rt(e,t){let n=Qe.get(e);return n&&n.get(t)}function it(e){let t=B(e);return t===e?t:(z(t,`iterate`,tt),Kt(e)?t:t.map(Yt))}function at(e){return z(e=B(e),`iterate`,tt),e}function ot(e,t){return Gt(e)?Xt(Wt(e)?Yt(t):t):Yt(t)}var st={__proto__:null,[Symbol.iterator](){return ct(this,Symbol.iterator,e=>ot(this,e))},concat(...e){return it(this).concat(...e.map(e=>d(e)?it(e):e))},entries(){return ct(this,`entries`,e=>(e[1]=ot(this,e[1]),e))},every(e,t){return ut(this,`every`,e,t,void 0,arguments)},filter(e,t){return ut(this,`filter`,e,t,e=>e.map(e=>ot(this,e)),arguments)},find(e,t){return ut(this,`find`,e,t,e=>ot(this,e),arguments)},findIndex(e,t){return ut(this,`findIndex`,e,t,void 0,arguments)},findLast(e,t){return ut(this,`findLast`,e,t,e=>ot(this,e),arguments)},findLastIndex(e,t){return ut(this,`findLastIndex`,e,t,void 0,arguments)},forEach(e,t){return ut(this,`forEach`,e,t,void 0,arguments)},includes(...e){return ft(this,`includes`,e)},indexOf(...e){return ft(this,`indexOf`,e)},join(e){return it(this).join(e)},lastIndexOf(...e){return ft(this,`lastIndexOf`,e)},map(e,t){return ut(this,`map`,e,t,void 0,arguments)},pop(){return pt(this,`pop`)},push(...e){return pt(this,`push`,e)},reduce(e,...t){return dt(this,`reduce`,e,t)},reduceRight(e,...t){return dt(this,`reduceRight`,e,t)},shift(){return pt(this,`shift`)},some(e,t){return ut(this,`some`,e,t,void 0,arguments)},splice(...e){return pt(this,`splice`,e)},toReversed(){return it(this).toReversed()},toSorted(e){return it(this).toSorted(e)},toSpliced(...e){return it(this).toSpliced(...e)},unshift(...e){return pt(this,`unshift`,e)},values(){return ct(this,`values`,e=>ot(this,e))}};function ct(e,t,n){let r=at(e),i=r[t]();return r!==e&&!Kt(e)&&(i._next=i.next,i.next=()=>{let e=i._next();return e.done||(e.value=n(e.value)),e}),i}var lt=Array.prototype;function ut(e,t,n,r,i,a){let o=at(e),s=o!==e&&!Kt(e),c=o[t];if(c!==lt[t]){let t=c.apply(e,a);return s?Yt(t):t}let l=n;o!==e&&(s?l=function(t,r){return n.call(this,ot(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 dt(e,t,n,r){let i=at(e),a=i!==e&&!Kt(e),o=n,s=!1;i!==e&&(a?(s=r.length===0,o=function(t,r,i){return s&&(s=!1,t=ot(e,t)),n.call(this,t,ot(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?ot(e,c):c}function ft(e,t,n){let r=B(e);z(r,`iterate`,tt);let i=r[t](...n);return(i===-1||i===!1)&&qt(n[0])?(n[0]=B(n[0]),r[t](...n)):i}function pt(e,t,n=[]){Ge(),Ne();let r=B(e)[t].apply(e,n);return Pe(),Ke(),r}var mt=e(`__proto__,__v_isRef,__isVue`),ht=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>e!==`arguments`&&e!==`caller`).map(e=>Symbol[e]).filter(v));function gt(e){v(e)||(e=String(e));let t=B(this);return z(t,`has`,e),t.hasOwnProperty(e)}var _t=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?Lt:It:i?Ft:Pt).get(e)||Object.getPrototypeOf(e)===Object.getPrototypeOf(n)?e:void 0;let a=d(e);if(!r){let e;if(a&&(e=st[t]))return e;if(t===`hasOwnProperty`)return gt}let o=Reflect.get(e,t,V(e)?e:n);if((v(t)?ht.has(t):mt(t))||(r||z(e,`get`,t),i))return o;if(V(o)){let e=a&&T(t)?o:o.value;return r&&y(e)?Vt(e):e}return y(o)?r?Vt(o):zt(o):o}},vt=class extends _t{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=Gt(i);if(!Kt(n)&&!Gt(n)&&(i=B(i),n=B(n)),!a&&V(i)&&!V(n))return e||(i.value=n),!0}let o=a?Number(t)<e.length:u(e,t),s=Reflect.set(e,t,n,V(e)?e:r);return e===B(r)&&s&&(o?j(n,i)&&nt(e,`set`,t,n,i):nt(e,`add`,t,n)),s}deleteProperty(e,t){let n=u(e,t),r=e[t],i=Reflect.deleteProperty(e,t);return i&&n&&nt(e,`delete`,t,void 0,r),i}has(e,t){let n=Reflect.has(e,t);return(!v(t)||!ht.has(t))&&z(e,`has`,t),n}ownKeys(e){return z(e,`iterate`,d(e)?`length`:$e),Reflect.ownKeys(e)}},yt=class extends _t{constructor(e=!1){super(!0,e)}set(e,t){return!0}deleteProperty(e,t){return!0}},bt=new vt,xt=new yt,St=new vt(!0),Ct=new yt(!0),wt=e=>e,Tt=e=>Reflect.getPrototypeOf(e);function Et(e,t,n){return function(...r){let i=this.__v_raw,a=B(i),o=f(a),c=e===`entries`||e===Symbol.iterator&&o,l=e===`keys`&&o,u=i[e](...r),d=n?wt:t?Xt:Yt;return!t&&z(a,`iterate`,l?et:$e),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 Dt(e){return function(...t){return e===`delete`?!1:e===`clear`?void 0:this}}function Ot(e,t){let n={get(n){let r=this.__v_raw,i=B(r),a=B(n);e||(j(n,a)&&z(i,`get`,n),z(i,`get`,a));let{has:o}=Tt(i),s=t?wt:e?Xt:Yt;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&&z(B(t),`iterate`,$e),t.size},has(t){let n=this.__v_raw,r=B(n),i=B(t);return e||(j(t,i)&&z(r,`has`,t),z(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=B(a),s=t?wt:e?Xt:Yt;return!e&&z(o,`iterate`,$e),a.forEach((e,t)=>n.call(r,s(e),s(t),i))}};return s(n,e?{add:Dt(`add`),set:Dt(`set`),delete:Dt(`delete`),clear:Dt(`clear`)}:{add(e){let n=B(this),r=Tt(n),i=B(e),a=!t&&!Kt(e)&&!Gt(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),nt(n,`add`,a,a)),this},set(e,n){!t&&!Kt(n)&&!Gt(n)&&(n=B(n));let r=B(this),{has:i,get:a}=Tt(r),o=i.call(r,e);o||=(e=B(e),i.call(r,e));let s=a.call(r,e);return r.set(e,n),o?j(n,s)&&nt(r,`set`,e,n,s):nt(r,`add`,e,n),this},delete(e){let t=B(this),{has:n,get:r}=Tt(t),i=n.call(t,e);i||=(e=B(e),n.call(t,e));let a=r?r.call(t,e):void 0,o=t.delete(e);return i&&nt(t,`delete`,e,void 0,a),o},clear(){let e=B(this),t=e.size!==0,n=e.clear();return t&&nt(e,`clear`,void 0,void 0,void 0),n}}),[`keys`,`values`,`entries`,Symbol.iterator].forEach(r=>{n[r]=Et(r,e,t)}),n}function kt(e,t){let n=Ot(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 At={get:kt(!1,!1)},jt={get:kt(!1,!0)},Mt={get:kt(!0,!1)},Nt={get:kt(!0,!0)},Pt=new WeakMap,Ft=new WeakMap,It=new WeakMap,Lt=new WeakMap;function Rt(e){switch(e){case`Object`:case`Array`:return 1;case`Map`:case`Set`:case`WeakMap`:case`WeakSet`:return 2;default:return 0}}function zt(e){return Gt(e)?e:Ut(e,!1,bt,At,Pt)}function Bt(e){return Ut(e,!1,St,jt,Ft)}function Vt(e){return Ut(e,!0,xt,Mt,It)}function Ht(e){return Ut(e,!0,Ct,Nt,Lt)}function Ut(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=Rt(C(e));if(o===0)return e;let s=new Proxy(e,o===2?r:n);return i.set(e,s),s}function Wt(e){return Gt(e)?Wt(e.__v_raw):!!(e&&e.__v_isReactive)}function Gt(e){return!!(e&&e.__v_isReadonly)}function Kt(e){return!!(e&&e.__v_isShallow)}function qt(e){return e?!!e.__v_raw:!1}function B(e){let t=e&&e.__v_raw;return t?B(t):e}function Jt(e){return!u(e,`__v_skip`)&&Object.isExtensible(e)&&N(e,`__v_skip`,!0),e}var Yt=e=>y(e)?zt(e):e,Xt=e=>y(e)?Vt(e):e;function V(e){return e?e.__v_isRef===!0:!1}function Zt(e){return $t(e,!1)}function Qt(e){return $t(e,!0)}function $t(e,t){return V(e)?e:new en(e,t)}var en=class{constructor(e,t){this.dep=new Xe,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=t?e:B(e),this._value=t?e:Yt(e),this.__v_isShallow=t}get value(){return this.dep.track(),this._value}set value(e){let t=this._rawValue,n=this.__v_isShallow||Kt(e)||Gt(e);e=n?e:B(e),j(e,t)&&(this._rawValue=e,this._value=n?e:Yt(e),this.dep.trigger())}};function tn(e){e.dep&&e.dep.trigger()}function nn(e){return V(e)?e.value:e}function rn(e){return g(e)?e():nn(e)}var an={get:(e,t,n)=>t===`__v_raw`?e:nn(Reflect.get(e,t,n)),set:(e,t,n,r)=>{let i=e[t];return V(i)&&!V(n)?(i.value=n,!0):Reflect.set(e,t,n,r)}};function on(e){return Wt(e)?e:new Proxy(e,an)}var sn=class{constructor(e){this.__v_isRef=!0,this._value=void 0;let t=this.dep=new Xe,{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 cn(e){return new sn(e)}function ln(e){let t=d(e)?Array(e.length):{};for(let n in e)t[n]=pn(e,n);return t}var un=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=B(e);let r=!0,i=e;if(!d(e)||v(this._key)||!T(this._key))do r=!qt(i)||Kt(i);while(r&&(i=i.__v_raw));this._shallow=r}get value(){let e=this._object[this._key];return this._shallow&&(e=nn(e)),this._value=e===void 0?this._defaultValue:e}set value(e){if(this._shallow&&V(this._raw[this._key])){let t=this._object[this._key];if(V(t)){t.value=e;return}}this._object[this._key]=e}get dep(){return rt(this._raw,this._key)}},dn=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 fn(e,t,n){return V(e)?e:g(e)?new dn(e):y(e)&&arguments.length>1?pn(e,t,n):Zt(e)}function pn(e,t,n){return new un(e,t,n)}var mn=class{constructor(e,t,n){this.fn=e,this.setter=t,this._value=void 0,this.dep=new Xe(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=Je-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!t,this.isSSR=n}notify(){if(this.flags|=16,!(this.flags&8)&&R!==this)return Me(this,!0),!0}get value(){let e=this.dep.track();return Re(this),e&&(e.version=this.dep.version),this._value}set value(e){this.setter&&this.setter(e)}};function hn(e,t,n=!1){let r,i;return g(e)?r=e:(r=e.get,i=e.set),new mn(r,i,n)}var gn={GET:`get`,HAS:`has`,ITERATE:`iterate`},_n={SET:`set`,ADD:`add`,DELETE:`delete`,CLEAR:`clear`},vn={},yn=new WeakMap,bn=void 0;function xn(){return bn}function Sn(e,t=!1,n=bn){if(n){let t=yn.get(n);t||yn.set(n,t=[]),t.push(e)}}function Cn(e,n,i=t){let{immediate:a,deep:o,once:s,scheduler:l,augmentJob:u,call:f}=i,p=e=>o?e:Kt(e)||o===!1||o===0?wn(e,1):wn(e),m,h,_,v,y=!1,b=!1;if(V(e)?(h=()=>e.value,y=Kt(e)):Wt(e)?(h=()=>p(e),y=!0):d(e)?(b=!0,y=e.some(e=>Wt(e)||Kt(e)),h=()=>e.map(e=>{if(V(e))return e.value;if(Wt(e))return p(e);if(g(e))return f?f(e,2):e()})):h=g(e)?n?f?()=>f(e,2):e:()=>{if(_){Ge();try{_()}finally{Ke()}}let t=bn;bn=m;try{return f?f(e,3,[v]):e(v)}finally{bn=t}}:r,n&&o){let e=h,t=o===!0?1/0:o;h=()=>wn(e(),t)}let x=Te(),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(vn):vn,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=bn;bn=m;try{let e=[t,C===vn?void 0:b&&C[0]===vn?[]:C,v];C=t,f?f(n,3,e):n(...e)}finally{bn=e}}}else m.run()}};return u&&u(w),m=new Oe(h),m.scheduler=l?()=>l(w,!1):w,v=e=>Sn(e,!1,m),_=m.onStop=()=>{let e=yn.get(m);if(e){if(f)f(e,4);else for(let t of e)t();yn.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 wn(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--,V(e))wn(e.value,t,n);else if(d(e))for(let r=0;r<e.length;r++)wn(e[r],t,n);else if(p(e)||f(e))e.forEach(e=>{wn(e,t,n)});else if(w(e)){for(let r in e)wn(e[r],t,n);for(let r of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,r)&&wn(e[r],t,n)}return e}var Tn=[];function En(e){Tn.push(e)}function Dn(){Tn.pop()}function On(e,t){}var kn={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`},An={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 jn(e,t,n,r){try{return r?e(...r):e()}catch(e){Nn(e,t,n)}}function Mn(e,t,n,r){if(g(e)){let i=jn(e,t,n,r);return i&&b(i)&&i.catch(e=>{Nn(e,t,n)}),i}if(d(e)){let i=[];for(let a=0;a<e.length;a++)i.push(Mn(e[a],t,n,r));return i}}function Nn(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){Ge(),jn(o,null,10,[e,i,a]),Ke();return}}Pn(e,r,a,i,s)}function Pn(e,t,n,r=!0,i=!1){if(i)throw e;console.error(e)}var H=[],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=H.length;for(;t<n;){let r=t+n>>>1,i=H[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=H[H.length-1];!n||!(e.flags&2)&&t>=Jn(n)?H.push(e):H.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<H.length;n++){let t=H[n];if(t&&t.flags&2){if(e&&t.id!==e.uid)continue;H.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<H.length;Fn++){let e=H[Fn];e&&!(e.flags&8)&&(e.flags&4&&(e.flags&=-2),jn(e,e.i,e.i?15:14),e.flags&4||(e.flags&=-2))}}finally{for(;Fn<H.length;Fn++){let e=H[Fn];e&&(e.flags&=-2)}Fn=-1,H.length=0,qn(e),Bn=null,(H.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&&rs(-1);let i=er(t),a=$o.length,o;try{o=e(...n)}finally{for(let e=$o.length;e>a;e--)ts();er(i),r._d&&rs(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&&wn(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&&(Ge(),Mn(c,n,8,[e.el,s,e,t]),Ke())}}function sr(e,t){if(Y){let n=Y.provides,r=Y.parent&&Y.parent.provides;r===n&&(n=Y.provides=Object.create(r)),n[e]=t}}function cr(e,t,n=!1){let r=Ds();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!!(Ds()||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=Y;u.call=(e,t,n)=>Mn(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=Cn(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=Ds(),r=Fr();return()=>{let i=t.default&&qr(t.default(),!0),a=i&&i.length?Br(i):n.subTree?vs():void 0;if(!a)return;let o=B(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&&!cs(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&&Mn(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&&cs(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=hs(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:hs(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=Ds();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=Ds(),r=Qt(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=B(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(V(m)){let e=n;x(m,e.k)&&(m.value=null),e.k&&(h[e.k]=null)}}if(g(p))jn(p,f,12,[l,h]);else{let t=_(p),n=V(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=J(G),t.anchor=D?D.previousSibling:e.lastChild):t=n.nodeType===3?gs(``):J(`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&&Wt(d.style))for(let e in d.style)d.style[e]}let x;(x=d&&d.onVnodeBeforeMount)&&Cs(x,n,t),h&&or(t,null,n,`beforeMount`),((x=d&&d.onVnodeMounted)||h||l)&&Jo(()=>{x&&Cs(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]=ys(d[t]),g=h.type===Zo;e?(g&&!u&&t+1<p&&ys(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=Y;if(Xr(e),u)return()=>Oi(u,e);let t=t=>{l=null,Nn(t,e,13,!r)};if(s&&e.suspense||Ns)return p().then(t=>()=>Oi(t,e)).catch(e=>(t(e),()=>r?J(r,{error:e}):null));let a=Zt(!1),c=Zt(),d=Zt(!!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 J(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=J(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=Ds(),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&&Cs(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&&Cs(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||!cs(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(!ss(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=hs(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=Y){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=Y,r=!1){if(n){let i=n[e]||(n[e]=[]),a=t.__weh||=(...r)=>{Ge();let i=As(n),a=Mn(t,n,e,r);return i(),Ke(),a};return r?i.unshift(a):i.push(a),a}}var zi=e=>(t,n=Y)=>{(!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=Y){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||Y;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&&Wt(e),r=!1,s=!1;n&&(r=!Kt(e),s=Gt(e),e=at(e)),i=Array(e.length);for(let n=0,o=e.length;n<o;n++)i[n]=t(r?s?Xt(Yt(e[n])):Yt(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),es(),os(G,null,[J(`slot`,e,r&&r())],i?-2:64)}let o=e[t];o&&o._c&&(o._d=!1);let c=$o.length;es();let l;try{let i=o&&sa(o(n)),s=n.key||a||i&&i.key;l=os(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--)ts();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=>!ss(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`&&z(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=Ds();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=Ds(),n=Ns,r=e();js(),n&&ks(!1);let i=()=>{As(t),n&&ks(!0)},a=()=>{Ds()!==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=zt(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),V(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){Mn(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||J(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&&(Mn(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=Ds(),a=O(n),o=k(n),s=Ya(e,a),c=cn((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&&Mn(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,Mn(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=ys(u.call(t,e,d,f,m,p,h)),y=c}else{let e=t;v=ys(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,Nn(t,e,1),v=J(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=hs(b,y,!1,!0))}return n.dirs&&(b=hs(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(ss(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)?!ge(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:Bt(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=B(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&&nt(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=B(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(ys):[ys(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&&!cs(e,t)&&(r=fe(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,he)}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)&&Cs(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&&Cs(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?bs(e[l]):ys(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)&&Cs(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&&Cs(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||!cs(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=Es(e,r,i);if(ki(e)&&(s.ctx.renderer=he),Ps(s,!1,o),s.asyncDep){if(i&&i.registerDep(s,re,o),!e.el){let r=s.subTree=J(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)&&Cs(d,s,t,c),jo(e,!0);let f=eo(e),p=e.subTree;e.subTree=f,v(p,f,m(p.el),fe(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(()=>Cs(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)&&Cs(o,d,t),jo(e,!0),s&&_e){let t=()=>{e.subTree=eo(e),_e(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(()=>Cs(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 Oe(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),Ge(),Kn(e),Ke()},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&&de(l,i,a),d!==l&&p(n,d)):u&16?m&16?F(l,d,n,r,i,a,o,s,c):de(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?bs(t[p]):ys(t[p]);v(e[p],n,r,null,a,o,s,c,l)}u>d?de(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?bs(t[u]):ys(t[u]);if(cs(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?bs(t[p]):ys(t[p]);if(cs(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?bs(t[u]):ys(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?bs(t[u]):ys(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&&cs(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,he);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&&(Ge(),ei(s,null,n,e,!0),Ke()),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)&&Cs(_,t,e),u&6)ue(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,he,r):l&&!l.hasOnce&&(a!==G||d>0&&d&64)?de(l,t,n,!1,!0):(a===G&&d&384||!i&&u&16)&&de(c,t,n),r&&I(e)}let v=m!=null&&p==null;(g&&(_=o&&o.onVnodeUnmounted)||h||v)&&W(()=>{_&&Cs(_,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)},ue=(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)},de=(e,t,n,r=!1,i=!1,a=0)=>{for(let o=a;o<e.length;o++)ce(e[o],t,n,r,i)},fe=e=>{if(e.shapeFlag&6)return fe(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},pe=!1,me=(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,pe||=(pe=!0,Kn(r),qn(),!1)},he={p:v,um:ce,m:se,r:I,mt:j,mc:ee,pc:ae,pbc:te,n:fe,o:e},ge,_e;return i&&([ge,_e]=i(he)),{render:me,hydrate:ge,createApp:Ka(me,ge)}}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]=bs(i[e]),a.el=t.el),!n&&a.patchFlag!==-2&&No(t,a)),a.type===Zo&&(a.patchFlag===-1&&(a=i[e]=bs(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,cs(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&&cs(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&&cs(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=>{Nn(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):J(K)}function qo(e){let t;if(g(e)){let n=ns&&e._c;n&&(e._d=!1,es()),e=e(),n&&(e._d=!0,t=q,ts())}return d(e)&&(e=to(e)),e=ys(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=[],q=null;function es(e=!1){$o.push(q=e?null:[])}function ts(){$o.pop(),q=$o[$o.length-1]||null}var ns=1;function rs(e,t=!1){ns+=e,e<0&&q&&t&&(q.hasOnce=!0)}function is(e){return e.dynamicChildren=ns>0?q||n:null,ts(),ns>0&&q&&q.push(e),e}function as(e,t,n,r,i,a){return is(fs(e,t,n,r,i,a,!0))}function os(e,t,n,r,i){return is(J(e,t,n,r,i,!0))}function ss(e){return e?e.__v_isVNode===!0:!1}function cs(e,t){return e.type===t.type&&e.key===t.key}function ls(e){}var us=({key:e})=>e??null,ds=({ref:e,ref_key:t,ref_for:n})=>(typeof e==`number`&&(e=``+e),e==null?null:_(e)||V(e)||g(e)?{i:U,r:e,k:t,f:!!n}:e);function fs(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&&us(t),ref:t&&ds(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?(xs(c,n),a&128&&e.normalize(c)):n&&(c.shapeFlag|=_(n)?8:16),ns>0&&!o&&q&&(c.patchFlag>0||a&6)&&c.patchFlag!==32&&q.push(c),c}var J=ps;function ps(e,t=null,n=null,r=0,i=null,a=!1){if((!e||e===$i)&&(e=K),ss(e)){let r=hs(e,t,!0);return n&&xs(r,n),ns>0&&!a&&q&&(r.shapeFlag&6?q[q.indexOf(e)]=r:q.push(r)),r.patchFlag=-2,r}if(Ks(e)&&(e=e.__vccOpts),t){t=ms(t);let{class:e,style:n}=t;e&&!_(e)&&(t.class=ue(e)),y(n)&&(qt(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 fs(e,t,n,r,i,o,a,!0)}function ms(e){return e?qt(e)||uo(e)?s({},e):e:null}function hs(e,t,n=!1,r=!1){let{props:i,ref:a,patchFlag:o,children:s,transition:c}=e,l=t?Ss(i||{},t):i,u={__v_isVNode:!0,__v_skip:!0,type:e.type,props:l,key:l&&us(l),ref:t&&t.ref?n&&a?d(a)?a.concat(ds(t)):[a,ds(t)]:ds(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&&hs(e.ssContent),ssFallback:e.ssFallback&&hs(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 gs(e=` `,t=0){return J(Zo,null,e,t)}function _s(e,t){let n=J(Qo,null,e);return n.staticCount=t,n}function vs(e=``,t=!1){return t?(es(),os(K,null,e)):J(K,null,e)}function ys(e){return e==null||typeof e==`boolean`?J(K):d(e)?J(G,null,e.slice()):ss(e)?bs(e):J(Zo,null,String(e))}function bs(e){return e.el===null&&e.patchFlag!==-1||e.memo?e:hs(e)}function xs(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),xs(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){xs(e,{default:t});return}t={default:t,_ctx:U},n=32}else t=String(t),r&64?(n=16,t=[gs(t)]):n=8;e.children=t,e.shapeFlag|=n}function Ss(...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=ue([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 Cs(e,t,n,r=null){Mn(e,t,7,[n,r])}var ws=Wa(),Ts=0;function Es(e,n,r){let i=e.type,a=(n?n.appContext:e.appContext)||ws,o={uid:Ts++,vnode:e,type:i,parent:n,appContext:a,root:null,next:null,subTree:null,effect:null,update:null,job:null,scope:new Ce(!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 Y=null,Ds=()=>Y||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=>Y=e),ks=t(`__VUE_SSR_SETTERS__`,e=>Ns=e)}var As=e=>{let t=Y;return Os(e),e.scope.on(),()=>{e.scope.off(),Os(t)}},js=()=>{Y&&Y.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){Ge();let n=e.setupContext=r.length>1?Us(e):null,i=As(e),a=jn(r,e,0,[e.props,n]),o=b(a);if(Ke(),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=>{Nn(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=on(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);Ge();try{Aa(e)}finally{Ke(),t()}}}var Hs={get(e,t){return z(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(on(Jt(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)=>hn(e,t,Ns);function Js(e,t,n){try{rs(-1);let r=arguments.length;return r===2?y(t)&&!d(t)?ss(t)?J(e,null,[t]):J(e,t):J(e,null,t):(r>3?n=Array.prototype.slice.call(arguments,2):r===3&&ss(n)&&(n=[n]),J(e,t,n))}finally{rs(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 ns>0&&q&&q.push(e),!0}var Qs=`3.5.41`,$s=r,ec=An,tc=Xn,nc=Qn,rc={createComponentInstance:Es,setupComponent:Ps,renderComponentRoot:eo,setCurrentRenderingInstance:er,isVNode:ss,normalizeVNode:ys,getComponentPublicInstance:Ws,ensureValidVNode:sa,pushWarningContext:En,popWarningContext:Dn},ic=typeof window<`u`,ac,oc=e=>ac=e,sc=Symbol();function cc(e){return e&&typeof e==`object`&&Object.prototype.toString.call(e)===`[object Object]`&&typeof e.toJSON!=`function`}var lc=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 uc(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 dc(e,t,n){let r=new XMLHttpRequest;r.open(`GET`,e),r.responseType=`blob`,r.onload=function(){gc(r.response,t,n)},r.onerror=function(){console.error(`could not download file`)},r.send()}function fc(e){let t=new XMLHttpRequest;t.open(`HEAD`,e,!1);try{t.send()}catch{}return t.status>=200&&t.status<=299}function pc(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 mc=typeof navigator==`object`?navigator:{userAgent:``},hc=/Macintosh/.test(mc.userAgent)&&/AppleWebKit/.test(mc.userAgent)&&!/Safari/.test(mc.userAgent),gc=ic?typeof HTMLAnchorElement<`u`&&`download`in HTMLAnchorElement.prototype&&!hc?_c:`msSaveOrOpenBlob`in mc?vc:yc:()=>{};function _c(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?pc(r):fc(r.href)?dc(e,t,n):(r.target=`_blank`,pc(r))):(r.href=URL.createObjectURL(e),setTimeout(function(){URL.revokeObjectURL(r.href)},4e4),setTimeout(function(){pc(r)},0))}function vc(e,t=`download`,n){if(typeof e==`string`){if(fc(e))dc(e,t,n);else{let t=document.createElement(`a`);t.href=e,t.target=`_blank`,setTimeout(function(){pc(t)})}}else navigator.msSaveOrOpenBlob(uc(e,n),t)}function yc(e,t,n,r){if(r||=open(``,`_blank`),r&&(r.document.title=r.document.body.innerText=`downloading...`),typeof e==`string`)return dc(e,t,n);let i=e.type===`application/octet-stream`,a=/constructor/i.test(String(lc.HTMLElement))||`safari`in lc,o=/CriOS\/[\d]+/.test(navigator.userAgent);if((o||i&&a||hc)&&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:bc}=Object;function xc(){let e=we(!0),t=e.run(()=>Zt({})),n=[],r=[],i=Jt({install(e){oc(i),i._a=e,e.provide(sc,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 Sc=()=>{};function Cc(e,t,n,r=Sc){e.add(t);let i=()=>{e.delete(t)&&r()};return!n&&Te()&&Ee(i),i}function wc(e,...t){e.forEach(e=>{e(...t)})}var Tc=e=>e(),Ec=Symbol(),Dc=Symbol();function Oc(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]=cc(i)&&cc(r)&&Object.hasOwn(e,n)&&!V(r)&&!Wt(r)?Oc(i,r):r}return e}var kc=Symbol();function Ac(e){return!e||typeof e!=`object`||!Object.hasOwn(e,kc)}var{assign:jc}=Object;function Mc(e){return!!(V(e)&&e.effect)}function Nc(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():{}),jc(ln(n.state.value[e]),a,Object.keys(o||{}).reduce((t,r)=>(t[r]=Jt(qs(()=>{oc(n);let t=n._s.get(e);return o[r].call(t,t)})),t),{}))}return c=Pc(e,l,t,n,r,!0),c}function Pc(e,t,n={},r,i,a){let o,s=jc({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}):(Oc(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,wc(d,n,r.state.value[e])}let _=a?function(){let{state:e}=n,t=e?e():{};this.$patch(e=>{jc(e,t)})}:Sc;function v(){o.stop(),d.clear(),f.clear(),r._s.delete(e)}let y=(t,n=``)=>{if(Ec in t)return t[Dc]=n,t;let i=function(){oc(r);let n=Array.from(arguments),a=new Set,o=new Set;function s(e){a.add(e)}function c(e){o.add(e)}wc(f,{args:n,name:i[Dc],store:b,after:s,onError:c});let l;try{l=t.apply(this&&this.$id===e?this:b,n)}catch(e){throw wc(o,e),e}return l instanceof Promise?l.then(e=>(wc(a,e),e)).catch(e=>(wc(o,e),Promise.reject(e))):(wc(a,l),l)};return i[Ec]=!0,i[Dc]=n,i},b=zt({_p:r,$id:e,$onAction:Cc.bind(null,f),$patch:g,$reset:_,$subscribe(t,n={}){if(d.has(t))return Sc;let i=Cc(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)},jc({},c,n)));return i},$dispose:v});r._s.set(e,b);let x=(r._a&&r._a.runWithContext||Tc)(()=>r._e.run(()=>(o=we()).run(()=>t({action:y}))));for(let t in x){let n=x[t];V(n)&&!Mc(n)||Wt(n)?a||(m&&Ac(n)&&(V(n)?n.value=m[t]:((n instanceof Set||n instanceof Map)&&n.clear(),Oc(n,m[t]))),r.state.value[e][t]=n):typeof n==`function`&&(x[t]=y(n,t),s.actions[t]=n)}return jc(b,x),jc(B(b),x),Object.defineProperty(b,"$state",{get:()=>r.state.value[e],set:e=>{g(t=>{jc(t,e)})}}),r._p.forEach(e=>{let t=o.run(()=>e({store:b,app:r._a,pinia:r,options:s}));jc(b,t)}),m&&a&&n.hydrate&&n.hydrate(b.$state,m),l=!0,u=!0,b}function Fc(e,t,n){let r,i=typeof t==`function`;r=i?n:t;function a(n,a){let o=lr();return n||=o?cr(sc,null):null,n&&oc(n),n=ac,n._s.has(e)||(i?Pc(e,t,r,n):Nc(e,r,n)),n._s.get(e)}return a.$id=e,a}function Ic(e){let t=B(e),n={};for(let r in t){let i=t[r];i?.effect?n[r]=qs({get:()=>e[r],set(t){e[r]=t}}):(V(i)||Wt(i))&&(n[r]=fn(e,r))}return n}var Lc={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`]},Rc={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`]},zc={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`]},Bc={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`]},Vc={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`]},Hc={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`]},Uc={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`]},Wc={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`]},Gc={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`]},Kc={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`]},qc={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`]},Jc={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`]},Yc={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`]},Xc={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`]},Zc={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`]},Qc={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`]},$c={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`]},el={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`]},tl={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`]},nl={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`]},rl={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`]},il={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`]},al={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`]},ol={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`]},sl={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`]},cl={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`]},ll={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`]},ul={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 dl(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=dl(e[t]))&&(r&&(r+=` `),r+=n)}else for(n in e)e[n]&&(r&&(r+=` `),r+=n)}return r}function fl(){for(var e,t,n=0,r=``,i=arguments.length;n<i;n++)(e=arguments[n])&&(t=dl(e))&&(r&&(r+=` `),r+=t);return r}var pl=e=>typeof e==`boolean`?`${e}`:e===0?`0`:e,ml=fl,hl=(e,t)=>n=>{if(t?.variants==null)return ml(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=pl(t)||pl(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 ml(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)},gl=(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},_l=(e,t)=>({classGroupId:e,validator:t}),vl=(e=new Map,t=null,n)=>({nextPart:e,validators:t,classGroupId:n}),yl=`-`,bl=[],xl=`arbitrary..`,Sl=e=>{let t=Tl(e),{conflictingClassGroups:n,conflictingClassGroupModifiers:r}=e;return{getClassGroupId:e=>{if(e.startsWith(`[`)&&e.endsWith(`]`))return wl(e);let n=e.split(yl);return Cl(n,+(n[0]===``&&n.length>1),t)},getConflictingClassGroupIds:(e,t)=>{if(t){let t=r[e],i=n[e];return t?i?gl(i,t):t:i||bl}return n[e]||bl}}},Cl=(e,t,n)=>{if(e.length-t===0)return n.classGroupId;let r=e[t],i=n.nextPart.get(r);if(i){let n=Cl(e,t+1,i);if(n)return n}let a=n.validators;if(a===null)return;let o=t===0?e.join(yl):e.slice(t).join(yl),s=a.length;for(let e=0;e<s;e++){let t=a[e];if(t.validator(o))return t.classGroupId}},wl=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?xl+r:void 0})(),Tl=e=>{let{theme:t,classGroups:n}=e;return El(n,t)},El=(e,t)=>{let n=vl();for(let r in e){let i=e[r];Dl(i,n,r,t)}return n},Dl=(e,t,n,r)=>{let i=e.length;for(let a=0;a<i;a++){let i=e[a];Ol(i,t,n,r)}},Ol=(e,t,n,r)=>{if(typeof e==`string`){kl(e,t,n);return}if(typeof e==`function`){Al(e,t,n,r);return}jl(e,t,n,r)},kl=(e,t,n)=>{let r=e===``?t:Ml(t,e);r.classGroupId=n},Al=(e,t,n,r)=>{if(Nl(e)){Dl(e(r),t,n,r);return}t.validators===null&&(t.validators=[]),t.validators.push(_l(n,e))},jl=(e,t,n,r)=>{let i=Object.entries(e),a=i.length;for(let e=0;e<a;e++){let[a,o]=i[e];Dl(o,Ml(t,a),n,r)}},Ml=(e,t)=>{let n=e,r=t.split(yl),i=r.length;for(let e=0;e<i;e++){let t=r[e],i=n.nextPart.get(t);i||(i=vl(),n.nextPart.set(t,i)),n=i}return n},Nl=e=>`isThemeGetter`in e&&e.isThemeGetter===!0,Pl=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)}}},Fl=`!`,Il=`:`,Ll=[],Rl=(e,t,n,r,i)=>({modifiers:e,hasImportantModifier:t,baseClassName:n,maybePostfixModifierPosition:r,isExternal:i}),zl=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===Il){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(Fl)?(c=s.slice(0,-1),l=!0):s.startsWith(Fl)&&(c=s.slice(1),l=!0);let u=a&&a>i?a-i:void 0;return Rl(t,l,c,u)};if(t){let e=t+Il,n=r;r=t=>t.startsWith(e)?n(t.slice(e.length)):Rl(Ll,!1,t,void 0,!0)}if(n){let e=r;r=t=>n({className:t,parseClassName:e})}return r},Bl=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}},Vl=e=>({cache:Pl(e.cacheSize),parseClassName:zl(e),sortModifiers:Bl(e),postfixLookupClassGroupIds:Hl(e),...Sl(e)}),Hl=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},Ul=/\s+/,Wl=(e,t)=>{let{parseClassName:n,getClassGroupId:r,getConflictingClassGroupIds:i,sortModifiers:a,postfixLookupClassGroupIds:o}=t,s=[],c=e.trim().split(Ul),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?_+Fl:_,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},Gl=(...e)=>{let t=0,n,r,i=``;for(;t<e.length;)(n=e[t++])&&(r=Kl(n))&&(i&&(i+=` `),i+=r);return i},Kl=e=>{if(typeof e==`string`)return e;let t,n=``;for(let r=0;r<e.length;r++)e[r]&&(t=Kl(e[r]))&&(n&&(n+=` `),n+=t);return n},ql=(e,...t)=>{let n,r,i,a,o=o=>(n=Vl(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=Wl(e,n);return i(e,a),a};return a=o,(...e)=>a(Gl(...e))},Jl=[],X=e=>{let t=t=>t[e]||Jl;return t.isThemeGetter=!0,t},Yl=/^\[(?:(\w[\w-]*):)?(.+)\]$/i,Xl=/^\((?:(\w[\w-]*):)?(.+)\)$/i,Zl=/^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/,Ql=/^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/,$l=/\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$/,eu=/^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/,tu=/^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/,nu=/^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/,ru=e=>Zl.test(e),Z=e=>!!e&&!Number.isNaN(Number(e)),iu=e=>!!e&&Number.isInteger(Number(e)),au=e=>e.endsWith(`%`)&&Z(e.slice(0,-1)),ou=e=>Ql.test(e),su=()=>!0,cu=e=>$l.test(e)&&!eu.test(e),lu=()=>!1,uu=e=>tu.test(e),du=e=>nu.test(e),fu=e=>!Q(e)&&!$(e),pu=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)),mu=e=>ku(e,Nu,lu),Q=e=>Yl.test(e),hu=e=>ku(e,Pu,cu),gu=e=>ku(e,Fu,Z),_u=e=>ku(e,Lu,su),vu=e=>ku(e,Iu,lu),yu=e=>ku(e,ju,lu),bu=e=>ku(e,Mu,du),xu=e=>ku(e,Ru,uu),$=e=>Xl.test(e),Su=e=>Au(e,Pu),Cu=e=>Au(e,Iu),wu=e=>Au(e,ju),Tu=e=>Au(e,Nu),Eu=e=>Au(e,Mu),Du=e=>Au(e,Ru,!0),Ou=e=>Au(e,Lu,!0),ku=(e,t,n)=>{let r=Yl.exec(e);return r?r[1]?t(r[1]):n(r[2]):!1},Au=(e,t,n=!1)=>{let r=Xl.exec(e);return r?r[1]?t(r[1]):n:!1},ju=e=>e===`position`||e===`percentage`,Mu=e=>e===`image`||e===`url`,Nu=e=>e===`length`||e===`size`||e===`bg-size`,Pu=e=>e===`length`,Fu=e=>e===`number`,Iu=e=>e===`family-name`,Lu=e=>e===`number`||e===`weight`,Ru=e=>e===`shadow`,zu=ql(()=>{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=()=>[ru,`full`,`auto`,...w()],E=()=>[iu,`none`,`subgrid`,$,Q],D=()=>[`auto`,{span:[`full`,iu,$,Q]},iu,$,Q],ee=()=>[iu,`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=()=>[ru,`auto`,`full`,`dvw`,`dvh`,`lvw`,`lvh`,`svw`,`svh`,`min`,`max`,`fit`,...w()],j=()=>[ru,`screen`,`full`,`dvw`,`lvw`,`svw`,`min`,`max`,`fit`,...w()],M=()=>[ru,`screen`,`full`,`lh`,`dvh`,`lvh`,`svh`,`min`,`max`,`fit`,...w()],N=()=>[e,$,Q],re=()=>[...b(),wu,yu,{position:[$,Q]}],ie=()=>[`no-repeat`,{repeat:[``,`x`,`y`,`space`,`round`]}],ae=()=>[`auto`,`cover`,`contain`,Tu,mu,{size:[$,Q]}],oe=()=>[au,Su,hu],P=()=>[``,`none`,`full`,l,$,Q],F=()=>[``,Z,Su,hu],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,au,wu,yu],le=()=>[``,`none`,m,$,Q],ue=()=>[`none`,Z,$,Q],de=()=>[`none`,Z,$,Q],fe=()=>[Z,$,Q],pe=()=>[ru,`full`,...w()];return{cacheSize:500,theme:{animate:[`spin`,`ping`,`pulse`,`bounce`],aspect:[`video`],blur:[ou],breakpoint:[ou],color:[su],container:[ou],"drop-shadow":[ou],ease:[`in`,`out`,`in-out`],font:[fu],"font-weight":[`thin`,`extralight`,`light`,`normal`,`medium`,`semibold`,`bold`,`extrabold`,`black`],"inset-shadow":[ou],leading:[`none`,`tight`,`snug`,`normal`,`relaxed`,`loose`],perspective:[`dramatic`,`near`,`normal`,`midrange`,`distant`,`none`],radius:[ou],shadow:[ou],spacing:[`px`,Z],text:[ou],"text-shadow":[ou],tracking:[`tighter`,`tight`,`normal`,`wide`,`wider`,`widest`]},classGroups:{aspect:[{aspect:[`auto`,`square`,ru,Q,$,g]}],container:[`container`],"container-type":[{"@container":[``,`normal`,`size`,$,Q]}],"container-named":[pu],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:[iu,`auto`,$,Q]}],basis:[{basis:[ru,`full`,`auto`,s,...w()]}],"flex-direction":[{flex:[`row`,`row-reverse`,`col`,`col-reverse`]}],"flex-wrap":[{flex:[`nowrap`,`wrap`,`wrap-reverse`]}],flex:[{flex:[Z,ru,`auto`,`initial`,`none`,Q]}],grow:[{grow:[``,Z,$,Q]}],shrink:[{shrink:[``,Z,$,Q]}],order:[{order:[iu,`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,Su,hu]}],"font-smoothing":[`antialiased`,`subpixel-antialiased`],"font-style":[`italic`,`not-italic`],"font-weight":[{font:[r,Ou,_u]}],"font-stretch":[{"font-stretch":[`ultra-condensed`,`extra-condensed`,`condensed`,`semi-condensed`,`normal`,`semi-expanded`,`expanded`,`extra-expanded`,`ultra-expanded`,au,Q]}],"font-family":[{font:[Cu,vu,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`,$,gu]}],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`,$,hu]}],"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:[iu,$,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`]},iu,$,Q],radial:[``,$,Q],conic:[iu,$,Q]},Eu,bu]}],"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,Su,hu]}],"outline-color":[{outline:N()}],shadow:[{shadow:[``,`none`,u,Du,xu]}],"shadow-color":[{shadow:N()}],"inset-shadow":[{"inset-shadow":[`none`,d,Du,xu]}],"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,hu]}],"ring-offset-color":[{"ring-offset":N()}],"inset-ring-w":[{"inset-ring":F()}],"inset-ring-color":[{"inset-ring":N()}],"text-shadow":[{"text-shadow":[`none`,f,Du,xu]}],"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,Du,xu]}],"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:ue()}],"rotate-x":[{"rotate-x":ue()}],"rotate-y":[{"rotate-y":ue()}],"rotate-z":[{"rotate-z":ue()}],scale:[{scale:de()}],"scale-x":[{"scale-x":de()}],"scale-y":[{"scale-y":de()}],"scale-z":[{"scale-z":de()}],"scale-3d":[`scale-3d`],skew:[{skew:fe()}],"skew-x":[{"skew-x":fe()}],"skew-y":[{"skew-y":fe()}],transform:[{transform:[$,Q,``,`none`,`gpu`,`cpu`]}],"transform-origin":[{origin:x()}],"transform-style":[{transform:[`3d`,`flat`]}],translate:[{translate:pe()}],"translate-x":[{"translate-x":pe()}],"translate-y":[{"translate-y":pe()}],"translate-z":[{"translate-z":pe()}],"translate-none":[`translate-none`],zoom:[{zoom:[iu,$,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,Su,hu,gu]}],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 Bu(...e){return zu(fl(e))}function Vu(e,t){return Te()?(Ee(e,t),!0):!1}function Hu(e){let t=!1,n,r=we(!0);return((...i)=>(t||=(n=r.run(()=>e(...i)),!0),n))}var Uu=typeof window<`u`&&typeof document<`u`;typeof WorkerGlobalScope<`u`&&globalThis instanceof WorkerGlobalScope;var Wu=e=>e!==void 0,Gu=Object.prototype.toString,Ku=e=>Gu.call(e)===`[object Object]`,qu=Ju();function Ju(){var e,t;return Uu&&!!((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 Yu(e){return Array.isArray(e)?e:[e]}function Xu(e){return e||Ds()}function Zu(e){if(!Uu)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=we(!0),n=r.run(()=>e(...a))),Vu(i),n))}function Qu(e){return zt(V(e)?new Proxy({},{get(t,n,r){return nn(Reflect.get(e.value,n,r))},set(t,n,r){return V(e.value[n])&&!V(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 $u(e){return Qu(qs(e))}function ed(e,...t){let n=t.flat(),r=n[0];return $u(()=>Object.fromEntries(typeof r==`function`?Object.entries(ln(e)).filter(([e,t])=>!r(rn(t),e)):Object.entries(ln(e)).filter(e=>!n.includes(e[0]))))}function td(e,t=1e4){return cn((n,r)=>{let i=rn(e),a,o=()=>setTimeout(()=>{i=rn(e),r()},rn(t));return Vu(()=>{clearTimeout(a)}),{get(){return n(),i},set(e){i=e,r(),clearTimeout(a),a=o()}}})}function nd(e,t){Xu(t)&&Wi(e,t)}function rd(e,t,n){return hr(e,t,{...n,immediate:!0})}function id(e){return e?e.flatMap(e=>e.type===G?id(e.children):[e]):[]}var ad=Jr({name:`PrimitiveSlot`,inheritAttrs:!1,setup(e,{attrs:t,slots:n}){return()=>{if(!n.default)return null;let e=id(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?Ss(t,i.props):t,o=hs({...i,props:{}},a);return e.length===1?o:(e[r]=o,e)}}}),od=[`area`,`img`,`input`],sd=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`&&od.includes(r)?()=>Js(r,t):r===`template`?()=>Js(ad,t,{default:n.default}):()=>Js(e.as,t,{default:n.default})}}),cd=[`data-size`],ld=Jr({__name:`Card`,props:{class:{type:[Boolean,null,String,Object,Array]},size:{default:`default`}},setup(e){let t=e;return(n,r)=>(es(),as(`div`,{"data-slot":`card`,"data-size":e.size,class:ue(nn(Bu)(`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,cd))}}),ud=Jr({__name:`CardContent`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(es(),as(`div`,{"data-slot":`card-content`,class:ue(nn(Bu)(`px-4 group-data-[size=sm]/card:px-3`,t.class))},[oa(e.$slots,`default`)],2))}}),dd=Jr({__name:`CardHeader`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(es(),as(`div`,{"data-slot":`card-header`,class:ue(nn(Bu)(`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))}}),fd=Jr({__name:`CardTitle`,props:{class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e;return(e,n)=>(es(),as(`div`,{"data-slot":`card-title`,class:ue(nn(Bu)(`text-base leading-snug font-medium group-data-[size=sm]/card:text-sm font-heading`,t.class))},[oa(e.$slots,`default`)],2))}}),pd=`llmgwAdminKey`;function md(){try{return sessionStorage.getItem(pd)??``}catch{return``}}function hd(e){try{sessionStorage.setItem(pd,e)}catch{}}function gd(){try{sessionStorage.removeItem(pd)}catch{}}var _d=Fc(`auth`,{state:()=>({apiKey:md(),error:``}),getters:{isAuthenticated:e=>e.apiKey!==``},actions:{submit(e){e&&(this.apiKey=e,this.error=``,hd(e))},reject(e){this.apiKey=``,this.error=e,gd()}}}),vd=class extends Error{status;constructor(e,t){super(e),this.name=`AdminApiError`,this.status=t}};async function yd(e,t){let n=`${t}: HTTP ${e.status}`;try{return(await e.json()).error?.message||n}catch{return n}}async function bd(e){let t=_d(),n=t.apiKey,r=await fetch(e,{credentials:`same-origin`,headers:n?{"x-api-key":n}:{}});if(!r.ok){let i=await yd(r,e);throw(r.status===401||r.status===403)&&t.apiKey===n&&t.reject(`invalid key, or not an admin`),new vd(i,r.status)}return await r.json()}function xd(e){return e||(typeof document>`u`?void 0:document)}function Sd({intervalMs:e,tick:t,doc:n}){let r=xd(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 Cd=5e3,wd=Fc(`dashboard`,{state:()=>({overview:null,usage:null,targets:null,lastUpdated:null,error:``,poller:void 0,refreshing:!1}),actions:{async refresh(){if(_d().isAuthenticated&&!this.refreshing){this.refreshing=!0;try{await this.doRefresh()}finally{this.refreshing=!1}}},async doRefresh(){let[e,t,n]=await Promise.allSettled([bd(`/admin/api/overview`),bd(`/admin/api/usage`),bd(`/admin/api/targets`)]);e.status===`fulfilled`&&(this.overview=e.value),t.status===`fulfilled`&&(this.usage=t.value),n.status===`fulfilled`&&(this.targets=n.value);let r=[];if(e.status===`rejected`&&r.push({label:`overview`,reason:e.reason}),t.status===`rejected`&&r.push({label:`usage`,reason:t.reason}),n.status===`rejected`&&r.push({label:`targets`,reason:n.reason}),r.length===0){this.lastUpdated=new Date,this.error=``;return}r.some(({reason:e})=>e instanceof vd&&(e.status===401||e.status===403))||(r.length<3&&(this.lastUpdated=new Date),this.error=r.map(({label:e,reason:t})=>`${e}: ${t instanceof Error?t.message:String(t)}`).join(`; `))},startPolling(){this.poller||(this.poller=Sd({intervalMs:Cd,tick:()=>void this.refresh()}),this.poller.start())}}}),Td=[`home`,`spend`,`consumers`,`models`,`reliability`,`config`,`targets`],Ed=`home`,Dd=[{id:`home`,label:`Home`,icon:Jc},{id:`spend`,label:`Spend`,icon:ll},{id:`consumers`,label:`Consumers`,icon:Uc},{id:`models`,label:`Models`,icon:$c},{id:`reliability`,label:`Reliability`,icon:Wc},{id:`config`,label:`Config`,icon:Yc},{id:`targets`,label:`MCP & Agents`,icon:tl}];function Od(e){return Td.includes(e)}var kd=[`24h`,`48h`,`7d`,`14d`,`30d`,`3mo`,`6mo`,`12mo`],Ad={"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}},jd={hour:48,day:35,month:13},Md=[`none`,`prev`],Nd=`none`;function Pd(e){let{window:t,span:n}=Ad[e],r=jd[t];return 2*n>r?{available:!1,offset:n,reason:`retention limit`}:{available:!0,offset:n}}function Fd(e,t){return e===`month`?{window:`month`,span:t}:e===`day`?{window:`day`,span:t}:{window:`day`,span:7}}function Id(e,t){return e===`hour`?`Showing last ${Fd(e,t).span} days — per-hour data is not kept for this view.`:null}function Ld(e){return kd.includes(e)}function Rd(e){return Md.includes(e)}function zd(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 Bd(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 Vd=Fc(`nav`,{state:()=>({page:Ed,params:{}}),actions:{goTo(e,t={}){this.page=e,this.params=t}}});export{sl as $,fr as $n,w as $r,bi as $t,Wu as A,ia as An,Ht as Ar,as as At,hl as B,rc as Bn,r as Br,ha as Bt,ld as C,Ui as Cn,Ee as Cr,Mn as Ct,Hu as D,tr as Dn,Vt as Dr,fs as Dt,id as E,sr as En,zt as Er,qs as Et,Yu as F,Ur as Fn,ln as Fr,_s as Ft,el as G,Ja as Gn,k as Gr,va as Gt,il as H,ls as Hn,A as Hr,ya as Ht,nd as I,rs as In,rn as Ir,gs as It,Qc as J,Zr as Jn,d as Jr,qr as Jt,Hc as K,dr as Kn,me as Kr,tc as Kt,Vu as L,nc as Ln,tn as Lr,J as Lt,Ku as M,Qi as Mn,He as Mr,Da as Mt,ed as N,ta as Nn,B as Nr,Do as Nt,Zu as O,Gn as On,Zt as Or,os as Ot,td as P,ea as Pn,fn as Pr,aa as Pt,Bc as Q,hr as Qn,a as Qr,lr as Qt,rd as R,Kr as Rn,nn as Rr,Di as Rt,ud as S,Gi as Sn,Jt as Sr,On as St,ad as T,nr as Tn,on as Tr,hs as Tt,cl as U,Sa as Un,s as Ur,_a as Ut,al as V,ca as Vn,O as Vr,ga as Vt,qc as W,Yr as Wn,u as Wr,ma as Wt,Gc as X,Qs as Xn,o as Xr,Js as Xt,Kc as Y,Fr as Yn,g as Yr,ms as Yt,ol as Z,$s as Zn,y as Zr,Nn as Zt,vd as _,Yi as _n,qt as _r,Ai as _t,Pd as a,_e as ai,Zs as an,ar,zc as at,fd as b,qi as bn,V as br,Ar as bt,Rd as c,Se as ci,Ta as cn,Ce as cr,xc as ct,Bd as d,ye as di,Vn as dn,_n as dr,Vr as dt,p as ei,wi as en,pr as er,nl as et,Ed as f,ne as fi,Mi as fn,cn as fr,Lr as ft,Sd as g,Ni as gn,xn as gr,G as gt,wd as h,Hi as hn,Te as hr,ec as ht,Ad as i,ge as ii,cr as in,ba as ir,ul as it,qu as j,oa as jn,Qt as jr,Oo as jt,Uu as k,zs as kn,Bt as kr,vs as kt,Ld as l,de as li,Ea as ln,Oe as lr,Fc as lt,Od as m,Wi as mn,we as mr,kn as mt,Nd as n,_ as ni,Si as nn,Oa as nr,Lc as nt,Id as o,re as oi,Bs as on,Xs as or,rl as ot,Dd as p,ie as pi,Bi as pn,Ve as pr,K as pt,Vc as q,xa as qn,M as qr,Ds as qt,kd as r,v as ri,Ys as rn,ir as rr,Xc as rt,Fd as s,ue as si,ss as sn,rr as sr,Zc as st,Vd as t,pe as ti,Ci as tn,mr as tr,Rc as tt,zd as u,F as ui,Ss as un,gn as ur,Ic as ut,bd as v,Vi as vn,Wt as vr,Qo as vt,sd as w,es as wn,Sn as wr,jn as wt,dd as x,Ki as xn,Kt as xr,Zo as xt,_d as y,Ji as yn,Gt as yr,Bo as yt,Bu as z,ur as zn,t as zr,Jr as zt};",
+		),
+	},
+	"provider-rate-DU7OgSeB.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"ZnVuY3Rpb24gZShlLHQpe3JldHVybiFOdW1iZXIuaXNGaW5pdGUoZSl8fGU8PTA/bnVsbDooZS0oTnVtYmVyLmlzRmluaXRlKHQpP3Q6MCkpL2V9ZnVuY3Rpb24gdChlKXtyZXR1cm4gZT09PW51bGw/YG5vLXRyYWZmaWNgOmU8Ljk/YHNldmVyZWA6ZTwuOTk/YGRlZ3JhZGVkYDpgaGVhbHRoeWB9ZnVuY3Rpb24gbih0LG4pe2xldCByPWUodCxuKTtyZXR1cm4gciE9PW51bGwmJnI8Ljk5fWZ1bmN0aW9uIHIoZSl7cmV0dXJuIGU+PTE/YDEwMCVgOmAke01hdGguZmxvb3IoZSoxMDApfSVgfWZ1bmN0aW9uIGkoZSx0KXtyZXR1cm4hTnVtYmVyLmlzRmluaXRlKGUpfHxlPD0wP251bGw6KE51bWJlci5pc0Zpbml0ZSh0KT90OjApL2V9ZnVuY3Rpb24gYShlKXtyZXR1cm4gZT09PW51bGw/YG5vIGRhdGFgOmU8PTA/YDAlYDpgJHtNYXRoLmNlaWwoZSoxMDApfSVgfWZ1bmN0aW9uIG8oZSx0LG4pe3JldHVybiBlPT09MT90Om59ZnVuY3Rpb24gcyh0LG4pe2lmKHQ8PTApcmV0dXJuYG5vIHRyYWZmaWMgaW4gdGhlIGxhc3QgbWludXRlYDtsZXQgaT1lKHQsbiksYT1pPT09bnVsbD9gYDpgICgke3IoaSl9KWA7cmV0dXJuYCR7dH0gJHtvKHQsYGF0dGVtcHRgLGBhdHRlbXB0c2ApfSwgJHtufSAke28obixgZmFpbHVyZWAsYGZhaWx1cmVzYCl9IGluIHRoZSBsYXN0IG1pbnV0ZSR7YX1gfWZ1bmN0aW9uIGModCxuKXtpZih0PD0wKXJldHVybmBubyB0cmFmZmljIHRvZGF5YDtsZXQgaT1lKHQsbiksYT1pPT09bnVsbD9gYDpgICgke3IoaSl9KWA7cmV0dXJuYCR7dH0gJHtvKHQsYGF0dGVtcHRgLGBhdHRlbXB0c2ApfSwgJHtufSAke28obixgZmFpbHVyZWAsYGZhaWx1cmVzYCl9IHRvZGF5JHthfWB9ZXhwb3J0e3MgYXMgYSxlIGFzIGMsbiBhcyBpLGEgYXMgbixpIGFzIG8scix0IGFzIHMsYyBhcyB0fTs=",
+		),
+	},
+	"reliability-0KiJSjTP.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"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",
+		),
+	},
+	"search-expand-B1qnK1H5.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{a as e,c as t,i as n,l as r,n as i,o as a,r as o,t as s,u as c}from"./Presence-CuQUGFyS.js";import{Dt as l,Et as u,Fr as d,G as f,Jn as p,Lt as m,Mn as h,N as g,Or as _,Ot as v,Qn as y,Rr as b,Sn as x,W as S,Yt as C,Z as w,di as ee,dn as te,jn as T,kt as E,li as D,ot as ne,q as re,rr as O,si as k,un as A,vn as j,w as M,wn as N,z as P,zt as F}from"./nav-Dzb0OTN_.js";import{P as ie,l as I,o as L}from"./CardDescription-IdOt317c.js";import{t as R}from"./clipboard-B73fZ0c1.js";import{a as z,d as B,t as V}from"./badge-ns0j8OUr.js";function H(e,n){return t(e)?!1:Array.isArray(e)?e.some(e=>c(e,n)):c(e,n)}var U=[`INPUT`,`TEXTAREA`];function W(e,t,n,r={}){if(!t||r.enableIgnoredElement&&U.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=G(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 G(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`?G(e,o,n,r):o:null}var[K,q]=r(`CollapsibleRoot`),J=F({__name:`CollapsibleRoot`,props:{defaultOpen:{type:Boolean,required:!1,default:!1},open:{type:Boolean,required:!1,default:void 0},disabled:{type:Boolean,required:!1},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`update:open`],setup(t,{expose:n,emit:r}){let i=t,a=I(i,`open`,r,{defaultValue:i.defaultOpen,passive:i.open===void 0}),{disabled:o,unmountOnHide:s}=d(i);return q({contentId:``,disabled:o,open:a,unmountOnHide:s,onOpenToggle:()=>{o.value||(a.value=!a.value)}}),n({open:a}),e(),(e,t)=>(N(),v(b(M),{as:e.as,"as-child":i.asChild,"data-state":b(a)?`open`:`closed`,"data-disabled":b(o)?``:void 0},{default:O(()=>[T(e.$slots,`default`,{open:b(a)})]),_:3},8,[`as`,`as-child`,`data-state`,`data-disabled`]))}}),Y=F({inheritAttrs:!1,__name:`CollapsibleContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`contentFound`],setup(t,{emit:n}){let r=t,a=n,o=K();o.contentId||=i(void 0,`reka-collapsible-content`);let c=_(),{forwardRef:l,currentElement:d}=e(),f=_(0),p=_(0),h=u(()=>o.open.value),g=_(h.value),x=_();y(()=>[h.value,c.value?.present],async()=>{await te();let e=d.value;if(!e)return;x.value=x.value||{transitionDuration:e.style.transitionDuration,animationName:e.style.animationName},e.style.transitionDuration=`0s`,e.style.animationName=`none`;let t=e.getBoundingClientRect();p.value=t.height,f.value=t.width,g.value||(e.style.transitionDuration=x.value.transitionDuration,e.style.animationName=x.value.animationName)},{immediate:!0});let S=u(()=>g.value&&o.open.value);return j(()=>{requestAnimationFrame(()=>{g.value=!1})}),L(d,`beforematch`,e=>{requestAnimationFrame(()=>{o.onOpenToggle(),a(`contentFound`)})}),(e,t)=>(N(),v(b(s),{ref_key:`presentRef`,ref:c,present:e.forceMount||b(o).open.value,"force-mount":!0},{default:O(({present:t})=>[m(b(M),A(e.$attrs,{id:b(o).contentId,ref:b(l),"as-child":r.asChild,as:e.as,hidden:t?void 0:b(o).unmountOnHide.value?``:`until-found`,"data-state":S.value?void 0:b(o).open.value?`open`:`closed`,"data-disabled":b(o).disabled?.value?``:void 0,style:{"--reka-collapsible-content-height":`${p.value}px`,"--reka-collapsible-content-width":`${f.value}px`}}),{default:O(()=>[!b(o).unmountOnHide.value||t?T(e.$slots,`default`,{key:0}):E(`v-if`,!0)]),_:2},1040,[`id`,`as-child`,`as`,`hidden`,`data-state`,`data-disabled`,`style`])]),_:3},8,[`present`]))}}),ae=F({__name:`CollapsibleTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`button`}},setup(t){let n=t;e();let r=K();return(e,t)=>(N(),v(b(M),{type:e.as===`button`?`button`:void 0,as:e.as,"as-child":n.asChild,"aria-controls":b(r).contentId,"aria-expanded":b(r).open.value,"data-state":b(r).open.value?`open`:`closed`,"data-disabled":b(r).disabled?.value?``:void 0,disabled:b(r).disabled?.value,onClick:b(r).onOpenToggle},{default:O(()=>[T(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=u(()=>se(e)),r=I(e,`modelValue`,t,{defaultValue:ce(e),passive:e.modelValue===void 0,deep:!0});function i(e){if(n.value===`single`)r.value=c(e,r.value)?void 0:e;else{let t=Array.isArray(r.value)?[...r.value||[]]:[r.value].filter(Boolean);if(H(t,e)){let n=t.findIndex(t=>c(t,e));t.splice(n,1)}else t.push(e);r.value=t}}return{modelValue:r,changeModelValue:i,isSingle:u(()=>n.value===`single`)}}var[X,ue]=r(`AccordionRoot`),de=F({__name:`AccordionRoot`,props:{collapsible:{type:Boolean,required:!1,default:!1},disabled:{type:Boolean,required:!1,default:!1},dir:{type:String,required:!1},orientation:{type:String,required:!1,default:`vertical`},unmountOnHide:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1},type:{type:String,required:!1},modelValue:{type:null,required:!1},defaultValue:{type:null,required:!1}},emits:[`update:modelValue`],setup(t,{emit:n}){let r=t,i=n,{dir:o,disabled:s,unmountOnHide:c}=d(r),l=a(o),{modelValue:u,changeModelValue:f,isSingle:p}=le(r,i),{forwardRef:m,currentElement:h}=e();return ue({disabled:s,direction:l,orientation:r.orientation,parentElement:h,isSingle:p,collapsible:r.collapsible,modelValue:u,changeModelValue:f,unmountOnHide:c}),(e,t)=>(N(),v(b(M),{ref:b(m),"as-child":e.asChild,as:e.as},{default:O(()=>[T(e.$slots,`default`,{modelValue:b(u)})]),_:3},8,[`as-child`,`as`]))}}),Z=function(e){return e.Open=`open`,e.Closed=`closed`,e}(Z||{}),[Q,fe]=r(`AccordionItem`),pe=F({__name:`AccordionItem`,props:{disabled:{type:Boolean,required:!1},value:{type:String,required:!0},unmountOnHide:{type:Boolean,required:!1,default:void 0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(t,{expose:n}){let r=t,i=X(),a=u(()=>i.isSingle.value?r.value===i.modelValue.value:Array.isArray(i.modelValue.value)&&i.modelValue.value.includes(r.value)),o=u(()=>i.disabled.value||r.disabled),s=u(()=>o.value?``:void 0),c=u(()=>a.value?Z.Open:Z.Closed);n({open:a,dataDisabled:s});let{currentRef:l,currentElement:d}=e();fe({open:a,dataState:c,disabled:o,dataDisabled:s,triggerId:``,currentRef:l,currentElement:d,value:u(()=>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;W(e,t,i.parentElement.value,{arrowKeyOptions:i.orientation,dir:i.direction.value,focus:!0})}return(e,t)=>(N(),v(b(J),{"data-orientation":b(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??b(i).unmountOnHide.value,onKeydown:ie(f,[`up`,`down`,`left`,`right`,`home`,`end`])},{default:O(()=>[T(e.$slots,`default`,{open:a.value})]),_:3},8,[`data-orientation`,`data-disabled`,`data-state`,`disabled`,`open`,`as`,`as-child`,`unmount-on-hide`]))}}),me=F({__name:`AccordionContent`,props:{forceMount:{type:Boolean,required:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(t){let n=t,r=X(),i=Q();return e(),(e,t)=>(N(),v(b(Y),{role:`region`,"as-child":n.asChild,as:e.as,"force-mount":n.forceMount,"aria-labelledby":b(i).triggerId,"data-state":b(i).dataState.value,"data-disabled":b(i).dataDisabled.value,"data-orientation":b(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=>b(r).changeModelValue(b(i).value.value)},{default:O(()=>[T(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`force-mount`,`aria-labelledby`,`data-state`,`data-disabled`,`data-orientation`]))}}),he=F({__name:`AccordionHeader`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1,default:`h3`}},setup(t){let n=t,r=X(),i=Q();return e(),(e,t)=>(N(),v(b(M),{as:n.as,"as-child":n.asChild,"data-orientation":b(r).orientation,"data-state":b(i).dataState.value,"data-disabled":b(i).dataDisabled.value},{default:O(()=>[T(e.$slots,`default`)]),_:3},8,[`as`,`as-child`,`data-orientation`,`data-state`,`data-disabled`]))}}),ge=F({__name:`AccordionTrigger`,props:{asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(e){let t=e,n=X(),r=Q();r.triggerId||=i(void 0,`reka-accordion-trigger`);function a(){let e=n.isSingle.value&&r.open.value&&!n.collapsible;r.disabled.value||e||n.changeModelValue(r.value.value)}return(e,i)=>(N(),v(b(ae),{id:b(r).triggerId,ref:b(r).currentRef,"data-reka-collection-item":``,as:t.as,"as-child":t.asChild,"aria-disabled":b(r).disabled.value||void 0,"aria-expanded":b(r).open.value||!1,"data-disabled":b(r).dataDisabled.value,"data-orientation":b(n).orientation,"data-state":b(r).dataState.value,disabled:b(r).disabled.value,onClick:a},{default:O(()=>[T(e.$slots,`default`)]),_:3},8,[`id`,`as`,`as-child`,`aria-disabled`,`aria-expanded`,`data-disabled`,`data-orientation`,`data-state`,`disabled`]))}}),$=F({__name:`ModelChip`,props:{id:{},contextTokens:{},inputPerMTokUsd:{},outputPerMTokUsd:{}},setup(e){let t=e,n=p(`label`),r=_(`idle`),i;function a(){clearTimeout(i),i=setTimeout(()=>{r.value=`idle`},1500)}async function o(){let e=await R(t.id,n.value??void 0);r.value=e,a()}let s={idle:w,copied:S,selected:S,failed:ne},c=u(()=>({idle:`Copy ${t.id}`,copied:`Copied`,selected:`Selected — press Ctrl/Cmd+C`,failed:`Copy failed`})),d=u(()=>{let e=[];return t.inputPerMTokUsd!==void 0&&t.outputPerMTokUsd!==void 0&&e.push(B(t.inputPerMTokUsd,t.outputPerMTokUsd)),t.contextTokens!==void 0&&e.push(`${z(t.contextTokens)} context`),e.join(` · `)}),f=u(()=>{let e=c.value[r.value];return d.value?`${e} · ${d.value}`:e});return x(()=>{clearTimeout(i)}),(t,n)=>{let i=h(`FontAwesomeIcon`);return N(),v(b(V),{as:`button`,type:`button`,variant:`secondary`,class:k([`cursor-pointer gap-1 font-mono text-xs font-normal transition-colors hover:bg-accent hover:text-accent-foreground`,r.value===`failed`?`text-destructive`:``]),title:f.value,"aria-label":f.value,onClick:o},{default:O(()=>[l(`span`,{ref:`label`,class:`select-text`},ee(e.id),513),m(i,{icon:s[r.value],class:`size-2.5 shrink-0`,"aria-hidden":`true`},null,8,[`icon`])]),_:1},8,[`class`,`title`,`aria-label`])}}}),_e=F({__name:`Accordion`,props:{collapsible:{type:Boolean},disabled:{type:Boolean},dir:{},orientation:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},type:{},modelValue:{},defaultValue:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=g(n,`class`),a=o(i,r);return(e,t)=>(N(),v(b(de),A({"data-slot":`accordion`},b(a),{class:b(P)(`flex w-full flex-col`,n.class)}),{default:O(t=>[T(e.$slots,`default`,D(C(t)))]),_:3},16,[`class`]))}}),ve=F({__name:`AccordionContent`,props:{forceMount:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,n=g(t,`class`);return(e,r)=>(N(),v(b(me),A({"data-slot":`accordion-content`},b(n),{class:`data-open:animate-accordion-down data-closed:animate-accordion-up text-sm overflow-hidden`}),{default:O(()=>[l(`div`,{class:k(b(P)(`pt-0 pb-2.5 [&_a]:underline [&_a]:underline-offset-3 [&_a]:hover:text-foreground [&_p:not(:last-child)]:mb-4`,t.class))},[T(e.$slots,`default`)],2)]),_:3},16))}}),ye=F({__name:`AccordionItem`,props:{disabled:{type:Boolean},value:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let t=e,r=g(t,`class`),i=n(r);return(e,n)=>(N(),v(b(pe),A({"data-slot":`accordion-item`},b(i),{class:b(P)(`not-last:border-b`,t.class)}),{default:O(t=>[T(e.$slots,`default`,D(C(t)))]),_:3},16,[`class`]))}}),be=F({__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=g(t,`class`,`headerClass`);return(e,r)=>{let i=h(`FontAwesomeIcon`);return N(),v(b(he),{class:k(b(P)(`flex`,t.headerClass))},{default:O(()=>[m(b(ge),A({"data-slot":`accordion-trigger`},b(n),{class:b(P)(`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:O(()=>[T(e.$slots,`default`),T(e.$slots,`icon`,{},()=>[m(i,{icon:b(f),"data-slot":`accordion-trigger-icon`,"aria-hidden":`true`,class:`pointer-events-none shrink-0 group-aria-expanded/accordion-trigger:hidden`},null,8,[`icon`]),m(i,{icon:b(re),"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 xe(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 Se(e,t,n){n?(e.manuallyExpanded.delete(t),e.manuallyCollapsed.add(t)):(e.manuallyCollapsed.delete(t),e.manuallyExpanded.add(t))}function Ce(e){e.manuallyCollapsed.clear()}export{ye as a,$ as c,be as i,xe as n,ve as o,Se as r,_e as s,Ce as t};",
+		),
+	},
+	"series-NIRVBXMP.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"ZnVuY3Rpb24gZShlKXtsZXQgdD0wO2ZvcihsZXQgbiBvZiBlKXQrPW47cmV0dXJuIHR9ZnVuY3Rpb24gdCh0LG4pe3JldHVybiBuPD0wP1tdOlsuLi50XS5zb3J0KCh0LG4pPT5lKG4ucG9pbnRzKS1lKHQucG9pbnRzKSkuc2xpY2UoMCxuKX1mdW5jdGlvbiBuKGUsdCl7cmV0dXJuIGUubWFwKChlLG4pPT57bGV0IHI9MDtmb3IobGV0IGUgb2YgdClyKz1lLnBvaW50c1tuXT8/MDtyZXR1cm4gTWF0aC5tYXgoMCxlLXIpfSl9ZnVuY3Rpb24gcih0KXtsZXQgbj1uZXcgTWFwO2ZvcihsZXQgZSBvZiB0KXtsZXQgdD1lLnNjb3BlLnN0YXJ0c1dpdGgoYG1vZGVsOmApP2Uuc2NvcGUuc2xpY2UoNik6ZS5zY29wZSxyPXQuaW5kZXhPZihgL2ApLGk9cj09PS0xP3Q6dC5zbGljZSgwLHIpLGE9bi5nZXQoaSk/P0FycmF5KGUucG9pbnRzLmxlbmd0aCkuZmlsbCgwKTtmb3IobGV0IHQ9MDt0PGUucG9pbnRzLmxlbmd0aDt0KyspYVt0XT0oYVt0XT8/MCkrKGUucG9pbnRzW3RdPz8wKTtuLnNldChpLGEpfXJldHVybiBBcnJheS5mcm9tKG4uZW50cmllcygpKS5tYXAoKFtlLHRdKT0+KHtzY29wZTplLHBvaW50czp0fSkpLnNvcnQoKHQsbik9PmUobi5wb2ludHMpLWUodC5wb2ludHMpKX1mdW5jdGlvbiBpKGUsdCl7cmV0dXJuIHQubWFwKCh0LG4pPT50PjA/KGVbbl0/PzApL3Q6bnVsbCl9ZXhwb3J0e3IgYXMgaSxpIGFzIG4sdCBhcyByLG4gYXMgdH07",
+		),
+	},
+	"tabs-BbGJyCRr.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"import{a as e,i as t,l as n,n as r,o as i,r as a}from"./Presence-CuQUGFyS.js";import{B as o,Et as s,Fr as c,Lt as l,N as u,Or as d,Ot as f,Qn as p,Rr as m,Sn as h,Yt as g,dn as _,jn as v,jr as y,li as b,rr as x,un as S,vn as C,w,wn as T,z as E,zt as D}from"./nav-Dzb0OTN_.js";import{F as O,P as k,l as A}from"./CardDescription-IdOt317c.js";import{c as j,l as M}from"./index-BiTQ_gCE.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=M();for(let r of e)if(r===n||(r.focus({preventScroll:t}),M()!==n))return}function z(e,t){return e.map((n,r)=>e[(t+r)%e.length])}var[B,V]=n(`RovingFocusGroup`),H=D({__name:`RovingFocusGroup`,props:{orientation:{type:String,required:!1,default:void 0},dir:{type:String,required:!1},loop:{type:Boolean,required:!1,default:!1},currentTabStopId:{type:[String,null],required:!1},defaultCurrentTabStopId:{type:String,required:!1},preventScrollOnEntryFocus:{type:Boolean,required:!1,default:!1},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},emits:[`entryFocus`,`update:currentTabStopId`],setup(e,{expose:t,emit:n}){let r=e,a=n,{loop:o,orientation:s,dir:u}=c(r),p=i(u),h=A(r,`currentTabStopId`,a,{defaultValue:r.defaultCurrentTabStopId,passive:r.currentTabStopId===void 0}),g=d(!1),_=d(!1),y=d(0),{getItems:b,CollectionSlot:S}=j({isProvider:!0});function C(e){let t=!_.value;if(e.currentTarget&&e.target===e.currentTarget&&t&&!g.value){let t=new CustomEvent(N,P);if(e.currentTarget.dispatchEvent(t),a(`entryFocus`,t),!t.defaultPrevented){let e=b().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===h.value),...e].filter(Boolean),r.preventScrollOnEntryFocus)}}_.value=!1}function E(){setTimeout(()=>{_.value=!1},1)}return t({getItems:b}),V({loop:o,dir:p,orientation:s,currentTabStopId:h,onItemFocus:e=>{h.value=e},onItemShiftTab:()=>{g.value=!0},onFocusableItemAdd:()=>{y.value++},onFocusableItemRemove:()=>{y.value--}}),(e,t)=>(T(),f(m(S),null,{default:x(()=>[l(m(w),{tabindex:g.value||y.value===0?-1:0,"data-orientation":m(s),as:e.as,"as-child":e.asChild,dir:m(p),style:{outline:`none`},onMousedown:t[0]||=e=>_.value=!0,onMouseup:E,onFocus:C,onBlur:t[1]||=e=>g.value=!1},{default:x(()=>[v(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`as`,`as-child`,`dir`])]),_:3}))}}),U=D({__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(),i=r(),a=s(()=>t.tabStopId||i),o=s(()=>n.currentTabStopId.value===a.value),{getItems:c,CollectionItem:u}=j();C(()=>{t.focusable&&n.onFocusableItemAdd()}),h(()=>{t.focusable&&n.onFocusableItemRemove()}),p(()=>t.focusable,(e,t)=>{e!==t&&(e?n.onFocusableItemAdd():n.onFocusableItemRemove())});function d(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=[...c().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)}_(()=>R(i))}}return(e,t)=>(T(),f(m(u),null,{default:x(()=>[l(m(w),{tabindex:o.value?0:-1,"data-orientation":m(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?m(n).onItemFocus(a.value):t.preventDefault()},onFocus:t[1]||=e=>m(n).onItemFocus(a.value),onKeydown:d},{default:x(()=>[v(e.$slots,`default`)]),_:3},8,[`tabindex`,`data-orientation`,`data-active`,`data-disabled`,`as`,`as-child`])]),_:3}))}}),[W,G]=n(`TabsRoot`),K=D({__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(t,{emit:n}){let a=t,o=n,{orientation:s,unmountOnHide:l,dir:u}=c(a),p=i(u);e();let h=A(a,`modelValue`,o,{defaultValue:a.defaultValue,passive:a.modelValue===void 0}),g=d(),_=y(new Set);return G({modelValue:h,changeModelValue:e=>{h.value=e},orientation:s,dir:p,unmountOnHide:l,activationMode:a.activationMode,baseId:r(void 0,`reka-tabs`),tabsList:g,contentIds:_,registerContent:e=>{_.value=new Set([..._.value,e])},unregisterContent:e=>{let t=new Set(_.value);t.delete(e),_.value=t}}),(e,t)=>(T(),f(m(w),{dir:m(p),"data-orientation":m(s),"as-child":e.asChild,as:e.as},{default:x(()=>[v(e.$slots,`default`,{modelValue:m(h)})]),_: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=D({__name:`TabsList`,props:{loop:{type:Boolean,required:!1,default:!0},asChild:{type:Boolean,required:!1},as:{type:null,required:!1}},setup(t){let{loop:n}=c(t),{forwardRef:r,currentElement:i}=e(),a=W();return a.tabsList=i,(e,t)=>(T(),f(m(H),{"as-child":``,orientation:m(a).orientation.value,dir:m(a).dir.value,loop:m(n)},{default:x(()=>[l(m(w),{ref:m(r),role:`tablist`,"as-child":e.asChild,as:e.as,"aria-orientation":m(a).orientation.value},{default:x(()=>[v(e.$slots,`default`)]),_:3},8,[`as-child`,`as`,`aria-orientation`])]),_:3},8,[`orientation`,`dir`,`loop`]))}}),X=D({__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(t){let n=t,{forwardRef:r}=e(),i=W(),a=s(()=>q(i.baseId,n.value)),o=s(()=>i.contentIds.value.has(n.value)?J(i.baseId,n.value):void 0),c=s(()=>n.value===i.modelValue.value);return(e,t)=>(T(),f(m(U),{"as-child":``,focusable:!e.disabled,active:c.value},{default:x(()=>[l(m(w),{id:a.value,ref:m(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":m(i).orientation.value,onMousedown:t[0]||=O(t=>{!e.disabled&&t.ctrlKey===!1?m(i).changeModelValue(e.value):t.preventDefault()},[`left`]),onKeydown:t[1]||=k(t=>m(i).changeModelValue(e.value),[`enter`,`space`]),onFocus:t[2]||=()=>{let t=m(i).activationMode!==`manual`;!c.value&&!e.disabled&&t&&m(i).changeModelValue(e.value)}},{default:x(()=>[v(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=D({__name:`Tabs`,props:{defaultValue:{},orientation:{},dir:{},activationMode:{},modelValue:{},unmountOnHide:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},emits:[`update:modelValue`],setup(e,{emit:t}){let n=e,r=t,i=u(n,`class`),o=a(i,r);return(e,t)=>(T(),f(m(K),S({"data-slot":`tabs`,"data-orientation":m(o).orientation||`horizontal`},m(o),{class:m(E)(`gap-2 group/tabs flex data-horizontal:flex-col`,n.class)}),{default:x(t=>[v(e.$slots,`default`,b(g(t)))]),_:3},16,[`data-orientation`,`class`]))}}),Q=D({__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=u(t,`class`,`variant`);return(r,i)=>(T(),f(m(Y),S({"data-slot":`tabs-list`,"data-variant":e.variant},m(n),{class:m(E)(m(ee)({variant:e.variant}),t.class)}),{default:x(()=>[v(r.$slots,`default`)]),_:3},16,[`data-variant`,`class`]))}}),$=D({__name:`TabsTrigger`,props:{value:{},disabled:{type:Boolean},asChild:{type:Boolean},as:{},class:{type:[Boolean,null,String,Object,Array]}},setup(e){let n=e,r=u(n,`class`),i=t(r);return(e,t)=>(T(),f(m(X),S({"data-slot":`tabs-trigger`,class:m(E)(`gap-1.5 rounded-md border border-transparent px-1.5 py-0.5 text-sm font-medium group-data-[variant=default]/tabs-list:data-active:shadow-sm group-data-[variant=line]/tabs-list:data-active:shadow-none [&_svg:not([class*=size-])]:size-4 has-data-[icon=inline-end]:pr-1 has-data-[icon=inline-start]:pl-1 relative inline-flex h-[calc(100%-1px)] flex-1 items-center justify-center whitespace-nowrap text-foreground/60 transition-all group-data-vertical/tabs:w-full group-data-vertical/tabs:justify-start hover:text-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 focus-visible:outline-1 focus-visible:outline-ring disabled:pointer-events-none disabled:opacity-50 dark:text-muted-foreground dark:hover:text-foreground [&_svg]:pointer-events-none [&_svg]:shrink-0`,`group-data-[variant=line]/tabs-list:bg-transparent group-data-[variant=line]/tabs-list:data-active:bg-transparent dark:group-data-[variant=line]/tabs-list:data-active:border-transparent dark:group-data-[variant=line]/tabs-list:data-active:bg-transparent`,`data-active:bg-background data-active:text-foreground dark:data-active:border-input dark:data-active:bg-input/30 dark:data-active:text-foreground`,`after:absolute after:bg-foreground after:opacity-0 after:transition-opacity group-data-horizontal/tabs:after:inset-x-0 group-data-horizontal/tabs:after:bottom-[-5px] group-data-horizontal/tabs:after:h-0.5 group-data-vertical/tabs:after:inset-y-0 group-data-vertical/tabs:after:-right-1 group-data-vertical/tabs:after:w-0.5 group-data-[variant=line]/tabs-list:data-active:after:opacity-100`,n.class)},m(i)),{default:x(()=>[v(e.$slots,`default`)]),_:3},16,[`class`]))}}),ee=o(`rounded-lg p-0.75 group-data-horizontal/tabs:h-8 data-[variant=line]:rounded-none group/tabs-list inline-flex w-fit items-center justify-center text-muted-foreground group-data-vertical/tabs:h-fit group-data-vertical/tabs:flex-col`,{variants:{variant:{default:`bg-muted`,line:`gap-1 bg-transparent`}},defaultVariants:{variant:`default`}});export{Q as n,Z as r,$ as t};",
+		),
+	},
+	"useSearchQuery-DysBt-In.js": {
+		contentType: "text/javascript; charset=utf-8",
+		body: decodeAdminAsset(
+			"aW1wb3J0e0F0IGFzIGUsRXQgYXMgdCxMdCBhcyBuLE1uIGFzIHIsT3IgYXMgaSxPdCBhcyBhLFJyIGFzIG8sa3QgYXMgcyxudCBhcyBjLHJyIGFzIGwsc2kgYXMgdSxzdCBhcyBkLHduIGFzIGYseiBhcyBwLHp0IGFzIG19ZnJvbSIuL25hdi1EemIwT1ROXy5qcyI7aW1wb3J0e24gYXMgaH1mcm9tIi4vQ2FyZERlc2NyaXB0aW9uLUlkT3QzMTdjLmpzIjtpbXBvcnR7cyBhcyBnfWZyb20iLi9pbmRleC1CaVRRX2dDRS5qcyI7dmFyIF89bSh7X19uYW1lOmBTZWFyY2hJbnB1dGAscHJvcHM6e21vZGVsVmFsdWU6e30scGxhY2Vob2xkZXI6e30sY2xhc3M6e3R5cGU6W0Jvb2xlYW4sbnVsbCxTdHJpbmcsT2JqZWN0LEFycmF5XX19LGVtaXRzOltgdXBkYXRlOm1vZGVsVmFsdWVgXSxzZXR1cChpLHtlbWl0Om19KXtsZXQgXz1pLHY9bSx5PXQoKCk9Pl8ubW9kZWxWYWx1ZS5sZW5ndGg+MCk7ZnVuY3Rpb24gYihlKXt2KGB1cGRhdGU6bW9kZWxWYWx1ZWAsU3RyaW5nKGUpKX1mdW5jdGlvbiB4KCl7dihgdXBkYXRlOm1vZGVsVmFsdWVgLGBgKX1yZXR1cm4odCxtKT0+e2xldCB2PXIoYEZvbnRBd2Vzb21lSWNvbmApO3JldHVybiBmKCksZShgZGl2YCx7Y2xhc3M6dShvKHApKGByZWxhdGl2ZWAsXy5jbGFzcykpfSxbbih2LHtpY29uOm8oYyksY2xhc3M6YHBvaW50ZXItZXZlbnRzLW5vbmUgYWJzb2x1dGUgdG9wLTEvMiBsZWZ0LTIuNSBzaXplLTMuNSAtdHJhbnNsYXRlLXktMS8yIHRleHQtbXV0ZWQtZm9yZWdyb3VuZGAsImFyaWEtaGlkZGVuIjpgdHJ1ZWB9LG51bGwsOCxbYGljb25gXSksbihvKGcpLHsibW9kZWwtdmFsdWUiOmkubW9kZWxWYWx1ZSx0eXBlOmB0ZXh0YCxwbGFjZWhvbGRlcjppLnBsYWNlaG9sZGVyLCJhcmlhLWxhYmVsIjppLnBsYWNlaG9sZGVyLGNsYXNzOmBwci04IHBsLThgLCJvblVwZGF0ZTptb2RlbFZhbHVlIjpifSxudWxsLDgsW2Btb2RlbC12YWx1ZWAsYHBsYWNlaG9sZGVyYCxgYXJpYS1sYWJlbGBdKSx5LnZhbHVlPyhmKCksYShvKGgpLHtrZXk6MCx0eXBlOmBidXR0b25gLHZhcmlhbnQ6YGdob3N0YCxzaXplOmBpY29uLXhzYCwiYXJpYS1sYWJlbCI6YENsZWFyIHNlYXJjaGAsY2xhc3M6YGFic29sdXRlIHRvcC0xLzIgcmlnaHQtMSAtdHJhbnNsYXRlLXktMS8yIHRleHQtbXV0ZWQtZm9yZWdyb3VuZCBob3Zlcjp0ZXh0LWZvcmVncm91bmRgLG9uQ2xpY2s6eH0se2RlZmF1bHQ6bCgoKT0+W24odix7aWNvbjpvKGQpLGNsYXNzOmBzaXplLTMuNWAsImFyaWEtaGlkZGVuIjpgdHJ1ZWB9LG51bGwsOCxbYGljb25gXSldKSxfOjF9KSk6cyhgYCwhMCldLDIpfX19KTtmdW5jdGlvbiB2KGUpe2xldCBuPWU/P2koYGApLHI9dCgoKT0+bi52YWx1ZS50cmltKCkudG9Mb3dlckNhc2UoKSk7cmV0dXJue3F1ZXJ5Om4sbm9ybWFsaXplZDpyLGhhc1F1ZXJ5OnQoKCk9PnIudmFsdWUubGVuZ3RoPjApfX1leHBvcnR7XyBhcyBuLHYgYXMgdH07",
 		),
 	},
 }
diff --git a/webui/src/App.vue b/webui/src/App.vue
index 3da0c22..93bd835 100644
--- a/webui/src/App.vue
+++ b/webui/src/App.vue
@@ -1,64 +1,66 @@
 <script setup lang="ts">
+import type { Component } from 'vue'
 import { faGithub } from '@fortawesome/free-brands-svg-icons'
 import { faCircleExclamation } from '@fortawesome/free-solid-svg-icons'
 import { computed, defineAsyncComponent, onMounted } from 'vue'
 
 import AuthGate from '@/components/AuthGate.vue'
 import ConfigWarningsBanner from '@/components/ConfigWarningsBanner.vue'
-import EventsView from '@/components/EventsView.vue'
-import ProvidersView from '@/components/ProvidersView.vue'
-import TargetsView from '@/components/TargetsView.vue'
+import GlobalFilterBar from '@/components/GlobalFilterBar.vue'
+import SidebarNav from '@/components/SidebarNav.vue'
 import { Button } from '@/components/ui/button'
-import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs'
-import UsageView from '@/components/UsageView.vue'
 import { useHashState } from '@/composables/useHashState'
+import type { PageId } from '@/lib/pages'
 import { useAuthStore } from '@/stores/auth'
 import { useDashboardStore } from '@/stores/dashboard'
 import { useNavStore } from '@/stores/nav'
 
-// Lazy: Chart.js (UsageChart.vue's dependency, pulled in transitively) is
-// the single largest piece of this bundle, and most admin sessions open on
-// Providers/Usage. Splitting it into its own chunk keeps the initial load
-// lean; it fetches once, on first visit to the Charts tab.
-const ChartsView = defineAsyncComponent(() => import('@/components/ChartsView.vue'))
-
-/** The module path (go.mod / .traefik.yml `import:`) — same repo the plugin
- * ships from, so this is the one canonical URL rather than a guess. */
+/** The module path (go.mod / .traefik.yml `import:`) — same repo the plugin ships from, so this is the one canonical URL rather than a guess. */
 const GITHUB_REPO_URL = 'https://github.com/lukaszraczylo/traefik-llmgateway'
 
 const auth = useAuthStore()
 const dashboard = useDashboardStore()
 const nav = useNavStore()
 
-// The "Providers" tab is labeled that way (operator rename); the backend
-// endpoint it fetches from, GET /admin/api/overview, and the store's own
-// `overview` field (AdminOverviewResponse) keep their original names
-// unchanged — the rename is UI-only, not an API surface change.
-
-// F9 (dashboard-plan.md) supersedes Feature C (v0.22)'s useTabHash()
-// composable: the Tabs v-model now binds nav.activeTab (stores/nav.ts)
-// directly, and useHashState() keeps that field — plus history.ts's
-// scope/window/tab/modelMetric, events.ts's kindFilter/userFilter, and
-// nav.usageQuery — synced with a single "#<tab>?<query>" URL hash
-// (lib/hash-state.ts), both on load and on every change. MUST be created
-// here, before the `v-if="!auth.isAuthenticated"` branch below (Risks,
-// dashboard-plan.md: "load-with-hash-then-authenticate") — every store
-// action it calls is safe to run before a key is stored, so the hash's
-// selection is already restored by the time the reader authenticates.
+// The old flat-tab shell (activeTab/useTabHash) is superseded by the
+// sidebar-page redesign (redesign-plan.md section 3.1): nav.page/params
+// now drive routing, and useHashState() keeps them — plus the global
+// filters (stores/filters.ts) — synced with a single
+// "#<page>?range=...&cmp=...&scope=...&<page params>" URL hash. MUST be
+// created here, before the `v-if="!auth.isAuthenticated"` branch below
+// (load-with-hash-then-authenticate) — every store write it makes is
+// safe to run before a key is stored, so the hash's selection is already
+// restored by the time the reader authenticates.
 useHashState()
 
+/**
+ * PAGES maps each PageId (lib/pages.ts) to its own top-level page
+ * component, lazily loaded — an admin session only ever looks at one
+ * page at a time, so only that page's own code (and, for the pages
+ * other work packages are filling in with chart.js-backed views) ships
+ * on first load, generalizing the same reasoning the old shell already
+ * applied to its one chart-heavy tab.
+ */
+const PAGES: Record<PageId, Component> = {
+  home: defineAsyncComponent(() => import('@/pages/HomePage.vue')),
+  spend: defineAsyncComponent(() => import('@/pages/SpendPage.vue')),
+  consumers: defineAsyncComponent(() => import('@/pages/ConsumersPage.vue')),
+  models: defineAsyncComponent(() => import('@/pages/ModelsPage.vue')),
+  reliability: defineAsyncComponent(() => import('@/pages/ReliabilityPage.vue')),
+  config: defineAsyncComponent(() => import('@/pages/ConfigPage.vue')),
+  targets: defineAsyncComponent(() => import('@/pages/TargetsPage.vue')),
+}
+
+const currentPage = computed<Component>(() => PAGES[nav.page])
+
 // statusText reads dashboard.error/lastUpdated unconditionally — it is
-// correct only while the template's own `v-if="auth.isAuthenticated"` below
-// keeps it off-screen otherwise. Without that gate a 401 (which resolves
-// before touching error/lastUpdated) left the PRIOR "last updated ..." or
-// "refresh failed: ..." line showing right under the auth gate, and a first
-// load with no stored key showed "loading..." forever (review finding).
-// F4 (dashboard-plan.md): appended only on a genuinely successful poll —
+// correct only while the template's own `v-if="auth.isAuthenticated"`
+// below keeps it off-screen otherwise, so a first load with no stored
+// key never shows a stale "refresh failed"/"loading..." line under the
+// auth gate. Appended only on a genuinely successful poll —
 // dashboard.overview.replica reflects WHICH replica answered that poll,
 // so it must never be shown alongside a stale value during a failed or
-// still-loading refresh (a prior successful poll's overview object can
-// still be sitting there while `error` is set, and showing its replica
-// next to "refresh failed" would misattribute the failure to it).
+// still-loading refresh.
 const statusText = computed<string>(() => {
   if (dashboard.error) return `refresh failed: ${dashboard.error}`
   if (dashboard.lastUpdated) {
@@ -74,8 +76,8 @@ onMounted(() => {
 </script>
 
 <template>
-  <div class="flex w-full flex-col gap-6 px-4 py-8 sm:px-6 lg:px-8">
-    <header class="flex flex-col gap-1">
+  <div class="flex w-full flex-col gap-4 px-4 py-6 sm:px-6 lg:px-8">
+    <header class="flex flex-col gap-3">
       <div class="flex items-center justify-between gap-2">
         <h1 class="text-xl font-semibold tracking-tight">LLM Gateway &mdash; Admin</h1>
         <Button
@@ -95,9 +97,10 @@ onMounted(() => {
         <FontAwesomeIcon v-if="dashboard.error" :icon="faCircleExclamation" class="size-3.5 text-destructive" aria-hidden="true" />
         <span :class="dashboard.error ? 'text-destructive' : undefined">{{ statusText }}</span>
       </p>
+      <GlobalFilterBar v-if="auth.isAuthenticated" />
     </header>
 
-    <!-- F10: GET /admin/api/overview's config warnings — renders nothing itself once `warnings` is empty, so this is always safe to mount. -->
+    <!-- GET /admin/api/overview's config warnings — renders nothing itself once `warnings` is empty, so this is always safe to mount. -->
     <ConfigWarningsBanner
       v-if="auth.isAuthenticated"
       :warnings="dashboard.overview?.warnings ?? []"
@@ -106,29 +109,11 @@ onMounted(() => {
 
     <AuthGate v-if="!auth.isAuthenticated" />
 
-    <Tabs v-else v-model="nav.activeTab">
-      <TabsList>
-        <TabsTrigger value="providers">Providers</TabsTrigger>
-        <TabsTrigger value="usage">Usage</TabsTrigger>
-        <TabsTrigger value="charts">Charts</TabsTrigger>
-        <TabsTrigger value="targets">MCP & Agents</TabsTrigger>
-        <TabsTrigger value="events">Events</TabsTrigger>
-      </TabsList>
-      <TabsContent value="providers">
-        <ProvidersView />
-      </TabsContent>
-      <TabsContent value="usage">
-        <UsageView />
-      </TabsContent>
-      <TabsContent value="charts">
-        <ChartsView />
-      </TabsContent>
-      <TabsContent value="targets">
-        <TargetsView />
-      </TabsContent>
-      <TabsContent value="events">
-        <EventsView />
-      </TabsContent>
-    </Tabs>
+    <div v-else class="flex flex-col gap-4 md:flex-row">
+      <SidebarNav />
+      <main class="min-w-0 flex-1">
+        <component :is="currentPage" />
+      </main>
+    </div>
   </div>
 </template>
diff --git a/webui/src/assets/main.css b/webui/src/assets/main.css
index 5acc396..70708c6 100644
--- a/webui/src/assets/main.css
+++ b/webui/src/assets/main.css
@@ -97,6 +97,29 @@
     --chart-tokens-out: #e69f00;
     --chart-cost: #d55e00;
 
+    /*
+     * --chart-series-a..d: Spend's breakdown chart (pages/SpendPage.vue,
+     * BREAKDOWN_PALETTE) extends the four series above with the
+     * remaining four swatches of that same Okabe & Ito (2008) 8-color
+     * qualitative set, for its open-ended per-model/provider/group
+     * series count. These tokens used to live in SpendPage.vue's own
+     * unscoped <style> block; moved here (P3 item 22) so every chart
+     * color token lives in the one design-tokens file, matching the
+     * Tailwind-only rule (no plain CSS outside a component's own scoped
+     * block or this file).
+     *
+     * --chart-series-b is NOT the Okabe-Ito yellow (#f0e442) verbatim in
+     * light mode: that measures well under WCAG 1.4.11's 3:1 non-text
+     * contrast minimum as a chart line on this light --card (~1.4:1) —
+     * #8a6d00 instead measures ~4.9:1 against --card, clearing both the
+     * 3:1 graphical-object minimum and the 4.5:1 text minimum with
+     * margin, while staying recognizably the same yellow/gold hue.
+     */
+    --chart-series-a: #56b4e9;
+    --chart-series-b: #8a6d00;
+    --chart-series-c: #cc79a7;
+    --chart-series-d: #4d4d4d;
+
     /*
      * --status-warn: a semantic "degraded, not broken" indicator (the
      * Providers tab's amber success-rate badge, ProviderRateBadge.vue) —
@@ -162,6 +185,16 @@
         --chart-tokens-out: #f0ac1f;
         --chart-cost: #e8763a;
 
+        /* Same Okabe-Ito hues as the light-mode block's own doc comment
+           above — already legible on a dark ground at this saturation
+           (Okabe-Ito was designed for slide/print use on light and dark
+           backgrounds alike), so only --chart-series-b's LIGHT value
+           needed darkening; here it keeps the original #f0e442. */
+        --chart-series-a: #56b4e9;
+        --chart-series-b: #f0e442;
+        --chart-series-c: #cc79a7;
+        --chart-series-d: #b8b8b8;
+
         /* #f0ac1f on the dark --card measures ~8.97:1 — no separate dark
            value was needed to clear WCAG 1.4.3 here, unlike light mode
            (see --status-warn's own doc comment above), but the token is
diff --git a/webui/src/components/AccessMatrix.vue b/webui/src/components/AccessMatrix.vue
new file mode 100644
index 0000000..40858dd
--- /dev/null
+++ b/webui/src/components/AccessMatrix.vue
@@ -0,0 +1,114 @@
+<script setup lang="ts">
+import { faCheck, faTriangleExclamation, faXmark } from '@fortawesome/free-solid-svg-icons'
+import { computed, onMounted } from 'vue'
+
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
+import { buildAccessMatrix } from '@/lib/access-matrix'
+import type { AccessCell } from '@/lib/access-matrix'
+import { useConsumersStore } from '@/stores/consumers'
+import { useDashboardStore } from '@/stores/dashboard'
+
+/**
+ * AccessMatrix (redesign-plan.md section 3.4) is the Consumers page's
+ * `view=matrix` alternative to ConsumerDirectory: rows are groups, columns
+ * are every configured provider (allowed check + "n/m models", from GET
+ * /admin/api/consumers' AllowedProviders/modelAccess) and every configured
+ * MCP server/agent target (from GET /admin/api/targets' own `access`
+ * list). Pure data shaping lives in lib/access-matrix.ts; this component
+ * only fetches, lays out columns, and renders.
+ */
+const consumers = useConsumersStore()
+const dashboard = useDashboardStore()
+
+onMounted(() => {
+  void consumers.ensureConsumers()
+})
+
+const providerNames = computed(() => (dashboard.overview?.providers ?? []).map((p) => p.name))
+const mcpServers = computed(() => dashboard.targets?.mcpServers ?? [])
+const agents = computed(() => dashboard.targets?.agents ?? [])
+
+/** MatrixColumn flattens the three heterogeneous column groups (providers, MCP servers, agents) into one ordered list — a single v-for renders every header AND every cell, rather than three near-identical template blocks. */
+interface MatrixColumn {
+  key: string
+  label: string
+  section: 'providers' | 'mcpServers' | 'agents'
+}
+
+const columns = computed<MatrixColumn[]>(() => [
+  ...providerNames.value.map((name): MatrixColumn => ({ key: name, label: name, section: 'providers' })),
+  ...mcpServers.value.map((t): MatrixColumn => ({ key: t.name, label: `${t.name} (MCP)`, section: 'mcpServers' })),
+  ...agents.value.map((t): MatrixColumn => ({ key: t.name, label: `${t.name} (agent)`, section: 'agents' })),
+])
+
+const rows = computed(() => buildAccessMatrix(consumers.data?.groups ?? [], providerNames.value, mcpServers.value, agents.value))
+
+const EMPTY_CELL: AccessCell = { allowed: false }
+
+function cellFor(row: (typeof rows.value)[number], column: MatrixColumn): AccessCell {
+  return row[column.section][column.key] ?? EMPTY_CELL
+}
+
+/**
+ * cellSrText is the ONLY accessible text a screen reader announces for
+ * one cell — the visible icon is aria-hidden and the visible detail span
+ * is aria-hidden too (P3 item 18: it used to be read TWICE, once as
+ * plain visible text and again inside this string). A zero-model cell
+ * (`zero`) gets its own wording rather than the plain "Allowed, 0/5
+ * models" reading, which sounds identical to "Allowed, 5/5 models" to a
+ * screen reader user skimming past the number.
+ */
+function cellSrText(cell: AccessCell): string {
+  if (!cell.allowed) return 'Not allowed'
+  if (cell.zero) return `Allowed, but ${cell.detail} reachable — the model grant matches none of this provider's models`
+  return cell.detail ? `Allowed, ${cell.detail}` : 'Allowed'
+}
+
+/** cellIcon picks the FontAwesome icon for a cell's three visual states: not allowed (X), allowed-but-zero-usable-models (warning triangle — P3 item 18: this used to render an identical green check to a genuinely unrestricted cell), and ordinarily allowed (check). */
+function cellIcon(cell: AccessCell) {
+  if (!cell.allowed) return faXmark
+  if (cell.zero) return faTriangleExclamation
+  return faCheck
+}
+
+/** cellIconClass colors cellIcon's three states distinctly — not-allowed and zero-but-allowed must never share the "everything is fine" green. */
+function cellIconClass(cell: AccessCell): string {
+  if (!cell.allowed) return 'text-muted-foreground/40'
+  if (cell.zero) return 'text-status-warn'
+  return 'text-chart-requests'
+}
+</script>
+
+<template>
+  <Card>
+    <CardHeader>
+      <CardTitle>Access matrix</CardTitle>
+      <CardDescription>Which groups can reach which providers, MCP servers, and agents.</CardDescription>
+    </CardHeader>
+    <CardContent v-if="consumers.error" class="text-sm text-destructive">{{ consumers.error }}</CardContent>
+    <CardContent v-else-if="rows.length === 0" class="py-6 text-center text-sm text-muted-foreground">
+      {{ consumers.loading ? 'loading…' : 'no groups configured' }}
+    </CardContent>
+    <CardContent v-else class="overflow-x-auto">
+      <Table>
+        <TableHeader>
+          <TableRow>
+            <TableHead>Group</TableHead>
+            <TableHead v-for="column in columns" :key="column.key + column.section">{{ column.label }}</TableHead>
+          </TableRow>
+        </TableHeader>
+        <TableBody>
+          <TableRow v-for="row in rows" :key="row.group">
+            <TableHead scope="row" class="font-medium">{{ row.group }}</TableHead>
+            <TableCell v-for="column in columns" :key="column.key + column.section" class="text-center" :title="cellFor(row, column).detail">
+              <FontAwesomeIcon :icon="cellIcon(cellFor(row, column))" :class="cellIconClass(cellFor(row, column))" class="size-3.5" aria-hidden="true" />
+              <span v-if="cellFor(row, column).detail" aria-hidden="true" class="ml-1 text-xs text-muted-foreground">{{ cellFor(row, column).detail }}</span>
+              <span class="sr-only">{{ cellSrText(cellFor(row, column)) }}</span>
+            </TableCell>
+          </TableRow>
+        </TableBody>
+      </Table>
+    </CardContent>
+  </Card>
+</template>
diff --git a/webui/src/components/AttributionDrilldown.vue b/webui/src/components/AttributionDrilldown.vue
new file mode 100644
index 0000000..9686141
--- /dev/null
+++ b/webui/src/components/AttributionDrilldown.vue
@@ -0,0 +1,163 @@
+<script setup lang="ts">
+import type { ColumnDef } from '@tanstack/vue-table'
+import { faChevronRight } from '@fortawesome/free-solid-svg-icons'
+import { FontAwesomeIcon } from '@fortawesome/vue-fontawesome'
+import { computed, h, ref } from 'vue'
+
+import ClampedRangeNotice from '@/components/ClampedRangeNotice.vue'
+import CompactNumber from '@/components/CompactNumber.vue'
+import DataTable from '@/components/DataTable.vue'
+import EntityLink from '@/components/EntityLink.vue'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { formatCost } from '@/lib/format'
+import { SPEND_METRIC_LABEL } from '@/stores/spend'
+import type { AdminTotalsResponse, HistoryMetric, HistoryWindow } from '@/types/api'
+
+/** DrilldownRow is one GET /admin/api/usage/totals row (types/api.ts's AdminTotalsResponse.rows entry). */
+type DrilldownRow = AdminTotalsResponse['rows'][number]
+
+/**
+ * AttributionDrilldown (redesign-plan.md section 3.4) descends group ->
+ * users (GET /admin/api/usage/totals?kind=user&group=) -> models (kind=
+ * usermodel, only when AdminFeaturesView.userModelStats — the config's
+ * admin.stats.userModel), breadcrumbs tracked in the `drill` page param
+ * (section 3.1). This component owns no fetch itself — CONTROLLED, like
+ * CostAvoidedCard.vue's own `ref` prop — stores/spend.ts's fetchDrilldown
+ * reads `drill` and supplies `rows`/`metrics`/`disabled`; every click here
+ * only emits `update:drill`, letting SpendPage.vue keep it in nav.params
+ * (so a reload or shared link restores the same drilldown position).
+ *
+ * `userModelStatsEnabled` gates whether a USER row is clickable at all
+ * (redesign-plan.md's own "only when features.userModelStats, else hint
+ * naming the config key") — checked client-side from the already-polled
+ * overview response, before ever firing a request that would only come
+ * back 404. `disabled` (from the store, a REAL 404) is the fallback for
+ * the deep-link case: a reader who lands directly on `drill=user:x` via a
+ * restored hash before this prop has had a chance to gate the click.
+ */
+const props = defineProps<{
+  rows: DrilldownRow[]
+  metrics: string[]
+  drill: string
+  disabled: boolean
+  userModelStatsEnabled: boolean
+  /** The global filters store's current window/span (N3 fix) — ClampedRangeNotice's own props, forwarded so this stays a controlled, props-driven component rather than reaching into stores/filters.ts itself. */
+  window: HistoryWindow
+  span: number
+}>()
+
+const emit = defineEmits<{ 'update:drill': [value: string] }>()
+
+type Level = { kind: 'group' } | { kind: 'user'; group: string } | { kind: 'usermodel'; user: string }
+
+const level = computed<Level>(() => {
+  if (props.drill === '') return { kind: 'group' }
+  if (props.drill.startsWith('group:')) return { kind: 'user', group: props.drill.slice('group:'.length) }
+  return { kind: 'usermodel', user: props.drill.slice('user:'.length) }
+})
+
+/**
+ * parentGroupLabel is a BEST-EFFORT breadcrumb label for the group a
+ * drilled-into user belongs to — the `drill` param itself only ever
+ * encodes the current LEAF selection (`user:{id}`, redesign-plan.md
+ * section 3.1's own `drill=group:x|user:x` shape has no room for a
+ * compound path), so this is tracked as local component state, set at
+ * the moment a user row is clicked FROM the user-list level. A reader who
+ * lands directly on `drill=user:x` via a restored hash sees no middle
+ * breadcrumb segment — an acceptable, honest degradation (nothing else
+ * available in `drill` records it) rather than a fabricated group name.
+ */
+const parentGroupLabel = ref('')
+
+function goToGroups(): void {
+  emit('update:drill', '')
+}
+function goToParentGroup(): void {
+  if (parentGroupLabel.value) emit('update:drill', `group:${parentGroupLabel.value}`)
+}
+function onRowClick(id: string): void {
+  const l = level.value
+  if (l.kind === 'group') {
+    emit('update:drill', `group:${id}`)
+  } else if (l.kind === 'user' && props.userModelStatsEnabled) {
+    parentGroupLabel.value = l.group
+    emit('update:drill', `user:${id}`)
+  }
+}
+
+const idColumnLabel = computed<string>(() => (level.value.kind === 'group' ? 'Group' : level.value.kind === 'user' ? 'User' : 'Model'))
+
+/** Row id is clickable to drill further at the group level always, and at the user level only when userModelStatsEnabled — the leaf (usermodel) level renders the model id as an EntityLink to the Models page instead, since there is nowhere further to drill. */
+function idCell(row: DrilldownRow) {
+  const l = level.value
+  if (l.kind === 'usermodel') return h(EntityLink, { label: row.id, kind: 'model', id: row.id })
+  const clickable = l.kind === 'group' || props.userModelStatsEnabled
+  if (!clickable) return h('span', {}, row.id)
+  return h(
+    '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: () => onRowClick(row.id),
+    },
+    [row.id, h(FontAwesomeIcon, { icon: faChevronRight, class: 'size-3', 'aria-hidden': 'true' })],
+  )
+}
+
+const columns = computed<ColumnDef<DrilldownRow, unknown>[]>(() => [
+  { id: 'id', header: idColumnLabel.value, accessorFn: (r) => r.id, cell: ({ row }) => idCell(row.original) },
+  ...props.metrics.map(
+    (metric): ColumnDef<DrilldownRow, unknown> => ({
+      id: metric,
+      header: SPEND_METRIC_LABEL[metric as HistoryMetric] ?? metric,
+      meta: { align: 'right' },
+      accessorFn: (r) => r.values[metric] ?? 0,
+      cell: ({ row }) => {
+        const value = row.original.values[metric] ?? 0
+        return metric === 'cost' ? formatCost(value) : h(CompactNumber, { value })
+      },
+    }),
+  ),
+])
+
+const showUserModelHint = computed<boolean>(() => level.value.kind === 'user' && (!props.userModelStatsEnabled || props.disabled))
+</script>
+
+<template>
+  <Card>
+    <CardHeader>
+      <CardTitle>Attribution</CardTitle>
+      <CardDescription>Drill from groups into users into the models they used.</CardDescription>
+      <nav aria-label="Breadcrumb" class="flex flex-wrap items-center gap-1.5 text-sm text-muted-foreground">
+        <button type="button" class="hover:text-foreground hover:underline" :disabled="level.kind === 'group'" @click="goToGroups">
+          All groups
+        </button>
+        <template v-if="level.kind === 'user'">
+          <FontAwesomeIcon :icon="faChevronRight" class="size-3" aria-hidden="true" />
+          <span class="font-medium text-foreground">{{ level.group }}</span>
+        </template>
+        <template v-if="level.kind === 'usermodel'">
+          <FontAwesomeIcon :icon="faChevronRight" class="size-3" aria-hidden="true" />
+          <button v-if="parentGroupLabel" type="button" class="hover:text-foreground hover:underline" @click="goToParentGroup">
+            {{ parentGroupLabel }}
+          </button>
+          <FontAwesomeIcon :icon="faChevronRight" class="size-3" aria-hidden="true" />
+          <span class="font-medium text-foreground">{{ level.user }}</span>
+        </template>
+      </nav>
+    </CardHeader>
+    <CardContent class="flex flex-col gap-3">
+      <ClampedRangeNotice v-if="level.kind === 'usermodel'" :window="window" :span="span" />
+      <p v-if="showUserModelHint" class="text-sm text-muted-foreground">
+        Per-model attribution for this user needs <code class="font-mono text-xs">admin.stats.userModel</code> enabled.
+      </p>
+      <DataTable
+        v-else
+        :columns="columns"
+        :data="rows"
+        :empty-message="level.kind === 'group' ? 'No group has spend in this range.' : 'Nothing in this range.'"
+      />
+    </CardContent>
+  </Card>
+</template>
diff --git a/webui/src/components/BurnDownChart.vue b/webui/src/components/BurnDownChart.vue
new file mode 100644
index 0000000..df4f6d8
--- /dev/null
+++ b/webui/src/components/BurnDownChart.vue
@@ -0,0 +1,92 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+
+import TimeSeriesChart from '@/components/TimeSeriesChart.vue'
+import type { TimeSeriesDataset } from '@/components/TimeSeriesChart.vue'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { cumulative, runOutDate } from '@/lib/burndown'
+import { formatBucketLabel, formatCost } from '@/lib/format'
+
+/**
+ * BurnDownChart (redesign-plan.md section 3.4) renders the current UTC
+ * calendar month's cumulative spend against its configured budget: a
+ * solid line (lib/burndown.ts's `cumulative`, run over the store's own raw
+ * per-day points — see stores/spend.ts's own doc comment on why the
+ * running-sum step lives here rather than in the store) plus, when a
+ * budget is configured, a dashed reference line at that flat limit
+ * (TimeSeriesChart's own `comparisonDatasets` — a budget ceiling is
+ * exactly the "reference overlay, not a component of the current total"
+ * that prop already documents) and the projected run-out date
+ * (lib/burndown.ts's runOutDate, MTD average daily rate).
+ *
+ * `now` is a required prop, not read from `new Date()` internally —
+ * CostForecastCard.vue's own doc comment explains why a component-local
+ * default silently freezes at first mount (Vue caches a prop default
+ * once per instance): the caller passes the SAME shared clock
+ * (composables/useNow.ts) every other time-dependent read on the page
+ * shares.
+ */
+const props = defineProps<{
+  /** Day-window bucket keys, oldest first (limits.go's "20060102" format — lib/format.ts's formatBucketLabel). */
+  buckets: string[]
+  /** Raw (not cumulative) per-day cost in micro-USD, index-aligned with `buckets`. */
+  points: number[]
+  /** The scope's configured cost/month budget in micro-USD, or null when none is configured. */
+  budgetMicros: number | null
+  now: Date
+}>()
+
+const labels = computed<string[]>(() => props.buckets.map((b) => formatBucketLabel(b, 'day')))
+const cumulativePoints = computed<number[]>(() => cumulative(props.points))
+const spentMicros = computed<number>(() => cumulativePoints.value.at(-1) ?? 0)
+
+const datasets = computed<TimeSeriesDataset[]>(() => [{ label: 'Spent (MTD)', data: cumulativePoints.value, color: '--chart-cost' }])
+
+const comparisonDatasets = computed<TimeSeriesDataset[]>(() => {
+  if (props.budgetMicros === null) return []
+  const flat = new Array<number>(cumulativePoints.value.length).fill(props.budgetMicros)
+  return [{ label: 'Budget', data: flat, color: '--destructive' }]
+})
+
+const runOut = computed<Date | null>(() => (props.budgetMicros === null ? null : runOutDate(spentMicros.value, props.budgetMicros, props.now)))
+
+const willExceed = computed<boolean>(() => props.budgetMicros !== null && spentMicros.value >= props.budgetMicros)
+</script>
+
+<template>
+  <Card>
+    <CardHeader>
+      <CardTitle>Burn-down</CardTitle>
+      <CardDescription>Cumulative spend this UTC calendar month against the configured budget.</CardDescription>
+    </CardHeader>
+    <CardContent class="flex flex-col gap-4">
+      <div class="grid grid-cols-2 gap-4 text-sm sm:grid-cols-3">
+        <div>
+          <p class="text-muted-foreground">Spent so far</p>
+          <p class="text-lg font-semibold tabular-nums" :class="willExceed ? 'text-destructive' : undefined">
+            {{ formatCost(spentMicros) }}
+          </p>
+        </div>
+        <div v-if="budgetMicros !== null">
+          <p class="text-muted-foreground">Budget</p>
+          <p class="text-lg font-semibold tabular-nums">{{ formatCost(budgetMicros) }}</p>
+        </div>
+        <div v-if="budgetMicros !== null">
+          <p class="text-muted-foreground">Projected run-out</p>
+          <p v-if="runOut === null" class="text-sm text-muted-foreground">not enough data yet</p>
+          <p v-else class="text-lg font-semibold tabular-nums" :class="willExceed ? 'text-destructive' : undefined">
+            {{ runOut.toLocaleDateString(undefined, { month: 'short', day: 'numeric' }) }}
+          </p>
+        </div>
+      </div>
+      <p v-if="budgetMicros === null" class="text-sm text-muted-foreground">No budget configured for this scope.</p>
+      <TimeSeriesChart
+        :labels="labels"
+        :datasets="datasets"
+        :comparison-datasets="comparisonDatasets"
+        :value-formatter="formatCost"
+        ariaLabel="Cumulative spend this month against the configured budget"
+      />
+    </CardContent>
+  </Card>
+</template>
diff --git a/webui/src/components/ChangeHelper.vue b/webui/src/components/ChangeHelper.vue
new file mode 100644
index 0000000..da44f7e
--- /dev/null
+++ b/webui/src/components/ChangeHelper.vue
@@ -0,0 +1,63 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+
+import GrantForm from '@/components/forms/GrantForm.vue'
+import LimitsForm from '@/components/forms/LimitsForm.vue'
+import ModelMetaForm from '@/components/forms/ModelMetaForm.vue'
+import PricingForm from '@/components/forms/PricingForm.vue'
+import UserForm from '@/components/forms/UserForm.vue'
+import { Tabs, TabsList, TabsTrigger } from '@/components/ui/tabs'
+import { useNavStore } from '@/stores/nav'
+
+/** HELPER_IDS mirrors the Config page's own `helper` hash param (redesign-plan.md section 3.1: `helper=limits|grant|pricing|model|user`) — the single source of truth for which tab is selected and which form renders. */
+const HELPER_IDS = ['limits', 'grant', 'pricing', 'model', 'user'] as const
+type HelperId = (typeof HELPER_IDS)[number]
+
+const HELPER_LABEL: Record<HelperId, string> = {
+  limits: 'Limits',
+  grant: 'Access grant',
+  pricing: 'Pricing',
+  model: 'Model metadata',
+  user: 'New user',
+}
+
+/**
+ * ChangeHelper (redesign-plan.md section 3.4) is the Config page's
+ * snippet-building surface: five forms (LimitsForm, GrantForm,
+ * PricingForm, ModelMetaForm, UserForm), each producing a paste-ready
+ * YAML/users.json fragment via lib/snippets.ts, switched by the page's own
+ * `helper` hash param so a shared link opens the same tab.
+ */
+const props = defineProps<{
+  groupNames: string[]
+  userNames: string[]
+}>()
+
+const nav = useNavStore()
+
+const helper = computed<HelperId>(() => {
+  const value = nav.params.helper
+  return (HELPER_IDS as readonly string[]).includes(value ?? '') ? (value as HelperId) : 'limits'
+})
+
+function setHelper(next: unknown): void {
+  if (typeof next !== 'string' || !(HELPER_IDS as readonly string[]).includes(next)) return
+  nav.goTo('config', { ...nav.params, helper: next })
+}
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <Tabs :model-value="helper" @update:model-value="setHelper">
+      <TabsList>
+        <TabsTrigger v-for="id in HELPER_IDS" :key="id" :value="id">{{ HELPER_LABEL[id] }}</TabsTrigger>
+      </TabsList>
+    </Tabs>
+
+    <LimitsForm v-if="helper === 'limits'" :group-names="props.groupNames" :user-names="props.userNames" />
+    <GrantForm v-else-if="helper === 'grant'" :group-names="props.groupNames" :user-names="props.userNames" />
+    <PricingForm v-else-if="helper === 'pricing'" />
+    <ModelMetaForm v-else-if="helper === 'model'" />
+    <UserForm v-else :group-names="props.groupNames" />
+  </div>
+</template>
diff --git a/webui/src/components/ChartsView.vue b/webui/src/components/ChartsView.vue
deleted file mode 100644
index af32ebe..0000000
--- a/webui/src/components/ChartsView.vue
+++ /dev/null
@@ -1,281 +0,0 @@
-<script setup lang="ts">
-import { faXmark } from '@fortawesome/free-solid-svg-icons'
-import { computed, onMounted, onUnmounted, watch } from 'vue'
-
-import SearchInput from '@/components/SearchInput.vue'
-import { Button } from '@/components/ui/button'
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
-import {
-  Select,
-  SelectContent,
-  SelectItem,
-  SelectTrigger,
-  SelectValue,
-} from '@/components/ui/select'
-import { Tabs, TabsList, TabsTrigger } from '@/components/ui/tabs'
-import CsvExportButton from '@/components/CsvExportButton.vue'
-import DataTable from '@/components/DataTable.vue'
-import ModelUsageChart from '@/components/ModelUsageChart.vue'
-import UsageChart from '@/components/UsageChart.vue'
-import { useSearchQuery } from '@/composables/useSearchQuery'
-import { filterModelsByPrefix } from '@/lib/model-filter'
-import { modelTableColumns } from '@/lib/model-table-columns'
-import { modelDetailCsv } from '@/lib/usage-csv'
-import { groupMatches, userMatches } from '@/lib/usage-search'
-import { useDashboardStore } from '@/stores/dashboard'
-import {
-  type ChartTab,
-  MODEL_METRIC_LABEL,
-  MODEL_RANKING_LIMIT,
-  type ModelMetric,
-  type TimeSeriesTab,
-  useHistoryStore,
-  WINDOW_LABEL,
-  WINDOW_SPAN,
-} from '@/stores/history'
-import type { HistoryWindow } from '@/types/api'
-
-const dashboard = useDashboardStore()
-const history = useHistoryStore()
-
-// --- user/group search filter (operator feature) ---
-//
-// Filters the scope picker's user/group list only — "total" always stays
-// reachable (unconditionally the list's first entry, below), and the
-// CURRENTLY SELECTED scope is always kept in the list even if it stops
-// matching a new query: the filter narrows what's OFFERED, it must never
-// force-switch (or hide the label of) whatever chart is already rendered.
-// Same shared SearchInput/useSearchQuery and lib/usage-search.ts matching
-// helpers as UsageView.vue — one implementation, no second copy.
-const { query: scopeQuery, normalized: normalizedScopeQuery, hasQuery: hasScopeQuery } = useSearchQuery()
-
-const scopeOptions = computed(() => {
-  const allUsers = dashboard.usage?.users ?? []
-  const allGroups = dashboard.usage?.groups ?? []
-  const users = allUsers
-    .filter((u) => !hasScopeQuery.value || userMatches(u, normalizedScopeQuery.value) || `user:${u.id}` === history.scope)
-    .map((u) => ({ value: `user:${u.id}`, label: u.id }))
-  const groups = allGroups
-    .filter(
-      (g) =>
-        !hasScopeQuery.value || groupMatches(g, allUsers, normalizedScopeQuery.value) || `group:${g.id}` === history.scope,
-    )
-    .map((g) => ({ value: `group:${g.id}`, label: g.id }))
-  // Models come from the ranking endpoint, which returns only models with
-  // non-zero traffic (operator requirement: the catalog is hundreds of
-  // models, so the picker must never list idle ones). Matched on the plain
-  // id rather than through lib/usage-search's helpers — those match a
-  // user's or group's own shape, and a model entry has neither.
-  const models = (history.modelOptions ?? [])
-    .filter(
-      (m) =>
-        !hasScopeQuery.value ||
-        m.id.toLowerCase().includes(normalizedScopeQuery.value) ||
-        `model:${m.id}` === history.scope,
-    )
-    .map((m) => ({ value: `model:${m.id}`, label: m.id }))
-  // A model already being charted stays in the list even once it drops out
-  // of modelOptions entirely — which happens the moment it goes idle for
-  // the selected window, since that list is non-zero-only. Without this,
-  // the watch below would read it as a vanished scope and force-switch the
-  // reader to "total" mid-look, for the ordinary reason that a model
-  // simply stopped receiving traffic.
-  if (history.scope.startsWith('model:') && !models.some((m) => m.value === history.scope)) {
-    models.push({ value: history.scope, label: history.scope.slice('model:'.length) })
-  }
-  return [{ value: 'total', label: 'Total (all traffic)' }, ...groups, ...users, ...models]
-})
-
-const windows: HistoryWindow[] = ['hour', 'day', 'month']
-const modelMetrics: ModelMetric[] = ['cost', 'req', 'tokin', 'tokout']
-
-/**
- * modelColumns is a stateless ColumnDef set (lib/model-table-columns.ts),
- * built once rather than per-render — the same convention
- * TargetsView.vue's own `columns` constant follows for its identical
- * reason (no per-row closures capture component state, so there is
- * nothing to rebuild).
- */
-const modelColumns = modelTableColumns()
-
-// --- Models-tab prefix filter (F6, dashboard-plan.md) ---
-//
-// history.modelFilter is set by ProvidersView.vue's provider-header link
-// (nav.goToModels(`${p.name}/`), stores/nav.ts — WP-B1) or restored from
-// the `#charts?tab=models&filter=...` hash (lib/hash-state.ts). P3 review
-// fix: setModelFilter now also sends the prefix to the SERVER and
-// refetches (stores/history.ts's own state doc comment on modelFilter),
-// so this re-slice is a harmless second pass over an already-narrowed
-// ranking, not the only filtering step — see lib/model-filter.ts's own
-// doc comment.
-const filteredModelRanking = computed(() => filterModelsByPrefix(history.modelRanking, history.modelFilter))
-
-/**
- * Exports exactly the ranking rows on screen (filter applied, server order
- * kept). free-models-plan.md: every ranking fetch now requests detail=1
- * (stores/history.ts's fetchModelRanking), so the export carries every
- * per-row figure (requests/tokens in/tokens out/cost/free) via
- * modelDetailCsv, not just the single metric currently being ranked by —
- * matching the on-screen table (lib/model-table-columns.ts) exactly,
- * regardless of which metric history.modelMetric happens to be.
- */
-function modelsCsv(): string {
-  return modelDetailCsv(filteredModelRanking.value, WINDOW_LABEL[history.window], WINDOW_SPAN[history.window])
-}
-
-function clearModelFilter(): void {
-  history.setModelFilter('')
-}
-
-/**
- * UsageChart only ever renders on a time-series tab (the template's v-else
- * below), but a `v-else` narrows nothing for the type checker — this does.
- * The 'requests' stand-in is never displayed: it is the value handed over
- * on the one tab where the component is not rendered at all.
- */
-const timeSeriesTab = computed<TimeSeriesTab>(() => (history.tab === 'models' ? 'requests' : history.tab))
-
-function onTabChange(value: string | number): void {
-  history.setTab(value as ChartTab)
-}
-function onScopeChange(value: unknown): void {
-  if (typeof value === 'string') history.setScope(value)
-}
-function onModelMetricChange(value: unknown): void {
-  if (typeof value === 'string') history.setModelMetric(value as ModelMetric)
-}
-
-onMounted(() => {
-  // The picker's model list is fetched here (initial load) and again on
-  // any window change (history.ts's own setWindow) — nowhere else (Q1,
-  // dashboard-plan.md DECISIONS). The selection's own series/ranking
-  // fetch no longer needs a separate call here: startAutoRefresh's poller
-  // (lib/polling.ts) ticks once immediately on start, which is that
-  // initial fetch.
-  void history.fetchModelOptions()
-  history.startAutoRefresh()
-})
-onUnmounted(() => {
-  history.stopAutoRefresh()
-})
-
-// The scope list is only known once the Usage response has loaded — if the
-// previously-selected scope disappears (a user/group config change), fall
-// back to the total scope rather than requesting a now-unknown id. This is
-// ALSO what guards a bogus scope restored from a hand-edited URL hash (F9,
-// dashboard-plan.md: lib/hash-state.ts's parseChartsParams only validates
-// SHAPE — "total"/"user:.+"/"group:.+"/"model:.+" — never that the id
-// actually exists): `watch` without `{ immediate: true }` skips its first
-// evaluation, so a hash-restored scope like "user:ghost" survives the
-// (likely still-empty, pre-fetch) initial scopeOptions and is only judged
-// once dashboard.usage genuinely loads and this computed's value actually
-// changes — at which point a truly nonexistent id resets to 'total' here,
-// exactly like any other vanished scope.
-watch(scopeOptions, (options) => {
-  if (!options.some((o) => o.value === history.scope)) {
-    history.setScope('total')
-  }
-})
-</script>
-
-<template>
-  <Card>
-    <CardHeader class="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
-      <CardTitle>Usage charts</CardTitle>
-      <div class="flex flex-wrap items-center gap-3">
-        <!-- The Models tab has no scope picker to filter (its own Select branch below is the ranking-metric picker instead) — a visible search box that silently does nothing is worse than no box at all. -->
-        <SearchInput
-          v-if="history.tab !== 'models'"
-          v-model="scopeQuery"
-          placeholder="Filter users, groups or models"
-          class="w-56"
-        />
-
-        <Select
-          v-if="history.tab === 'models'"
-          :model-value="history.modelMetric"
-          @update:model-value="onModelMetricChange"
-        >
-          <SelectTrigger class="w-40" aria-label="Rank models by">
-            <SelectValue placeholder="Rank by" />
-          </SelectTrigger>
-          <SelectContent>
-            <SelectItem v-for="m in modelMetrics" :key="m" :value="m">
-              {{ MODEL_METRIC_LABEL[m] }}
-            </SelectItem>
-          </SelectContent>
-        </Select>
-
-        <Select v-else :model-value="history.scope" @update:model-value="onScopeChange">
-          <SelectTrigger class="w-56">
-            <SelectValue placeholder="Scope" />
-          </SelectTrigger>
-          <SelectContent>
-            <SelectItem v-for="opt in scopeOptions" :key="opt.value" :value="opt.value">
-              {{ opt.label }}
-            </SelectItem>
-          </SelectContent>
-        </Select>
-
-        <Tabs :model-value="history.window" @update:model-value="(v) => history.setWindow(v as HistoryWindow)">
-          <TabsList>
-            <TabsTrigger v-for="w in windows" :key="w" :value="w">{{ WINDOW_LABEL[w] }}</TabsTrigger>
-          </TabsList>
-        </Tabs>
-      </div>
-    </CardHeader>
-    <CardContent class="flex flex-col gap-4">
-      <Tabs :model-value="history.tab" @update:model-value="onTabChange">
-        <TabsList>
-          <TabsTrigger value="requests">Requests</TabsTrigger>
-          <TabsTrigger value="tokens">Tokens</TabsTrigger>
-          <TabsTrigger value="cost">Cost</TabsTrigger>
-          <TabsTrigger value="models">Models</TabsTrigger>
-        </TabsList>
-      </Tabs>
-
-      <p v-if="history.error" class="text-sm text-destructive">{{ history.error }}</p>
-      <!-- Only until the current selection's first fetch lands (history.loaded) — background refreshes never flash it over rendered data. -->
-      <p v-else-if="history.loading && !history.loaded" class="text-sm text-muted-foreground">Loading…</p>
-      <template v-if="history.tab === 'models'">
-        <p class="text-sm text-muted-foreground">
-          Models with usage over the last {{ WINDOW_LABEL[history.window] }}, ranked by
-          {{ MODEL_METRIC_LABEL[history.modelMetric].toLowerCase() }}. Each row is the provider that served the
-          traffic, so a model reached through more than one provider appears once per provider.
-        </p>
-        <p v-if="history.modelFilter" class="flex items-center gap-1.5 text-sm">
-          <span class="text-muted-foreground">Filtered to</span>
-          <span class="font-mono text-xs">{{ history.modelFilter }}</span>
-          <Button variant="ghost" size="icon-xs" aria-label="Clear model filter" @click="clearModelFilter">
-            <FontAwesomeIcon :icon="faXmark" class="size-3.5" aria-hidden="true" />
-          </Button>
-        </p>
-        <!-- P3: the ranking is a top-N (MODEL_RANKING_LIMIT), never the complete set — say so whenever the fetched ranking is exactly that long, so a full list doesn't silently read as "this is everything". -->
-        <p v-if="history.modelRanking.length === MODEL_RANKING_LIMIT" class="text-xs text-muted-foreground">
-          Top {{ MODEL_RANKING_LIMIT }} models
-        </p>
-        <ModelUsageChart :metric="history.modelMetric" :models="filteredModelRanking" />
-        <!--
-          free-models-plan.md: the per-model detail table beneath the
-          chart, with a per-row Requests/Tokens in/Tokens out/Cost
-          breakdown (a free model shows a "free" badge instead of $0 —
-          lib/model-table-columns.ts). Guarded by the same
-          filteredModelRanking.length check ModelUsageChart's own empty
-          state already uses above, so an empty window shows exactly ONE
-          "no model recorded any usage" message, not a second, empty
-          table stacked under it.
-        -->
-        <DataTable
-          v-if="filteredModelRanking.length"
-          :columns="modelColumns"
-          :data="filteredModelRanking"
-          empty-message="No model recorded any usage in this window."
-        />
-        <div class="flex justify-end">
-          <CsvExportButton :filename="`usage-models-${history.window}.csv`" :build="modelsCsv" />
-        </div>
-      </template>
-      <UsageChart v-else :tab="timeSeriesTab" :window="history.window" :series-by-metric="history.seriesByMetric" />
-    </CardContent>
-  </Card>
-</template>
diff --git a/webui/src/components/ClampedRangeNotice.vue b/webui/src/components/ClampedRangeNotice.vue
new file mode 100644
index 0000000..35f0f70
--- /dev/null
+++ b/webui/src/components/ClampedRangeNotice.vue
@@ -0,0 +1,38 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { dayOrMonthClampNotice } from '@/lib/range'
+import type { HistoryWindow } from '@/types/api'
+
+/**
+ * ClampedRangeNotice (N3 fix, verify-redesign-final.md) is the ONE shared
+ * "this view silently clamped your range" banner for every day/month-only
+ * endpoint reached through lib/range.ts's dayOrMonthWindow:
+ *   - UserDetail.vue's "Models used" table (usermodel totals)
+ *   - AttributionDrilldown.vue's usermodel level (the Spend drilldown)
+ *   - TargetCallers.vue (targetcaller totals)
+ * An hour-resolution global range (24h/48h) has no day/month equivalent
+ * for any of these — dayOrMonthWindow silently substitutes a fixed
+ * 7-day day-window instead, and this renders nothing (dayOrMonthClampNotice
+ * returns null) unless that substitution actually happened, so a
+ * day/month-window reader never sees a spurious banner.
+ *
+ * Distinct from ReliabilityPage.vue's own inline month-clamp Alert — a
+ * DIFFERENT clamp (hour/day -> a fixed 30-day window, stores/
+ * reliability.ts's hourOrDayWindow) that stays its own local computed,
+ * not this component.
+ */
+const props = defineProps<{
+  window: HistoryWindow
+  span: number
+}>()
+
+const note = computed<string | null>(() => dayOrMonthClampNotice(props.window, props.span))
+</script>
+
+<template>
+  <Alert v-if="note" variant="warn">
+    <AlertDescription>{{ note }}</AlertDescription>
+  </Alert>
+</template>
diff --git a/webui/src/components/CompactNumber.vue b/webui/src/components/CompactNumber.vue
index 4529533..612e576 100644
--- a/webui/src/components/CompactNumber.vue
+++ b/webui/src/components/CompactNumber.vue
@@ -9,8 +9,8 @@ import { formatCompactCount, formatExactInt } from '@/lib/format'
  * (mouse hover) and a visually-hidden sibling span (keyboard/screen-
  * reader parity). Used anywhere a usage count renders: DataTable numeric
  * columns (usage-columns.ts, target-columns.ts, via
- * `h(CompactNumber, { value })`), the Usage tab's Total card, and a
- * group accordion's trigger/detail stat grid (UsageView.vue).
+ * `h(CompactNumber, { value })`), the Consumers page's Total row, and a
+ * group accordion's trigger/detail stat grid (ConsumerDirectory.vue).
  *
  * Review fix (folded minor, ARIA): `aria-label` on a plain `<span>` is
  * an axe `aria-prohibited-attr` violation — a `<span>`'s implicit ARIA
diff --git a/webui/src/components/ConfigTree.vue b/webui/src/components/ConfigTree.vue
new file mode 100644
index 0000000..d8121cb
--- /dev/null
+++ b/webui/src/components/ConfigTree.vue
@@ -0,0 +1,37 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+
+import SnippetBlock from '@/components/SnippetBlock.vue'
+import { Alert, AlertDescription, AlertTitle } from '@/components/ui/alert'
+import { emitYamlDocument, toYamlValue } from '@/lib/yaml-emit'
+import type { YamlValue } from '@/lib/yaml-emit'
+
+/**
+ * ConfigTree (redesign-plan.md section 3.4) renders GET /admin/api/config's
+ * already-redacted `config` (admin_config.go's redactConfig — every
+ * apiKey/password literal replaced with "[redacted]", an "env:NAME"/
+ * "file:/path" indirection kept, every baseUrl/url stripped of userinfo)
+ * as read-only YAML via lib/yaml-emit.ts's generic recursive renderer —
+ * safe to render as-is, never re-sanitized client-side (types/api.ts's
+ * AdminConfigResponse doc comment).
+ */
+const props = defineProps<{
+  config: Record<string, unknown>
+  warnings: string[]
+}>()
+
+const yamlText = computed(() => {
+  const value = toYamlValue(props.config) as Record<string, YamlValue | undefined>
+  return emitYamlDocument(value)
+})
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <Alert v-for="(warning, index) in warnings" :key="index" variant="warn">
+      <AlertTitle>Config warning</AlertTitle>
+      <AlertDescription>{{ warning }}</AlertDescription>
+    </Alert>
+    <SnippetBlock label="Redacted running config (read-only)" :text="yamlText" />
+  </div>
+</template>
diff --git a/webui/src/components/UsageView.vue b/webui/src/components/ConsumerDirectory.vue
similarity index 57%
rename from webui/src/components/UsageView.vue
rename to webui/src/components/ConsumerDirectory.vue
index 318a029..4506991 100644
--- a/webui/src/components/UsageView.vue
+++ b/webui/src/components/ConsumerDirectory.vue
@@ -2,13 +2,11 @@
 import type { SortingState } from '@tanstack/vue-table'
 import { getCoreRowModel, getSortedRowModel, useVueTable } from '@tanstack/vue-table'
 import { computed, onMounted, onUnmounted, reactive, ref, watch } from 'vue'
-import { storeToRefs } from 'pinia'
 
 import CompactNumber from '@/components/CompactNumber.vue'
 import CostForecastCard from '@/components/CostForecastCard.vue'
 import CsvExportButton from '@/components/CsvExportButton.vue'
 import ModelChip from '@/components/ModelChip.vue'
-import ScopeLink from '@/components/ScopeLink.vue'
 import SearchInput from '@/components/SearchInput.vue'
 import SortHeaderButton from '@/components/SortHeaderButton.vue'
 import { Accordion, AccordionContent, AccordionItem, AccordionTrigger } from '@/components/ui/accordion'
@@ -19,7 +17,6 @@ import UsageBar from '@/components/UsageBar.vue'
 import UsageTable from '@/components/UsageTable.vue'
 import { useNow } from '@/composables/useNow'
 import { useSearchQuery } from '@/composables/useSearchQuery'
-import { useNavStore } from '@/stores/nav'
 import { headroom, monthProgress, projectMonthEnd } from '@/lib/forecast'
 import { formatCost, formatExactInt, formatLimits } from '@/lib/format'
 import { type ExpandState, clearExpandOverrides, computeExpandedItems, toggleItemExpand } from '@/lib/search-expand'
@@ -27,19 +24,37 @@ import { BUDGET_RATIO_LABEL, type BudgetRatio, budgetRatios } from '@/lib/usage-
 import { usageColumns } from '@/lib/usage-columns'
 import { usageCsv } from '@/lib/usage-csv'
 import { groupMatches, groupNameMatches, matchingMembersOfGroup, membersOfGroup, userMatches } from '@/lib/usage-search'
+import { useConsumersStore } from '@/stores/consumers'
 import { useDashboardStore } from '@/stores/dashboard'
+import { useNavStore } from '@/stores/nav'
 import type { AdminUsageEntryView } from '@/types/api'
 
+/**
+ * ConsumerDirectory (redesign-plan.md section 3.4) is the Consumers page's
+ * default view: the Users/Groups usage-and-access directory that used to
+ * be UsageView.vue's whole tab, moved here verbatim (the Groups accordion
+ * + its access block included, per the coordinator's own instruction) with
+ * three redesign-era changes: nav.usageQuery -> the page's own `q` hash
+ * param (stores/nav.ts no longer special-cases a search string), the id
+ * cell's ScopeLink -> EntityLink (usage-columns.ts, opens this row's own
+ * UserDetail instead of jumping to the old flat Charts tab), and a new
+ * Source column (inline/file, GET /admin/api/consumers) on the flat Users
+ * table only.
+ */
 const dashboard = useDashboardStore()
+const consumers = useConsumersStore()
+const nav = useNavStore()
 const usage = computed(() => dashboard.usage)
 
-// The one shared reactive clock every time-dependent read on this tab uses
+onMounted(() => {
+  void consumers.ensureConsumers()
+})
+
+// The one shared reactive clock every time-dependent read on this page uses
 // (P1, composables/useNow.ts's own doc comment) — CostForecastCard's own
 // elapsedFraction, usageColumns()'s `now` parameter (both the real Users/
 // Members <table>s below and the headless Groups toolbar's groupColumns),
-// and groupCostProjection all read THIS ref, never their own `new Date()`,
-// so a long-open tab's cost projections advance together instead of
-// freezing at whatever instant each one happened to first run.
+// and groupCostProjection all read THIS ref, never their own `new Date()`.
 const { now, start: startClock, stop: stopClock } = useNow()
 onMounted(startClock)
 onUnmounted(stopClock)
@@ -60,25 +75,24 @@ function memberCountOf(entry: AdminUsageEntryView): string {
   return count === undefined ? '' : String(count)
 }
 
-// --- user/group search filter (operator feature, mirrors
-// ProvidersView.vue's model search via the shared SearchInput component and
-// useSearchQuery composable — same styling, same clear-button behavior.
-// Matching logic lives in lib/usage-search.ts, which ChartsView.vue's own
-// scope-picker filter calls directly too (groupMatches, userMatches) — no
-// second copy of "does this user/group match?") ---
-// Bound to nav.usageQuery so the search text round-trips through the URL hash (#usage?q=…, lib/hash-state.ts).
-const { usageQuery } = storeToRefs(useNavStore())
+/** sourceOf (Consumers redesign) joins a usage entry's id against GET /admin/api/consumers' own users list — 'inline' or 'file' (admin.go: adminConsumerUser.Source), undefined until that on-demand fetch resolves or for an id it has no match for (a group row never has one). Passed to usage-columns.ts's usageColumns() as `sourceValue` — see that module's sourceColumn doc comment. */
+function sourceOf(entry: AdminUsageEntryView): string | undefined {
+  return consumers.data?.users.find((u) => u.name === entry.id)?.source
+}
+
+// --- user/group search filter (operator feature) ---
+// Matching logic lives in lib/usage-search.ts. Bound to nav.params.q so
+// the search text round-trips through the URL hash (#consumers?q=...,
+// lib/hash-state.ts) — stores/nav.ts's own `params` is opaque, so this
+// page owns interpreting/writing its own `q` key directly, rather than
+// the old nav.usageQuery special case.
+const usageQuery = computed<string>({
+  get: () => nav.params.q ?? '',
+  set: (value) => nav.goTo('consumers', { ...nav.params, q: value }),
+})
 const { query: userQuery, normalized: normalizedQuery, hasQuery } = useSearchQuery(usageQuery)
 
-/**
- * filteredGroups is every group matching the query — own name OR a
- * matching member (lib/usage-search.ts's groupMatches, binding semantics)
- * — or every group when there is no query. This feeds groupsTable's
- * `data()` below directly, so filtering happens upstream of sorting: the
- * Groups sort toolbar and the Accordion both operate on the same
- * (possibly narrowed) list, no separate filtering pass downstream of the
- * table.
- */
+/** filteredGroups is every group matching the query — own name OR a matching member (lib/usage-search.ts's groupMatches) — or every group when there is no query. */
 const filteredGroups = computed<AdminUsageEntryView[]>(() => {
   const all = usage.value?.groups ?? []
   if (!hasQuery.value) return all
@@ -86,101 +100,46 @@ const filteredGroups = computed<AdminUsageEntryView[]>(() => {
   return all.filter((g) => groupMatches(g, users, normalizedQuery.value))
 })
 
-/**
- * memberOnlyMatchIds is filteredGroups narrowed to groups that matched
- * ONLY via a member, never via their own name — the auto-expand target
- * set (search-expand.ts's computeExpandedItems `matchingIds`).
- *
- * This is a DELIBERATE divergence from ProvidersView.vue, not an
- * oversight, and NOT because Providers lacks a provider-name match —
- * it doesn't lack one: providerMatches there (ProvidersView.vue) checks
- * each model's full ROUTABLE id, `${provider}/${model}`
- * (lib/format.ts's routableModelId), so a query like "openai" matches
- * every "openai/..." model id and the whole provider auto-expands with
- * every one of them showing. That is correct there — a provider's own
- * model list IS what the search is for, so revealing it is the point,
- * and EVERY provider match (name-flavored or not) auto-expands.
- *
- * Groups differ: a group's own name is already fully legible on its
- * COLLAPSED trigger row (the `<AccordionTrigger>` below) — no expansion
- * needed to read a name match. Auto-expanding every name-matched group too
- * would dump every one of their full member rosters onto the screen for a
- * query that only needed the trigger row to already be visible. A member-ONLY
- * match has no such shortcut — the member that matched stays invisible
- * until the group opens — so that case alone still auto-expands.
- * search-expand.ts itself has no opinion on any of this; it is purely
- * this view's own choice of matchingIds.
- */
+/** memberOnlyMatchIds is filteredGroups narrowed to groups that matched ONLY via a member, never via their own name — the auto-expand target set (search-expand.ts's computeExpandedItems `matchingIds`). A group's own name is already legible on its collapsed trigger row, so only a member-only match needs auto-expansion to reveal what matched. */
 const memberOnlyMatchIds = computed<string[]>(() => {
   if (!hasQuery.value) return []
   return filteredGroups.value.filter((g) => !groupNameMatches(g, normalizedQuery.value)).map((g) => g.id)
 })
 
-/**
- * visibleMembers implements the members-table distinction (binding
- * semantics): a group matched by its OWN name shows every member
- * (membersOfGroup); a group that matched only via a member shows only
- * the matching ones — the exported, tested matchingMembersOfGroup
- * helper (lib/usage-search.ts), not a re-filter of userMatches here. No
- * active query behaves like a name match — show everyone, today's
- * behavior unchanged. Replaces the former local membersOf helper.
- */
+/** visibleMembers: a group matched by its OWN name shows every member; a group that matched only via a member shows only the matching ones. */
 function visibleMembers(group: AdminUsageEntryView): AdminUsageEntryView[] {
   const users = usage.value?.users ?? []
   if (!hasQuery.value || groupNameMatches(group, normalizedQuery.value)) return membersOfGroup(group, users)
   return matchingMembersOfGroup(group, users, normalizedQuery.value)
 }
 
-/** groupsEmptyMessage mirrors ProvidersView.vue's aliasEmptyMessage three-way pattern: distinguishes nothing configured from nothing matching the active query, so an empty Groups card never reads the same regardless of why it's empty. */
 const groupsEmptyMessage = computed(() =>
   !usage.value?.groups.length ? 'none configured' : hasQuery.value ? `no groups match "${userQuery.value}"` : 'none',
 )
 
-/**
- * filteredUsers is every user matching the query directly, PLUS every
- * member of a group that matched by NAME (semantics item 5: "a
- * group-name match includes all of that group's member rows"). A group
- * that matched only via ONE member must not pull its other, non-matching
- * members into this flat table too — that narrower distinction is
- * visibleMembers' job, scoped to the nested table inside an expanded
- * group, not this one.
- */
+/** filteredUsers is every user matching the query directly, PLUS every member of a group that matched by NAME. */
 const filteredUsers = computed<AdminUsageEntryView[]>(() => {
   const all = usage.value?.users ?? []
   if (!hasQuery.value) return all
   const groups = usage.value?.groups ?? []
-  const nameMatchedGroupIds = new Set(
-    groups.filter((g) => groupNameMatches(g, normalizedQuery.value)).map((g) => g.id),
-  )
+  const nameMatchedGroupIds = new Set(groups.filter((g) => groupNameMatches(g, normalizedQuery.value)).map((g) => g.id))
   return all.filter(
-    (u) =>
-      userMatches(u, normalizedQuery.value) ||
-      (u.groups ?? [u.groupName]).some((g) => g !== undefined && nameMatchedGroupIds.has(g)),
+    (u) => userMatches(u, normalizedQuery.value) || (u.groups ?? [u.groupName]).some((g) => g !== undefined && nameMatchedGroupIds.has(g)),
   )
 })
-/** usersEmptyMessage mirrors groupsEmptyMessage's three-way pattern (see its own doc comment). */
 const usersEmptyMessage = computed(() =>
   !usage.value?.users.length ? 'none configured' : hasQuery.value ? `no users match "${userQuery.value}"` : 'none',
 )
 
-// --- Groups accordion (operator directive) ---
+// --- Groups accordion ---
 //
-// Groups render as a shadcn-vue Accordion, same component and rationale
-// as Providers (ProvidersView.vue) — expanding a group shows its member
-// users' own usage rows below it. A group's row cannot ALSO be a literal
-// <table> row for the identical reason Providers' old expandable row was
-// retired: AccordionItem wraps its trigger+content in a <div>, illegal
-// directly inside a <tbody>/<tr>.
-//
-// "Sortable groups usage" (operator directive) is therefore implemented
-// headlessly: the SAME usageColumns() defs used by the real <table>-based
-// UsageTable (Users, and each group's own nested member list) drive a
-// second, unrendered useVueTable instance here purely for its
-// getSortedRowModel() — sortedGroupRows below. The small button toolbar
-// under the Groups heading toggles that sort using the identical
-// SortHeaderButton DataTable.vue's real <th>s use (same icons, same
-// toggleSorting call, same accessible name), just laid out as a toolbar
-// instead of <th>s, because there is no <table> here to put a <th> in.
+// Groups render as a shadcn-vue Accordion — expanding a group shows its
+// member users' own usage rows below it. "Sortable groups usage" is
+// implemented headlessly: the SAME usageColumns() defs the real <table>-
+// based UsageTable uses drive a second, unrendered useVueTable instance
+// here purely for its getSortedRowModel() — sortedGroupRows below. The
+// small button toolbar under the Groups heading toggles that sort using
+// the identical SortHeaderButton DataTable.vue's real <th>s use.
 const groupColumns = computed(() => usageColumns('Name', 'Members', memberCountOf, now.value))
 const groupSorting = ref<SortingState>([])
 const groupsTable = useVueTable({
@@ -201,36 +160,16 @@ const groupsTable = useVueTable({
 })
 const sortedGroupRows = computed(() => groupsTable.getRowModel().rows)
 
-/**
- * TOOLBAR_COLUMN_IDS restricts the toolbar to exactly the fields each
- * trigger row displays (Name, Members, req/day, cost/day) — review fix:
- * exposing all 11 usageColumns() fields as sortable when only 4 are
- * visible per row let the accordion's order silently diverge from what
- * the toolbar visibly claims to control. The full stat set stays
- * available inside each expanded item's own detail grid, just not as a
- * sort key here.
- */
+/** TOOLBAR_COLUMN_IDS restricts the toolbar to exactly the fields each trigger row displays (Name, Members, req/day, cost/day) — the full stat set stays available inside each expanded item's own detail grid, just not as a sort key here. */
 const TOOLBAR_COLUMN_IDS = new Set(['id', 'secondary', 'reqDay', 'costDay'])
-const toolbarHeaders = computed(() =>
-  groupsTable.getHeaderGroups()[0].headers.filter((header) => TOOLBAR_COLUMN_IDS.has(header.column.id)),
-)
+const toolbarHeaders = computed(() => groupsTable.getHeaderGroups()[0].headers.filter((header) => TOOLBAR_COLUMN_IDS.has(header.column.id)))
 
-/**
- * Which groups are open — driven by the SAME tested lib/search-expand.ts
- * state ProvidersView.vue uses for providers (generalized from
- * provider-expand.ts specifically so this view could reuse it, rather
- * than fork a second copy — see that module's own doc comment). The
- * adapter shape is the identical get/set computed pattern
- * expandedProviderValues uses there, translating the Set-based effective
- * state into the string[] Accordion's `type="multiple"` v-model expects.
- */
+/** Which groups are open — driven by the shared tested lib/search-expand.ts state. */
 const groupExpandState: ExpandState = reactive({
   manuallyExpanded: new Set<string>(),
   manuallyCollapsed: new Set<string>(),
 })
-const expandedGroups = computed<Set<string>>(() =>
-  computeExpandedItems(groupExpandState, hasQuery.value, memberOnlyMatchIds.value),
-)
+const expandedGroups = computed<Set<string>>(() => computeExpandedItems(groupExpandState, hasQuery.value, memberOnlyMatchIds.value))
 function toggleGroup(id: string): void {
   toggleItemExpand(groupExpandState, id, expandedGroups.value.has(id))
 }
@@ -249,74 +188,26 @@ const expandedGroupValues = computed<string[]>({
 
 // A stale manuallyCollapsed suppression from one search must never
 // silently carry into a later, unrelated one — see ExpandState's own doc
-// comment. Watching userQuery (not just the clear button) covers
-// backspacing to empty too — same convention as ProvidersView.vue.
+// comment.
 watch(userQuery, (value) => {
   if (value.trim() === '') clearExpandOverrides(groupExpandState)
 })
 
-// --- Access block (group-access-display task, review round) ---
-//
-// GLOB_HINT is the title attribute on every Access label (Providers,
-// Models, MCP servers, Agents): group.allowsX (auth.go) matches every one
-// of these four configured lists via matchesGlob/path.Match semantics, not
-// literal equality — a heading that just says "Models" leaves that
-// invisible. One constant, not four copies of the same string (vue.md:
-// "if you've written it twice, you owe an abstraction").
+// --- Access block (moved from UsageView.vue, unchanged) ---
 const GLOB_HINT = 'Glob pattern — matches like a shell wildcard (*, ?, [...])'
 
-/**
- * isGlobPattern reports whether one configured models entry is a glob
- * pattern rather than a literal model id — the same special characters
- * path.Match recognizes (auth.go's matchesGlob, which group.allowsModel
- * calls). Only Models needs this distinction rendered differently: a
- * literal id gets the copyable ModelChip treatment (it IS a routable id a
- * caller can paste into a request's `model` field); a pattern like
- * "gpt-4*" is not a valid id and must not invite copying it as one, so it
- * renders as a plain, non-copyable Badge instead (see the template below).
- * Providers/MCPServers/Agents render every entry as a plain Badge either
- * way, so they need no such split.
- */
+/** isGlobPattern reports whether one configured models entry is a glob pattern rather than a literal model id — the same special characters path.Match recognizes (auth.go's matchesGlob). */
 function isGlobPattern(entry: string): boolean {
   return /[*?[]/.test(entry)
 }
 
-// --- F1 usage-vs-limit bars (group detail grid) ---
-//
-// usage-columns.ts's own numericColumn already renders a bar beside each
-// TABLE cell that has a configured limit (Users table, and — reused — the
-// Members table inside an expanded group). A group's own accordion detail
-// grid (the dl/dd block below, distinct from its nested Members table) has
-// no per-cell numeric columns at all, so it renders budgetRatios directly
-// as one compact row of labeled bars instead — the coordinator brief's own
-// phrasing ("Group detail grid ... renders bars from budgetRatios").
-
-// BUDGET_RATIO_LABEL (P10/P11 review fix): imported from lib/usage-bars.ts
-// — this used to be a second, independently-declared copy here (BUDGET_LABEL)
-// with slightly different text ("tok/day" here vs usage-columns.ts's own
-// bar label), the exact DRY drift the coordinator's review flagged. The one
-// shared definition also spells out "tokens (in+out)/day" (P10) for the
-// tokDay/tokMonth ids — accurate for a screen-reader user, who has no OTHER
-// column beside this compact grid's own labeled bar to infer the combined-
-// total measurement from.
-
-/** budgetValueText renders one BudgetRatio's "used / limit" detail text (UsageBar's aria-valuetext/title) — cost ids in dollars (formatCost, the micro-USD unit budgetRatios already computed them in), every other id as a plain thousands-separated count. */
+/** budgetValueText renders one BudgetRatio's "used / limit" detail text (UsageBar's aria-valuetext/title). */
 function budgetValueText(ratio: BudgetRatio): string {
   if (ratio.id.startsWith('cost')) return `${formatCost(ratio.used)} / ${formatCost(ratio.limit)}`
   return `${formatExactInt(ratio.used)} / ${formatExactInt(ratio.limit)}`
 }
 
-/**
- * groupCostProjection (F7) mirrors usage-columns.ts's own costMonthProjColumn
- * math for one group row — the coordinator brief's own phrasing ("also in
- * group grid"): the group detail dl/dd block is not a DataTable column, so
- * it cannot reuse that column's ColumnDef cell renderer directly, but the
- * underlying lib/forecast.ts math (monthProgress/projectMonthEnd/headroom)
- * is identical. `now` is the shared clock (useNow, above) — the SAME
- * instant every other time-dependent read on this tab uses — not a fresh
- * `new Date()` read per call, so this grid's own projection never disagrees
- * with CostForecastCard's or a column's mid-render.
- */
+/** groupCostProjection mirrors usage-columns.ts's own costMonthProjColumn math for one group row. */
 function groupCostProjection(entry: AdminUsageEntryView, now: Date): { text: string; willExceed: boolean } {
   const elapsedFraction = monthProgress(now)
   const projected = projectMonthEnd(entry.costPerMonthMicroUsd, elapsedFraction)
@@ -324,22 +215,8 @@ function groupCostProjection(entry: AdminUsageEntryView, now: Date): { text: str
   return { text: formatCost(projected), willExceed: headroom(projected, entry.limits?.costPerMonthUSD).willExceed }
 }
 
-// --- F8 CSV export ---
-//
-// Each button exports whatever rows are CURRENTLY visible: Groups export
-// in the Groups toolbar's own sort order (sortedGroupRows, already
-// computed below for the headless sort toolbar); Users export in the
-// Users <table>'s own CURRENT column sort (P6 review fix — this used to
-// export in filtered order alone, a self-declared deviation from the plan's
-// "exports filtered+sorted rows"). The Users DataTable's sort state is
-// LIFTED UP here via DataTable.vue's `v-model:sorting` (that component's
-// own doc comment) — usersSorting below is bound two ways: down into the
-// rendered UsageTable (template) so a header click writes back here, and
-// into a second, headless useVueTable instance (usersTable) that applies
-// the identical sort to filteredUsers so usersCsv can read it back in the
-// same order the reader is actually looking at — the same "one sort state,
-// two consumers" shape sortedGroupRows/groupsTable already used for Groups.
-const usersColumns = computed(() => usageColumns('Name', 'Group', groupNameOf, now.value))
+// --- CSV export ---
+const usersColumns = computed(() => usageColumns('Name', 'Group', groupNameOf, now.value, sourceOf))
 const usersSorting = ref<SortingState>([])
 const usersTable = useVueTable({
   get data() {
@@ -391,7 +268,6 @@ function groupsCsv(): string {
           <p class="text-lg font-semibold tabular-nums"><CompactNumber :value="usage.total.requestsPerDay" /></p>
         </div>
         <div>
-          <!-- F4: fleet-wide requests denied by a limit check today (types/api.ts's own doc comment) — destructive tint once positive, mirroring usage-columns.ts's own rejDay column convention. -->
           <p class="text-muted-foreground">Rejected/day</p>
           <p class="text-lg font-semibold tabular-nums" :class="usage.total.rejectionsPerDay > 0 ? 'text-destructive' : undefined">
             <CompactNumber :value="usage.total.rejectionsPerDay" />
@@ -412,7 +288,6 @@ function groupsCsv(): string {
       </CardContent>
     </Card>
 
-    <!-- F7: fleet-wide cost forecast, directly under the Total card (coordinator brief). -->
     <CostForecastCard v-if="usage" :mtd-micros="usage.total.costPerMonthMicroUsd" :limits="usage.total.limits" :now="now" />
 
     <Card>
@@ -422,39 +297,18 @@ function groupsCsv(): string {
             <CardTitle>Groups</CardTitle>
             <CardDescription>Expand a group to see its member users' own usage.</CardDescription>
           </div>
-          <CsvExportButton filename="usage-groups.csv" :build="groupsCsv" />
+          <CsvExportButton filename="consumers-groups.csv" :build="groupsCsv" />
         </div>
       </CardHeader>
       <CardContent>
-        <div
-          v-if="sortedGroupRows.length"
-          class="mb-3 flex flex-wrap gap-x-4 gap-y-1 text-xs font-medium text-muted-foreground"
-        >
+        <div v-if="sortedGroupRows.length" class="mb-3 flex flex-wrap gap-x-4 gap-y-1 text-xs font-medium text-muted-foreground">
           <SortHeaderButton v-for="header in toolbarHeaders" :key="header.id" :header="header" />
         </div>
 
         <Accordion v-if="sortedGroupRows.length" v-model="expandedGroupValues" type="multiple" class="rounded-md border px-3">
           <AccordionItem v-for="row in sortedGroupRows" :key="row.original.id" :value="row.original.id">
-            <!--
-              P2 review fix: ScopeLink moved OUTSIDE AccordionTrigger — a
-              real interactive element can never be a valid descendant of
-              another interactive element (AccordionTrigger's own <button>,
-              reka-ui), so it is now a sibling in this header row instead
-              of nested inside the trigger's own slot. `py-2.5` matches
-              AccordionTrigger.vue's own vertical padding so the two line
-              up, keeping the same visual row the nested version had.
-              `header-class="flex-1"` fills the AccordionHeader (<h3>) that
-              wraps the trigger button, since AccordionTrigger's own
-              `class` prop lands on the inner button, not the header — see
-              AccordionTrigger.vue's doc comment. Without it the header
-              shrinks to content width, so the chevron drifts left of the
-              row's right edge and the empty space to its right stops
-              being clickable. The sr-only span gives the toggle button an
-              accessible name that names the group, since the visible text
-              beside it is just counts.
-            -->
             <div class="flex items-center gap-2">
-              <ScopeLink class="shrink-0 py-2.5 font-medium" :label="row.original.id" :scope="`group:${row.original.id}`" />
+              <span class="shrink-0 py-2.5 font-medium">{{ row.original.id }}</span>
               <AccordionTrigger header-class="flex-1">
                 <span class="sr-only">Group {{ row.original.id }} details</span>
                 <span class="flex flex-1 flex-wrap items-center gap-x-4 gap-y-1 pr-2 text-left">
@@ -470,16 +324,6 @@ function groupsCsv(): string {
               </AccordionTrigger>
             </div>
             <AccordionContent>
-              <!--
-                Access block (group-access-display task): the group's
-                configured provider/model/MCP-server/agent access,
-                display-only — not part of the user/group search filter
-                above (row.original.providers/models/mcpServers/agents are
-                plain display data, never touched by groupMatches/
-                userMatches in lib/usage-search.ts). Same dl/dt/dd
-                convention as the stat grid immediately below — one
-                convention per panel.
-              -->
               <dl class="mb-3 grid grid-cols-2 gap-x-6 gap-y-1.5 text-sm sm:grid-cols-4">
                 <div>
                   <dt class="text-xs text-muted-foreground" :title="GLOB_HINT">Providers</dt>
@@ -531,13 +375,7 @@ function groupsCsv(): string {
                   <dt class="text-xs text-muted-foreground" :title="GLOB_HINT">Agents</dt>
                   <dd>
                     <div v-if="row.original.agents?.length" class="flex flex-wrap gap-1.5">
-                      <Badge
-                        v-for="agentName in row.original.agents"
-                        :key="agentName"
-                        as="span"
-                        variant="secondary"
-                        class="font-mono font-normal"
-                      >
+                      <Badge v-for="agentName in row.original.agents" :key="agentName" as="span" variant="secondary" class="font-mono font-normal">
                         {{ agentName }}
                       </Badge>
                     </div>
@@ -597,7 +435,6 @@ function groupsCsv(): string {
                   <dd class="tabular-nums">{{ row.original.storeDown ? '?' : formatCost(row.original.costPerMonthMicroUsd) }}</dd>
                 </div>
                 <div>
-                  <!-- F7: projected month-end cost, extrapolated from this group's own month-to-date spend (mirrors usage-columns.ts's costMonthProj column). -->
                   <dt class="text-xs text-muted-foreground">cost/month (proj.)</dt>
                   <dd
                     class="tabular-nums"
@@ -608,7 +445,6 @@ function groupsCsv(): string {
                   </dd>
                 </div>
               </dl>
-              <!-- F1: usage-vs-limit bars, one per configured limit — budgetRatios (lib/usage-bars.ts) returns nothing for an unlimited group or a storeDown one, so this whole row is simply absent then. -->
               <div v-if="budgetRatios(row.original).length" class="mb-3 flex flex-wrap items-center gap-x-4 gap-y-1.5">
                 <span
                   v-for="ratio in budgetRatios(row.original)"
@@ -626,6 +462,7 @@ function groupsCsv(): string {
                 :entries="visibleMembers(row.original)"
                 :secondary-value="groupNameOf"
                 :now="now"
+                :source-value="sourceOf"
               />
             </AccordionContent>
           </AccordionItem>
@@ -637,8 +474,11 @@ function groupsCsv(): string {
     <Card>
       <CardHeader>
         <div class="flex items-start justify-between gap-2">
-          <CardTitle>Users</CardTitle>
-          <CsvExportButton filename="usage-users.csv" :build="usersCsv" />
+          <div>
+            <CardTitle>Users</CardTitle>
+            <CardDescription v-if="consumers.data?.usersFile">File-backed users load from {{ consumers.data.usersFile }}.</CardDescription>
+          </div>
+          <CsvExportButton filename="consumers-users.csv" :build="usersCsv" />
         </div>
       </CardHeader>
       <CardContent>
@@ -649,6 +489,7 @@ function groupsCsv(): string {
           :secondary-value="groupNameOf"
           :empty-message="usersEmptyMessage"
           :now="now"
+          :source-value="sourceOf"
           v-model:sorting="usersSorting"
         />
       </CardContent>
diff --git a/webui/src/components/CostAvoidedCard.vue b/webui/src/components/CostAvoidedCard.vue
new file mode 100644
index 0000000..116bc68
--- /dev/null
+++ b/webui/src/components/CostAvoidedCard.vue
@@ -0,0 +1,142 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { costAvoidedMicros, freeRows, pickReferenceModel } from '@/lib/cost-avoided'
+import { formatCost } from '@/lib/format'
+import type { AdminCatalogModel, AdminUsageModelEntry } from '@/types/api'
+
+/**
+ * CostAvoidedCard (redesign-plan.md section 3.4) reports what the fleet's
+ * free-tier traffic in range WOULD have cost against a real, priced
+ * reference model — lib/cost-avoided.ts's own doc comment has the unit
+ * derivation. The reference model defaults to the most-requested priced
+ * model actually served in range (pickReferenceModel) but is always
+ * reader-overridable via the picker below; `ref` is a CONTROLLED prop
+ * (this card owns no picker state itself), mirroring DataTable.vue's own
+ * `sorting`/`update:sorting` convention — SpendPage.vue keeps the current
+ * choice in the `ref` page param (redesign-plan.md section 3.1) so a
+ * reload or shared link restores the same comparison.
+ *
+ * Cache savings (redesign-plan.md section 3.4: "cache savings (sum csave)
+ * shown alongside when enabled") render as a second figure beside the
+ * cost-avoided one, only when `cacheStatsEnabled` — a genuinely different
+ * saving (a repeat request served from cache, never re-billed at all) that
+ * would otherwise be easy to conflate with "served by a free model".
+ *
+ * N2 fix (verify-redesign-final.md): the figure is not always summable.
+ * `cacheSavingsAvailable` (lib/cache-savings.ts's own doc comment has the
+ * full backend grounding) is false for an hour-window range — the
+ * backend never writes a per-hour cache-savings bucket at all, so
+ * `m.cacheSavedMicroUsd` is undefined on every row and summing it would
+ * silently render a fabricated "$0.00" rather than "no data for this
+ * range". The card renders "n/a" instead whenever it is false.
+ */
+const props = defineProps<{
+  /** The model ranking (GET /admin/api/usage/models, detail=1) — every free row feeds costAvoidedMicros; every catalog-priced row is a candidate reference model. */
+  models: AdminUsageModelEntry[]
+  catalog: Map<string, AdminCatalogModel>
+  /**
+   * The reader's explicit reference-model override (the `ref` page param),
+   * or '' for "use the default". Named `refModel`, not `ref` — `ref` is a
+   * reserved Vue template attribute (component template refs); a prop
+   * literally named `ref` can never be set from a parent's template via
+   * `:ref="..."`, since Vue always intercepts that binding for its own
+   * template-ref mechanism instead of passing it through as a prop.
+   */
+  refModel: string
+  /** AdminFeaturesView.cacheStats — gates the cache-savings figure. */
+  cacheStatsEnabled: boolean
+  /**
+   * cacheSavingsAvailable (N2 fix, lib/cache-savings.ts's own
+   * cacheSavingsStatus) — false for an hour-window range, where the
+   * backend has no per-hour cache-savings bucket at all. The card
+   * renders "n/a" instead of a figure when this is false, never a
+   * fabricated "$0.00". SpendPage.vue computes this from the current
+   * global range (it owns the filters store; this card stays a pure,
+   * props-driven component).
+   */
+  cacheSavingsAvailable: boolean
+  /**
+   * cacheSavingsNote (N2 fix) — a caveat to show ALONGSIDE an available
+   * figure (currently only the month-window "35-day retention" note,
+   * lib/cache-savings.ts), or the reason text when
+   * `cacheSavingsAvailable` is false. Null when the figure is available
+   * and exact (day-window ranges).
+   */
+  cacheSavingsNote?: string | null
+}>()
+
+const emit = defineEmits<{ 'update:refModel': [value: string] }>()
+
+/** priceableOptions is the picker's own list: every served model whose catalog entry is genuinely priced (excludes free/unpriced — comparing free traffic against another $0 model is meaningless, the same filter pickReferenceModel itself applies), sorted by descending requests so the most relevant choices sit at the top. */
+const priceableOptions = computed<{ id: string; requests: number }[]>(() => {
+  const out: { id: string; requests: number }[] = []
+  for (const m of props.models) {
+    const cat = props.catalog.get(m.id)
+    if (!cat || cat.priceSource === 'free' || cat.priceSource === 'unpriced') continue
+    out.push({ id: m.id, requests: m.requests ?? 0 })
+  }
+  return out.sort((a, b) => b.requests - a.requests)
+})
+
+const defaultReference = computed<string | null>(() => pickReferenceModel(props.models, props.catalog))
+const effectiveReference = computed<string | null>(() => props.refModel || defaultReference.value)
+const referenceCatalog = computed<AdminCatalogModel | undefined>(() =>
+  effectiveReference.value ? props.catalog.get(effectiveReference.value) : undefined,
+)
+
+const avoidedMicros = computed<number | null>(() => {
+  const cat = referenceCatalog.value
+  if (!cat || cat.inputPerMTokUsd === undefined || cat.outputPerMTokUsd === undefined) return null
+  return costAvoidedMicros(freeRows(props.models), cat.inputPerMTokUsd, cat.outputPerMTokUsd)
+})
+
+const cacheSavedMicros = computed<number>(() => {
+  let total = 0
+  for (const m of props.models) total += m.cacheSavedMicroUsd ?? 0
+  return total
+})
+
+function onReferenceUpdate(value: unknown): void {
+  if (typeof value === 'string') emit('update:refModel', value)
+}
+</script>
+
+<template>
+  <Card>
+    <CardHeader class="flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between">
+      <div>
+        <CardTitle>Cost avoided</CardTitle>
+        <CardDescription>What free-tier traffic in range would have cost at a real model's own rates.</CardDescription>
+      </div>
+      <div v-if="priceableOptions.length > 0" class="flex flex-col gap-1">
+        <label id="cost-avoided-ref-label" class="text-xs font-medium text-muted-foreground">Reference model</label>
+        <Select :model-value="effectiveReference ?? undefined" @update:model-value="onReferenceUpdate">
+          <SelectTrigger aria-labelledby="cost-avoided-ref-label" class="w-56">
+            <SelectValue placeholder="Pick a reference model" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem v-for="opt in priceableOptions" :key="opt.id" :value="opt.id">{{ opt.id }}</SelectItem>
+          </SelectContent>
+        </Select>
+      </div>
+    </CardHeader>
+    <CardContent class="grid grid-cols-2 gap-4 text-sm">
+      <div>
+        <p class="text-muted-foreground">Cost avoided (free-tier traffic)</p>
+        <p v-if="avoidedMicros === null" class="text-sm text-muted-foreground">
+          {{ priceableOptions.length === 0 ? 'No priced model served in range to compare against.' : 'Pick a reference model above.' }}
+        </p>
+        <p v-else class="text-lg font-semibold tabular-nums text-chart-requests">{{ formatCost(avoidedMicros) }}</p>
+      </div>
+      <div v-if="cacheStatsEnabled">
+        <p class="text-muted-foreground">Cache savings</p>
+        <p v-if="!cacheSavingsAvailable" class="text-lg font-semibold tabular-nums text-muted-foreground">n/a</p>
+        <p v-else class="text-lg font-semibold tabular-nums text-chart-requests">{{ formatCost(cacheSavedMicros) }}</p>
+        <p v-if="cacheSavingsNote" class="text-xs text-status-warn">{{ cacheSavingsNote }}</p>
+      </div>
+    </CardContent>
+  </Card>
+</template>
diff --git a/webui/src/components/CostForecastCard.vue b/webui/src/components/CostForecastCard.vue
index a4f8215..dee5459 100644
--- a/webui/src/components/CostForecastCard.vue
+++ b/webui/src/components/CostForecastCard.vue
@@ -7,27 +7,30 @@ import { formatCost } from '@/lib/format'
 import type { LimitsConfig } from '@/types/api'
 
 /**
- * CostForecastCard renders the Usage tab's fleet-wide cost projection —
- * F7, placed under the Total card (UsageView.vue). All math is delegated
- * to lib/forecast.ts's pure functions; this component only formats and
- * lays the result out.
+ * CostForecastCard renders a fleet- or scope-wide cost projection — F7,
+ * originally the pre-redesign Usage tab's own card, now used by both
+ * SpendPage.vue (the global range's own scope, under the burn-down chart)
+ * and ConsumerDirectory.vue (fleet-wide, under the Total row). All math is
+ * delegated to lib/forecast.ts's pure functions; this component only
+ * formats and lays the result out.
  *
  * `now` is a REQUIRED prop, not read from `new Date()` inside this
  * component (coordinator brief: "now passed as prop for determinism") —
- * the caller (UsageView.vue) supplies it, keeping every `Date.now()`-
- * flavored read in this feature at the boundary rather than buried inside
- * a component, same discipline lib/forecast.ts's own functions already
- * follow by taking `now`/`elapsedFraction` as plain arguments.
+ * every caller supplies it from its OWN composables/useNow.ts instance,
+ * keeping every `Date.now()`-flavored read in this feature at the
+ * boundary rather than buried inside a component, same discipline
+ * lib/forecast.ts's own functions already follow by taking
+ * `now`/`elapsedFraction` as plain arguments.
  *
  * P1 review fix: this used to be optional with a `withDefaults(...,
  * { now: () => new Date() })` default. Vue caches a prop's default value
  * ONCE per component instance (propsDefaults) — the very first time it is
  * read, not on every render — so a caller that omitted `now` froze this
  * card's projection at whatever instant it happened to mount, never
- * advancing again for as long as the tab stayed open. `now` is now
- * required: UsageView.vue passes the ONE shared reactive clock
- * (composables/useNow.ts) every time-dependent read on this tab shares,
- * so there is no default left to accidentally freeze.
+ * advancing again for as long as the page stayed open. `now` is now
+ * required: every caller passes the ONE shared reactive clock its own
+ * useNow() call returns, so there is no default left to accidentally
+ * freeze.
  */
 const props = defineProps<{
   /** usage.total.costPerMonthMicroUsd — fleet-wide month-to-date spend. */
diff --git a/webui/src/components/CsvExportButton.vue b/webui/src/components/CsvExportButton.vue
index 90bfeae..dda4086 100644
--- a/webui/src/components/CsvExportButton.vue
+++ b/webui/src/components/CsvExportButton.vue
@@ -7,11 +7,11 @@ import { downloadText, type DownloadOutcome } from '@/lib/download'
 
 /**
  * CsvExportButton is the one "Export CSV" control every table export in
- * this panel uses — F8. Owned by WP-B1 (usage-csv.ts, this component) but
- * consumed unmodified by WP-B2's Models tab, which builds its own CSV text
- * via lib/usage-csv.ts's modelDetailCsv and passes it through the same
- * `build` prop — one export affordance, not a copy per tab (vue.md: "if
- * you've written it twice, you owe an abstraction").
+ * this panel uses (F8) — ConsumerDirectory.vue's Users/Groups exports
+ * (lib/usage-csv.ts's usageCsv) and PricingHealthTable.vue's own
+ * pricing-health export each build their own CSV text and pass it
+ * through the same `build` prop — one export affordance, not a copy per
+ * table (vue.md: "if you've written it twice, you owe an abstraction").
  *
  * `build` is called fresh on every click, never memoized — an export
  * always reflects whatever rows are CURRENTLY visible (filtered + sorted)
diff --git a/webui/src/components/DataTable.vue b/webui/src/components/DataTable.vue
index b4e16d7..1774a9c 100644
--- a/webui/src/components/DataTable.vue
+++ b/webui/src/components/DataTable.vue
@@ -43,8 +43,8 @@ const props = defineProps<{
    * default) keeps every existing call site's original UNCONTROLLED
    * behavior unchanged — this component owns `internalSorting` itself and
    * a caller has no way to read the current sort. Passed, a caller (e.g.
-   * UsageView.vue's Users export, which needs to export rows in the
-   * table's own current sort order — the plan's own "exports
+   * ConsumerDirectory.vue's Users export, which needs to export rows in
+   * the table's own current sort order — the plan's own "exports
    * filtered+sorted rows" requirement) instead owns the ref: every header
    * click emits `update:sorting` with the new state rather than mutating
    * anything locally here.
diff --git a/webui/src/components/EntityLink.vue b/webui/src/components/EntityLink.vue
new file mode 100644
index 0000000..f2297d6
--- /dev/null
+++ b/webui/src/components/EntityLink.vue
@@ -0,0 +1,57 @@
+<script setup lang="ts">
+import { faArrowUpRightFromSquare } from '@fortawesome/free-solid-svg-icons'
+
+import { useNavStore } from '@/stores/nav'
+
+/**
+ * EntityLink (redesign-plan.md section 3.5) is the redesigned shell's own
+ * navigation link for an entity id: a user id opens Consumers pre-filtered
+ * to that user (lib/usage-columns.ts's id cell, UserDetail.vue), a model
+ * id opens Models pre-filtered to that model (lib/model-table-columns.ts's
+ * id cell) — nav.goTo rather than a bare href, so it stays inside the
+ * SPA's own hash-routed shell. It replaced ScopeLink.vue (deleted, section
+ * 3.5) once every one of that component's own call sites had switched
+ * over.
+ *
+ * Structural note carried over from ScopeLink.vue: a real
+ * `<button type="button">`, always rendered as a SIBLING of whatever
+ * interactive element it sits beside (a table cell, an accordion header),
+ * never nested inside one — the HTML button content model forbids a
+ * focusable descendant, and nesting one breaks both keyboard operation
+ * and how assistive technology exposes it.
+ */
+const props = defineProps<{
+  /** The visible + accessible label, e.g. a user id or model id. */
+  label: string
+  /** Which page this id opens — 'user' -> Consumers, 'model' -> Models. */
+  kind: 'user' | 'model'
+  /** The raw entity id (never pre-formatted as "kind:id" — this component builds nav.goTo's own params itself). */
+  id: string
+}>()
+
+const nav = useNavStore()
+
+const TARGET: Record<'user' | 'model', { page: 'consumers' | 'models'; paramKey: 'user' | 'model'; noun: string }> = {
+  user: { page: 'consumers', paramKey: 'user', noun: 'Consumers' },
+  model: { page: 'models', paramKey: 'model', noun: 'Models' },
+}
+
+function onClick(event: MouseEvent): void {
+  event.stopPropagation()
+  const target = TARGET[props.kind]
+  nav.goTo(target.page, { [target.paramKey]: props.id })
+}
+</script>
+
+<template>
+  <button
+    type="button"
+    :aria-label="`View ${label} in ${TARGET[kind].noun}`"
+    :title="`View ${label} in ${TARGET[kind].noun}`"
+    class="inline-flex cursor-pointer items-center gap-1 rounded-sm text-inherit hover:text-primary hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50"
+    @click="onClick"
+  >
+    <span>{{ label }}</span>
+    <FontAwesomeIcon :icon="faArrowUpRightFromSquare" class="size-3" aria-hidden="true" />
+  </button>
+</template>
diff --git a/webui/src/components/EventsView.vue b/webui/src/components/EventsView.vue
index d44ba24..cdbe8e6 100644
--- a/webui/src/components/EventsView.vue
+++ b/webui/src/components/EventsView.vue
@@ -25,8 +25,9 @@ const ALL_KINDS = 'all'
 // kindFilter/userFilter live on the store, not as local refs (F9,
 // hash-state): composables/useHashState.ts reads/writes them directly so
 // this filter round-trips through the URL hash. userFilter binds through
-// useSearchQuery's own external-ref option, the same way UsageView.vue
-// binds nav.usageQuery — see useSearchQuery.ts's own doc comment.
+// useSearchQuery's own external-ref option — see useSearchQuery.ts's own
+// doc comment for the other current external-ref caller
+// (ConsumerDirectory.vue).
 const { kindFilter, userFilter } = storeToRefs(events)
 const { normalized: normalizedUserQuery } = useSearchQuery(userFilter)
 
@@ -48,9 +49,9 @@ function onKindChange(value: unknown): void {
 const columns = eventsColumns()
 
 /**
- * emptyMessage mirrors TargetsView.vue/UsageView.vue's own three-way
- * pattern: distinguishes "nothing recorded at all" from "nothing matches
- * the active filter".
+ * emptyMessage mirrors TargetsView.vue/ConsumerDirectory.vue's own
+ * three-way pattern: distinguishes "nothing recorded at all" from
+ * "nothing matches the active filter".
  *
  * P9 review fix: gated on events.lastUpdated (null until the first fetch
  * settles, stores/events.ts) — this used to read events.events.length
diff --git a/webui/src/components/GlobalFilterBar.vue b/webui/src/components/GlobalFilterBar.vue
new file mode 100644
index 0000000..a462509
--- /dev/null
+++ b/webui/src/components/GlobalFilterBar.vue
@@ -0,0 +1,134 @@
+<script setup lang="ts">
+import { faArrowRightArrowLeft } from '@fortawesome/free-solid-svg-icons'
+import { computed, ref, watch } from 'vue'
+
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { SCOPE_PATTERN } from '@/lib/hash-state'
+import { RANGE_KEYS } from '@/lib/range'
+import type { RangeKey } from '@/lib/range'
+import { DEFAULT_SCOPE, useFiltersStore } from '@/stores/filters'
+
+/** RANGE_LABEL is the range Select's display text per lib/range.ts's RangeKey — kept here (not lib/range.ts) since it is pure presentation, not logic a store or another page's fetch needs. */
+const RANGE_LABEL: Record<RangeKey, string> = {
+  '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',
+}
+
+/**
+ * GlobalFilterBar (redesign-plan.md section 3.1) is the shell's one
+ * control surface for the three global filters (stores/filters.ts):
+ * time range, "vs previous period" comparison, and an optional
+ * group/user/provider scope narrowing. Every page reads the SAME filters
+ * store; this bar is mounted once, in App.vue's header, not per-page.
+ */
+const filters = useFiltersStore()
+
+function onRangeUpdate(value: unknown): void {
+  if (typeof value !== 'string') return
+  filters.setFilters({ range: value as RangeKey })
+}
+
+/**
+ * toggleCmp (P3 item 19): turning the comparison OFF is always allowed,
+ * even when the CURRENT range does not support one — a `cmp=prev` value
+ * restored from the hash (e.g. loaded directly onto a 48h/30d/12mo range,
+ * where 2*span exceeds the retention ceiling) used to leave the button
+ * permanently pressed-and-disabled, with no way to turn it off short of
+ * changing the range first. filters.cmpSpec.requested already gates the
+ * actual fetch on availability (stores/filters.ts's own doc comment), so
+ * this was purely a stuck AFFORDANCE, never a bad request. Turning it ON
+ * still requires availability — there is nothing to compare against
+ * otherwise.
+ */
+function toggleCmp(): void {
+  if (filters.cmp === 'prev') {
+    filters.setFilters({ cmp: 'none' })
+    return
+  }
+  if (!filters.cmpSpec.available) return
+  filters.setFilters({ cmp: 'prev' })
+}
+
+/** cmpDisabled only blocks turning the toggle ON when unavailable — turning an already-on comparison OFF is never blocked (toggleCmp's own doc comment). */
+const cmpDisabled = computed<boolean>(() => filters.cmp !== 'prev' && !filters.cmpSpec.available)
+
+const cmpTitle = computed<string>(() => {
+  if (filters.cmp === 'prev' && !filters.cmpSpec.available) {
+    return `Comparison unavailable for this range (${filters.cmpSpec.reason}) — click to turn off`
+  }
+  if (filters.cmpSpec.available) return 'Compare against the previous equal-length period'
+  return `Comparison unavailable for this range: ${filters.cmpSpec.reason}`
+})
+
+// scopeDraft is a local editing buffer, not bound straight to
+// filters.scope: a partially-typed value ("group:") must not spam
+// setFilters/refetch every store on every keystroke, and an invalid
+// commit (onBlur/Enter, below) must revert the FIELD, not the store —
+// the store keeps whatever scope was last valid.
+const scopeDraft = ref(filters.scope)
+watch(
+  () => filters.scope,
+  (scope) => {
+    scopeDraft.value = scope
+  },
+)
+
+function commitScope(): void {
+  const value = scopeDraft.value.trim() || DEFAULT_SCOPE
+  if (SCOPE_PATTERN.test(value)) {
+    filters.setFilters({ scope: value })
+  } else {
+    // Invalid — revert the field to the store's own current value rather than keeping the bad text on screen.
+    scopeDraft.value = filters.scope
+  }
+}
+</script>
+
+<template>
+  <div class="flex flex-wrap items-end gap-3">
+    <div class="flex flex-col gap-1">
+      <label id="global-filter-range-label" class="text-xs font-medium text-muted-foreground">Range</label>
+      <Select :model-value="filters.range" @update:model-value="onRangeUpdate">
+        <SelectTrigger aria-labelledby="global-filter-range-label" class="w-36">
+          <SelectValue />
+        </SelectTrigger>
+        <SelectContent>
+          <SelectItem v-for="key in RANGE_KEYS" :key="key" :value="key">{{ RANGE_LABEL[key] }}</SelectItem>
+        </SelectContent>
+      </Select>
+    </div>
+
+    <Button
+      type="button"
+      variant="outline"
+      :aria-pressed="filters.cmp === 'prev'"
+      :disabled="cmpDisabled"
+      :title="cmpTitle"
+      @click="toggleCmp"
+    >
+      <FontAwesomeIcon :icon="faArrowRightArrowLeft" class="size-3.5" aria-hidden="true" />
+      vs previous period
+    </Button>
+
+    <div class="flex flex-col gap-1">
+      <label for="global-filter-scope" class="text-xs font-medium text-muted-foreground">Scope</label>
+      <Input
+        id="global-filter-scope"
+        v-model="scopeDraft"
+        class="w-48"
+        placeholder="all"
+        title="all, group:<name>, user:<name>, or provider:<name>"
+        @keyup.enter="commitScope"
+        @blur="commitScope"
+      />
+    </div>
+  </div>
+</template>
diff --git a/webui/src/components/KpiTile.vue b/webui/src/components/KpiTile.vue
new file mode 100644
index 0000000..616451c
--- /dev/null
+++ b/webui/src/components/KpiTile.vue
@@ -0,0 +1,70 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+
+import { Card, CardContent } from '@/components/ui/card'
+import type { KpiTier } from '@/lib/kpi'
+import type { PageId } from '@/lib/pages'
+import { useNavStore } from '@/stores/nav'
+
+/**
+ * KpiTile (redesign-plan.md section 3.4) is the Home page's one KPI-tile
+ * shape: a label, a headline value, an optional delta/detail line, and a
+ * tier (lib/kpi.ts) that colors the value text — 'ok' (default
+ * foreground), 'warn' (--status-warn), 'critical' (--destructive), the
+ * same two semantic tokens the rest of this panel's badges/bars already
+ * use, never a fourth ad-hoc color.
+ *
+ * Optionally a link: when `to` is set, the whole tile becomes a real
+ * `<button>` that calls nav.goTo(to.page, to.params) — a budget tile
+ * jumps to Spend, an open-breakers tile jumps to Reliability, and so on.
+ * Without `to`, it renders as a plain, non-interactive Card (a tile with
+ * nowhere useful to send the reader, e.g. "requests/min", stays inert
+ * rather than a button that does nothing).
+ */
+const props = withDefaults(
+  defineProps<{
+    label: string
+    value: string
+    delta?: string
+    tier?: KpiTier
+    to?: { page: PageId; params?: Record<string, string> }
+  }>(),
+  { tier: 'ok' },
+)
+
+const nav = useNavStore()
+
+const valueClass = computed<string>(() => {
+  switch (props.tier) {
+    case 'warn':
+      return 'text-status-warn'
+    case 'critical':
+      return 'text-destructive'
+    default:
+      return 'text-foreground'
+  }
+})
+
+function onClick(): void {
+  if (!props.to) return
+  nav.goTo(props.to.page, props.to.params ?? {})
+}
+</script>
+
+<template>
+  <component
+    :is="to ? 'button' : 'div'"
+    :type="to ? 'button' : undefined"
+    class="block w-full rounded-xl text-left"
+    :class="to ? 'cursor-pointer transition-colors hover:opacity-90 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50' : undefined"
+    @click="onClick"
+  >
+    <Card>
+      <CardContent class="flex flex-col gap-1 px-4 py-3">
+        <span class="text-xs font-medium text-muted-foreground">{{ label }}</span>
+        <span class="text-2xl font-semibold tracking-tight tabular-nums" :class="valueClass">{{ value }}</span>
+        <span v-if="delta" class="text-xs text-muted-foreground">{{ delta }}</span>
+      </CardContent>
+    </Card>
+  </component>
+</template>
diff --git a/webui/src/components/ModelCatalogTable.vue b/webui/src/components/ModelCatalogTable.vue
new file mode 100644
index 0000000..6585cc7
--- /dev/null
+++ b/webui/src/components/ModelCatalogTable.vue
@@ -0,0 +1,69 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+
+import DataTable from '@/components/DataTable.vue'
+import SearchInput from '@/components/SearchInput.vue'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { filterModelRows } from '@/lib/model-filter'
+import { modelCatalogColumns } from '@/lib/model-table-columns'
+import type { ModelCatalogRow } from '@/lib/model-table-columns'
+
+/**
+ * ModelCatalogTable (redesign-plan.md section 3.4, Models & providers
+ * page) is the catalog-driven table: every configured model (not just
+ * ones with observed traffic), joined with the current range's ranking
+ * and fleet performance — ModelCatalogRow's own doc comment
+ * (lib/model-table-columns.ts) has the full join contract.
+ *
+ * `query` is a controlled v-model, not owned locally: ModelsPage.vue keeps
+ * it so the Models page's own `q` hash param (redesign-plan.md section
+ * 3.1) round-trips through the URL, the same controlled-component
+ * convention SearchInput.vue itself already documents.
+ */
+const props = defineProps<{
+  rows: ModelCatalogRow[]
+  query: string
+  /** GET /admin/api/performance's own latencyEnabled (AdminPerfResponse) — false means admin.stats.latency is off, so p50/p95 read "—" for every row, not "no traffic yet". */
+  latencyEnabled: boolean
+  loading: boolean
+}>()
+
+const emit = defineEmits<{ 'update:query': [value: string] }>()
+
+const filtered = computed<ModelCatalogRow[]>(() => filterModelRows(props.rows, props.query))
+
+const columns = modelCatalogColumns()
+
+const emptyMessage = computed<string>(() => {
+  if (props.loading) return 'loading…'
+  if (props.rows.length === 0) return 'no models configured'
+  if (props.query.trim()) return `no models match "${props.query}"`
+  return 'none'
+})
+</script>
+
+<template>
+  <Card>
+    <CardHeader>
+      <CardTitle>Model catalog</CardTitle>
+      <CardDescription>
+        Every configured model: price source, per-model usage for the current range, fleet p50/p95, and error rate.
+      </CardDescription>
+      <SearchInput
+        :model-value="query"
+        placeholder="Search models or aliases..."
+        class="mt-2 max-w-sm"
+        @update:model-value="emit('update:query', $event)"
+      />
+    </CardHeader>
+    <CardContent class="flex flex-col gap-3">
+      <Alert v-if="!latencyEnabled" variant="warn">
+        <AlertDescription>
+          Latency percentiles (p50/p95) are off for this deployment. Enable <code>admin.stats.latency</code> to see them.
+        </AlertDescription>
+      </Alert>
+      <DataTable :columns="columns" :data="filtered" :empty-message="emptyMessage" />
+    </CardContent>
+  </Card>
+</template>
diff --git a/webui/src/components/ModelChip.vue b/webui/src/components/ModelChip.vue
index 5625e78..92584ce 100644
--- a/webui/src/components/ModelChip.vue
+++ b/webui/src/components/ModelChip.vue
@@ -9,13 +9,15 @@ import { formatContextWindow, formatModelCostHover } from '@/lib/format'
 /**
  * ModelChip is one clickable, copyable model-id chip, used anywhere a
  * resolvable model or alias id renders: a provider's expanded model list
- * (ProvidersView.vue's accordion), the model-alias table, and a group's
- * usage-detail model list (UsageView.vue — passed with no metadata props
- * there, since a raw group-config glob entry has no resolvable provider/
- * model pair to look metadata up against). id is the full routable id
- * (lib/format.ts's routableModelId) or an alias name — what actually
- * gets copied, so a pasted value works straight into a `model: "..."`
- * request field.
+ * and the model-alias table (both ProviderHealthPanel.vue's accordion),
+ * the Models page's own catalog table (lib/model-table-columns.ts, WITH
+ * metadata props — see contextTokens/inputPerMTokUsd/outputPerMTokUsd
+ * below), and a group's own allowed-models list (ConsumerDirectory.vue —
+ * passed with no metadata props there for a raw glob entry, since it has
+ * no resolvable provider/model pair to look metadata up against). id is
+ * the full routable id (lib/format.ts's routableModelId) or an alias
+ * name — what actually gets copied, so a pasted value works straight
+ * into a `model: "..."` request field.
  *
  * contextTokens/inputPerMTokUsd/outputPerMTokUsd are this model's
  * resolved metadata (feature v0.23, hover-detail refinement:
diff --git a/webui/src/components/ModelUsageChart.vue b/webui/src/components/ModelUsageChart.vue
deleted file mode 100644
index 43da886..0000000
--- a/webui/src/components/ModelUsageChart.vue
+++ /dev/null
@@ -1,119 +0,0 @@
-<script setup lang="ts">
-import type { ChartData, ChartOptions } from 'chart.js'
-import { computed } from 'vue'
-import { Bar } from 'vue-chartjs'
-
-import '@/lib/chart-setup'
-import { useThemeColors } from '@/composables/useThemeColors'
-import { formatCompactCount, formatCost, formatExactInt } from '@/lib/format'
-import { MODEL_METRIC_LABEL, type ModelMetric } from '@/stores/history'
-import type { AdminUsageModelEntry } from '@/types/api'
-
-const props = defineProps<{
-  metric: ModelMetric
-  models: AdminUsageModelEntry[]
-}>()
-
-const { foreground, mutedForeground, border } = useThemeColors()
-
-/**
- * One token per rankable metric, reusing the SAME --chart-* custom
- * properties the time-series chart uses (UsageChart.vue's DATASET_SPECS),
- * so a model's bar is the colour that metric already has elsewhere in the
- * view rather than a second, conflicting palette.
- */
-const METRIC_COLOR: Record<ModelMetric, string> = {
-  req: '--chart-requests',
-  tokin: '--chart-tokens-in',
-  tokout: '--chart-tokens-out',
-  cost: '--chart-cost',
-}
-
-/** Cost is stored as micro-USD (limits.go's account/history convention); every other metric is already the display unit. */
-function toDisplayValue(metric: ModelMetric, raw: number): number {
-  return metric === 'cost' ? raw / 1_000_000 : raw
-}
-
-/** resolveToken reads a --chart-* custom property from :root, live — same approach (and same reason) as UsageChart.vue. */
-function resolveToken(cssVar: string): string {
-  return getComputedStyle(document.documentElement).getPropertyValue(cssVar).trim()
-}
-
-/**
- * The server already returns the ranking sorted, descending, and capped —
- * this component neither re-sorts nor re-filters it. Chart.js draws the
- * first category at the TOP of a horizontal bar chart, so the busiest
- * model lands where a reader looks first, with no reversal needed.
- */
-const chartData = computed<ChartData<'bar'>>(() => {
-  void foreground.value // re-run on a prefers-color-scheme flip (see UsageChart.vue)
-  return {
-    labels: props.models.map((m) => m.id),
-    datasets: [
-      {
-        label: MODEL_METRIC_LABEL[props.metric],
-        backgroundColor: resolveToken(METRIC_COLOR[props.metric]),
-        data: props.models.map((m) => toDisplayValue(props.metric, m.value)),
-      },
-    ],
-  }
-})
-
-/**
- * Height grows with the row count so bars keep a readable thickness
- * instead of compressing into hairlines at 20 models, and so a two-model
- * ranking does not stretch each bar across a third of the screen.
- */
-const chartHeight = computed<string>(() => `${Math.max(180, props.models.length * 28 + 60)}px`)
-
-const chartOptions = computed<ChartOptions<'bar'>>(() => ({
-  indexAxis: 'y',
-  responsive: true,
-  maintainAspectRatio: false,
-  animation: false,
-  scales: {
-    x: {
-      // Zero-based, honest axis: bar length is the whole comparison here.
-      beginAtZero: true,
-      grid: { color: border.value },
-      ticks: {
-        color: mutedForeground.value,
-        // Reuses formatCost, same rationale as UsageChart.vue's identical
-        // fix: a raw tick float interpolated directly into "$${value}" can
-        // print unrounded binary-float noise; formatCost's .toFixed(4)
-        // resolves it, and is the same formatter every other cost figure
-        // in this app already renders through.
-        callback: (value) => (props.metric === 'cost' ? formatCost(Number(value) * 1_000_000) : formatCompactCount(Number(value))),
-      },
-    },
-    y: {
-      grid: { display: false },
-      ticks: { color: mutedForeground.value, autoSkip: false },
-    },
-  },
-  plugins: {
-    legend: { display: false },
-    tooltip: {
-      callbacks: {
-        // Compact figure plus the exact one, matching UsageChart.vue's
-        // tooltip contract — a tooltip has room for both, and precision
-        // must never be lost to the axis's compact form.
-        label: (ctx) => {
-          const value = ctx.parsed.x ?? 0
-          if (props.metric === 'cost') return `${MODEL_METRIC_LABEL[props.metric]}: $${value.toFixed(4)}`
-          return `${MODEL_METRIC_LABEL[props.metric]}: ${formatCompactCount(value)} (${formatExactInt(value)})`
-        },
-      },
-    },
-  },
-}))
-</script>
-
-<template>
-  <p v-if="models.length === 0" class="py-8 text-center text-sm text-muted-foreground">
-    No model recorded any usage in this window.
-  </p>
-  <div v-else class="w-full" :style="{ height: chartHeight }">
-    <Bar :data="chartData" :options="chartOptions" />
-  </div>
-</template>
diff --git a/webui/src/components/PricingHealthTable.vue b/webui/src/components/PricingHealthTable.vue
new file mode 100644
index 0000000..4a98e53
--- /dev/null
+++ b/webui/src/components/PricingHealthTable.vue
@@ -0,0 +1,152 @@
+<script setup lang="ts">
+import type { ColumnDef } from '@tanstack/vue-table'
+import { computed, h } from 'vue'
+
+import CompactNumber from '@/components/CompactNumber.vue'
+import CsvExportButton from '@/components/CsvExportButton.vue'
+import DataTable from '@/components/DataTable.vue'
+import EntityLink from '@/components/EntityLink.vue'
+import { Badge } from '@/components/ui/badge'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { toCsv } from '@/lib/csv'
+import { formatContextWindow, formatCost, formatModelCostHover } from '@/lib/format'
+import { joinPricingHealth, pricingHealthOrder } from '@/lib/pricing-health'
+import type { PricingHealthRow } from '@/lib/pricing-health'
+import type { AdminCatalogModel, AdminUsageModelEntry, PriceSource } from '@/types/api'
+
+/**
+ * PricingHealthTable (redesign-plan.md section 3.4) lists every model
+ * actually served in the current range, joined with its catalog entry
+ * (lib/pricing-health.ts's joinPricingHealth), unpriced first with a
+ * destructive badge (pricingHealthOrder) — the row an operator most needs
+ * to act on (a served model billing at $0 because no pricing rule
+ * matched) is always the first thing they see, before any manual sort.
+ */
+const props = defineProps<{
+  models: AdminUsageModelEntry[]
+  catalog: Map<string, AdminCatalogModel>
+}>()
+
+const rows = computed<PricingHealthRow[]>(() => pricingHealthOrder(joinPricingHealth(props.models, props.catalog)))
+
+const unpricedCount = computed<number>(() => rows.value.filter((r) => r.priceSource === 'unpriced').length)
+
+/** SOURCE_BADGE_VARIANT mirrors lib/model-table-columns.ts's own priceCell badge treatment (WP-F, ModelCatalogTable.vue) so the two tables read consistently: destructive for unpriced (needs attention), secondary for a deliberate free model, outline for an explicit rule. */
+const SOURCE_BADGE_VARIANT: Record<PriceSource, 'destructive' | 'secondary' | 'outline'> = {
+  unpriced: 'destructive',
+  free: 'secondary',
+  override: 'outline',
+  builtin: 'outline',
+  litellm: 'outline',
+}
+
+function sourceCell(row: PricingHealthRow) {
+  return h(Badge, { as: 'span', variant: SOURCE_BADGE_VARIANT[row.priceSource], class: 'font-normal' }, () => row.priceSource)
+}
+
+function priceCell(row: PricingHealthRow) {
+  if (row.inputPerMTokUsd === undefined || row.outputPerMTokUsd === undefined) return h('span', { class: 'text-muted-foreground' }, '—')
+  return h('span', {}, formatModelCostHover(row.inputPerMTokUsd, row.outputPerMTokUsd))
+}
+
+const columns: ColumnDef<PricingHealthRow, unknown>[] = [
+  {
+    id: 'id',
+    header: 'Model',
+    accessorFn: (r) => r.id,
+    cell: ({ row }) => h(EntityLink, { label: row.original.id, kind: 'model', id: row.original.id }),
+  },
+  {
+    id: 'source',
+    header: 'Source',
+    accessorFn: (r) => r.priceSource,
+    cell: ({ row }) => sourceCell(row.original),
+  },
+  {
+    id: 'price',
+    header: 'Price',
+    enableSorting: false,
+    cell: ({ row }) => priceCell(row.original),
+  },
+  {
+    id: 'context',
+    header: 'Context',
+    meta: { align: 'right' },
+    accessorFn: (r) => r.contextTokens ?? 0,
+    cell: ({ row }) => h('span', { class: 'tabular-nums' }, row.original.contextTokens !== undefined ? formatContextWindow(row.original.contextTokens) : '—'),
+  },
+  {
+    id: 'requests',
+    header: 'Requests',
+    meta: { align: 'right' },
+    accessorFn: (r) => r.requests,
+    cell: ({ row }) => h(CompactNumber, { value: row.original.requests }),
+  },
+  {
+    id: 'tokensIn',
+    header: 'Tokens in',
+    meta: { align: 'right' },
+    accessorFn: (r) => r.tokensIn,
+    cell: ({ row }) => h(CompactNumber, { value: row.original.tokensIn }),
+  },
+  {
+    id: 'tokensOut',
+    header: 'Tokens out',
+    meta: { align: 'right' },
+    accessorFn: (r) => r.tokensOut,
+    cell: ({ row }) => h(CompactNumber, { value: row.original.tokensOut }),
+  },
+  {
+    id: 'cost',
+    header: 'Cost',
+    meta: { align: 'right' },
+    accessorFn: (r) => r.costMicroUsd,
+    cell: ({ row }) => formatCost(row.original.costMicroUsd),
+  },
+]
+
+/**
+ * pricingHealthCsv exports exactly the rows on screen (unpriced-first
+ * order, or whatever the reader has since re-sorted to — DataTable's own
+ * `data` prop is passed through unmodified) as raw, unformatted values
+ * (CsvExportButton.vue's own doc comment: "always reflects whatever rows
+ * are CURRENTLY visible... never a stale snapshot") — costMicroUsd stays
+ * micro-USD, not a pre-formatted "$X.XXXX" string, so the export re-opens
+ * cleanly as a spreadsheet numeric column.
+ */
+function pricingHealthCsv(): string {
+  return toCsv(
+    ['id', 'priceSource', 'displayFree', 'requests', 'tokensIn', 'tokensOut', 'costMicroUsd', 'contextTokens', 'inputPerMTokUsd', 'outputPerMTokUsd'],
+    rows.value.map((r) => [
+      r.id,
+      r.priceSource,
+      r.displayFree,
+      r.requests,
+      r.tokensIn,
+      r.tokensOut,
+      r.costMicroUsd,
+      r.contextTokens ?? '',
+      r.inputPerMTokUsd ?? '',
+      r.outputPerMTokUsd ?? '',
+    ]),
+  )
+}
+</script>
+
+<template>
+  <Card>
+    <CardHeader>
+      <CardTitle class="flex items-center gap-2">
+        Pricing health
+        <Badge v-if="unpricedCount > 0" variant="destructive" class="font-normal">{{ unpricedCount }} unpriced</Badge>
+      </CardTitle>
+      <CardDescription>Every model served in range, joined with its billing price source.</CardDescription>
+    </CardHeader>
+    <CardContent class="flex flex-col gap-3">
+      <DataTable :columns="columns" :data="rows" empty-message="No model served any traffic in this range." />
+      <div class="flex justify-end">
+        <CsvExportButton filename="pricing-health.csv" :build="pricingHealthCsv" />
+      </div>
+    </CardContent>
+  </Card>
+</template>
diff --git a/webui/src/components/ProvidersView.vue b/webui/src/components/ProviderHealthPanel.vue
similarity index 52%
rename from webui/src/components/ProvidersView.vue
rename to webui/src/components/ProviderHealthPanel.vue
index a106023..554bce2 100644
--- a/webui/src/components/ProvidersView.vue
+++ b/webui/src/components/ProviderHealthPanel.vue
@@ -8,11 +8,12 @@ import {
 import { computed, h, reactive, watch } from 'vue'
 
 import DataTable from '@/components/DataTable.vue'
+import EntityLink from '@/components/EntityLink.vue'
 import ModelChip from '@/components/ModelChip.vue'
 import ProviderRateBadge from '@/components/ProviderRateBadge.vue'
-import ScopeLink from '@/components/ScopeLink.vue'
 import SearchInput from '@/components/SearchInput.vue'
 import { Accordion, AccordionContent, AccordionItem, AccordionTrigger } from '@/components/ui/accordion'
+import { Alert, AlertDescription } from '@/components/ui/alert'
 import { Badge } from '@/components/ui/badge'
 import {
   Card,
@@ -26,79 +27,55 @@ import { formatAgo, formatContextWindow, formatLatencyMs, formatUntil, refreshDe
 import { isModelDegraded } from '@/lib/provider-rate'
 import { type ExpandState, clearExpandOverrides, computeExpandedItems, toggleItemExpand } from '@/lib/search-expand'
 import { useDashboardStore } from '@/stores/dashboard'
+import { useModelsStore } from '@/stores/models'
 import { useNavStore } from '@/stores/nav'
-import type { AdminAliasView, AdminLatencyView, AdminModelMetaView, AdminModelRateView, AdminProvenanceView, AdminProviderView } from '@/types/api'
+import type {
+  AdminAliasView,
+  AdminLatencyView,
+  AdminModelMetaView,
+  AdminModelRateView,
+  AdminPerfRow,
+  AdminProvenanceView,
+  AdminProviderView,
+} from '@/types/api'
 
-// This component backs the "Providers" tab (App.vue) — a UI-label rename
-// only. The data it renders still comes from GET /admin/api/overview
-// (admin.go's adminOverviewResponse) and the store field below keeps that
-// same "overview" name, since the backend route/type names are unchanged
-// API surface.
+/**
+ * ProviderHealthPanel (redesign-plan.md section 3.4, Models & providers
+ * page) is ProvidersView.vue's own Providers accordion + aliases table,
+ * moved here verbatim, PLUS fleet-wide performance (p50/p95, timeouts,
+ * failovers — GET /admin/api/performance?kind=provider, read from
+ * useModelsStore, which the Models page's own onMounted fetches once for
+ * the whole page, shared with ModelCatalogTable.vue). The per-replica
+ * discovery/latency/provenance badges below are UNCHANGED from
+ * ProvidersView.vue — still sourced from the SAME 5s dashboard poll
+ * (GET /admin/api/overview), still per-replica/in-process (see each
+ * badge's own doc comment for why that never averages across replicas).
+ */
 const dashboard = useDashboardStore()
+const models = useModelsStore()
 const overview = computed(() => dashboard.overview)
 const nav = useNavStore()
 
 /**
- * goToProviderModels navigates to the Charts Models ranking, pre-filtered
- * to this provider's own models (F6, dashboard-plan.md: `nav.goToModels`).
- *
- * P2 review fix: this used to back a `<span role="link" tabindex="0">`
- * nested INSIDE AccordionTrigger's own real `<button>` — invalid per the
- * HTML button content model (no descendant may carry a `tabindex`
- * attribute, not just no nested button/anchor) and effectively invisible
- * to assistive technology (ARIA's `button` role declares "children
- * presentational: true", so the nested span was never announced as its
- * own link — see ScopeLink.vue's own doc comment for the identical
- * finding there). The provider-name label is now a real `<button>`,
- * rendered as a SIBLING of AccordionTrigger rather than nested inside it
- * (this component's template) — a plain click handler is enough: a click
- * on a sibling element never bubbles INTO the trigger's own listener
- * (event bubbling only travels through actual ancestors of the click
- * target), so the stopPropagation/Enter-only-keydown machinery this used
- * to need is gone along with the span it protected — native `<button>`
- * keyboard activation (Enter AND Space) is correct here for free.
+ * goToProviderModels navigates to the Models catalog table, pre-filtered
+ * (via its own `q` search) to this provider's own models — the redesign's
+ * replacement for the pre-redesign nav.goToModels (stores/nav.ts no
+ * longer has a per-page goTo* method at all, see that store's own doc
+ * comment; every navigation goes through the single goTo(page, params)).
  */
 function goToProviderModels(providerName: string): void {
-  nav.goToModels(`${providerName}/`)
+  nav.goTo('models', { q: `${providerName}/` })
 }
 
-// --- provider expand/collapse (shadcn-vue Accordion) ---
-//
-// Providers render as a real shadcn-vue Accordion (operator directive:
-// use the library component, restructure the layout to fit it — the
-// earlier hand-rolled table-row-toggle accordion is retired). The
-// trigger is one provider's summary line; the content holds its detail
-// (base URL, last refresh, last error) plus its model-id chips.
-//
-// Expand STATE itself is unchanged: lib/search-expand.ts's plain,
-// Vue-free two-set module (manuallyExpanded/manuallyCollapsed, generalized
-// from provider-expand.ts so UsageView.vue's Groups accordion shares the
-// same tested logic) — the exact search-interaction bug fix a prior review
-// flagged, covered by a real vitest spec (lib/search-expand.spec.ts) that
-// exercises the module directly, without mounting Vue. Only the
-// template-facing adapter changed: expandedProviderValues below is a
-// writable computed translating that Set-based state into the string[]
-// shape Accordion's `type="multiple"` v-model expects, and back —
-// clicking a trigger fires the setter with the new array; diffing it
-// against the previous effective set finds the one name that changed
-// and replays it through the SAME tested toggleItemExpand used before, so
-// Accordion never owns this state itself, only displays it.
+// --- provider expand/collapse (shadcn-vue Accordion) — unchanged from ProvidersView.vue ---
 const expandState: ExpandState = reactive({
   manuallyExpanded: new Set<string>(),
   manuallyCollapsed: new Set<string>(),
 })
 
-// --- model/alias search filter (operator feature) ---
+// --- model/alias search filter (operator feature) — unchanged from ProvidersView.vue ---
 const { query: modelQuery, normalized: normalizedQuery, hasQuery } = useSearchQuery()
 
-/**
- * Matching is against each model's full ROUTABLE id
- * (routableModelId(p.name, m) — the same string ModelChip both displays
- * and copies), not the bare model id: copying a chip's text and pasting
- * it back into search must find it, and the routable form is strictly
- * more permissive (it contains the bare id as a substring), so this
- * never hides a match the bare-id form would have found.
- */
 function modelMatches(providerName: string, modelId: string): boolean {
   return routableModelId(providerName, modelId).toLowerCase().includes(normalizedQuery.value)
 }
@@ -118,7 +95,6 @@ const filteredAliases = computed<AdminAliasView[]>(() => {
   return hasQuery.value ? all.filter(aliasMatches) : all
 })
 
-/** expandedProviders is the EFFECTIVE (possibly auto-expanded-by-search) set — see lib/search-expand.ts's own doc comments for the manual/auto-expand/override semantics. */
 const expandedProviders = computed<Set<string>>(() =>
   computeExpandedItems(
     expandState,
@@ -127,18 +103,10 @@ const expandedProviders = computed<Set<string>>(() =>
   ),
 )
 
-/** toggleProvider reads the CURRENT effective (visible) state for name before flipping it — see toggleItemExpand's own doc comment for exactly which bug this avoids. */
 function toggleProvider(name: string): void {
   toggleItemExpand(expandState, name, expandedProviders.value.has(name))
 }
 
-/**
- * expandedProviderValues adapts expandedProviders (a Set) to Accordion's
- * `type="multiple"` v-model contract (a string[]): reads out as
- * Array.from(expandedProviders.value); writes replay each name whose
- * membership changed through toggleProvider — Accordion never mutates
- * expandState directly, it only tells this setter what changed.
- */
 const expandedProviderValues = computed<string[]>({
   get: () => Array.from(expandedProviders.value),
   set: (newValues) => {
@@ -152,58 +120,33 @@ const expandedProviderValues = computed<string[]>({
   },
 })
 
-// A stale manuallyCollapsed suppression from one search must never
-// silently carry into a later, unrelated one — see ExpandState's own doc
-// comment. Watching modelQuery (not just the explicit clear button)
-// covers backspacing to empty too.
 watch(modelQuery, (value) => {
   if (value.trim() === '') clearExpandOverrides(expandState)
 })
 
-/** visibleModels is p's own model list, filtered to matches while a query is active — p only appears in filteredProviders at all because it has one, so this is never empty in that case; it exists so the accordion shows WHICH models matched instead of re-showing all 70+ with no distinction. */
 function visibleModels(p: AdminProviderView): string[] {
   return hasQuery.value ? p.models.filter((m) => modelMatches(p.name, m)) : p.models
 }
 
-/** ZERO_MODEL_RATE is the fallback ProviderRateBadge reads for a model p.modelRates has no entry for — should not happen (admin.go's buildAdminOverview populates one entry per Models id, unconditionally), but a defensive fallback keeps a stale/mismatched client build from throwing rather than just under-reporting. */
 const ZERO_MODEL_RATE: AdminModelRateView = { attemptsDay: 0, failuresDay: 0 }
 
-/**
- * modelRateFor looks up one model's counters within p.modelRates (Feature
- * A, v0.22), falling back to ZERO_MODEL_RATE. The optional-chain on
- * modelRates itself (folded review minor, v0.22 review round), not just
- * on the lookup, matches ZERO_MODEL_RATE's own doc comment: a stale
- * client talking to an older server build (before this field existed at
- * all) would otherwise throw on `.modelRates[model]` rather than fall
- * back — the type says modelRates is always present, but a real response
- * across a version skew is the one case that type cannot guarantee.
- */
 function modelRateFor(p: AdminProviderView, model: string): AdminModelRateView {
   return p.modelRates?.[model] ?? ZERO_MODEL_RATE
 }
 
-/** modelIsDegraded gates the per-model rate badge (spec: "ONLY when that model is degraded") so a healthy or no-traffic model's ModelChip renders with no badge beside it at all. */
 function modelIsDegraded(p: AdminProviderView, model: string): boolean {
   const r = modelRateFor(p, model)
   return isModelDegraded(r.attemptsDay, r.failuresDay)
 }
 
-/** ZERO_MODEL_META is modelMetaFor's fallback, mirroring ZERO_MODEL_RATE's own doc comment above — every sub-field undefined reads as "nothing known", not a thrown error, across a version-skewed client/server pair. */
 const ZERO_MODEL_META: AdminModelMetaView = {}
 
-/** modelMetaFor looks up one model's resolved metadata within p.modelMeta (feature v0.23), falling back to ZERO_MODEL_META. */
 function modelMetaFor(p: AdminProviderView, model: string): AdminModelMetaView {
   return p.modelMeta?.[model] ?? ZERO_MODEL_META
 }
 
-// --- discovery circuit breaker (feat/provider-health) ---
-//
-// Badge shown ONLY for 'open'/'half-open' — mirroring modelIsDegraded's
-// own "no badge when healthy" convention above: a 'closed' provider (the
-// common case) renders no breaker badge at all, exactly like a
-// non-degraded model gets no ProviderRateBadge.
+// --- discovery circuit breaker (feat/provider-health) — unchanged from ProvidersView.vue ---
 
-/** healthBadgeVariant maps healthState to the shadcn-vue Badge variant: destructive (backing off) for 'open', secondary (in progress) for 'half-open', undefined (no badge) for 'closed'. */
 function healthBadgeVariant(state: AdminProviderView['healthState']): 'destructive' | 'secondary' | undefined {
   switch (state) {
     case 'open':
@@ -215,36 +158,17 @@ function healthBadgeVariant(state: AdminProviderView['healthState']): 'destructi
   }
 }
 
-/** healthBadgeLabel renders the breaker badge's text: "open (in Ns)" while backing off (formatUntil omits the parenthetical once openUntil has passed or is unset), or "half-open" while probing. */
 function healthBadgeLabel(p: AdminProviderView): string {
   const until = formatUntil(p.openUntil)
   return until ? `${p.healthState} (${until})` : p.healthState
 }
 
-/** healthDetailClass matches the accordion-content detail row's text color to healthBadgeVariant's own trigger-row Badge color, rather than hardcoding text-destructive for every non-closed state: destructive (red) for 'open', muted (grey, the same neutral tone secondary conveys on the Badge) for 'half-open'. */
 function healthDetailClass(state: AdminProviderView['healthState']): string {
   return state === 'open' ? 'text-destructive' : 'text-muted-foreground'
 }
 
-// --- upstream latency (feat: instrument upstream latency) ---
-//
-// Beside the discovery-health badge above: no badge at all for a stream
-// state with no observations yet (p.latency undefined, or missing that
-// key) — mirrors healthBadgeVariant/modelIsDegraded's own "nothing to
-// show reads as no badge" convention, so absent data reads as absent,
-// never as a fabricated zero.
-//
-// The two stream states are deliberately labeled and worded differently,
-// never merged into one figure (task brief's own correctness rule):
-// streaming shows avgTtfbMs, the load-sensitive reading, labeled "ttfb";
-// non-streaming shows avgDurationMs labeled "avg" — NEVER "latency" or
-// "ttfb" — because a non-streaming provider buffers its whole completion
-// before sending anything, so its own avgTtfbMs is approximately equal
-// to avgDurationMs and carries the identical output-length contamination
-// a raw total-duration figure always has (a 4000-token answer legitimately
-// takes longer than a 50-token one on an equally healthy provider).
+// --- per-replica upstream latency (feat: instrument upstream latency) — unchanged from ProvidersView.vue ---
 
-/** streamingLatency/nonStreamingLatency pull p.latency's two known stream-state keys (admin.go's buildAdminLatencyViews emits exactly these two strings) — undefined when that stream state has no observations yet. */
 function streamingLatency(p: AdminProviderView): AdminLatencyView | undefined {
   return p.latency?.streaming
 }
@@ -252,57 +176,27 @@ function nonStreamingLatency(p: AdminProviderView): AdminLatencyView | undefined
   return p.latency?.['non-streaming']
 }
 
-/** latencyObservationCount renders v.count (omitted, per admin.go, when 0) as a singular/plural detail phrase for a badge title, falling back to "no observations counted" for the defensive case of a present view with an absent count (version skew). */
 function latencyObservationCount(v: AdminLatencyView): string {
   if (v.count === undefined) return 'no observations counted'
   return `${v.count} ${v.count === 1 ? 'observation' : 'observations'} on this replica`
 }
 
-/**
- * perReplicaCaveat is appended to every latency/provenance badge's title
- * (task brief's correctness rule 1): this figure comes from the same
- * in-process accumulator the rate-limit rejection counter reads, never
- * Redis, so it reflects only whichever of this deployment's several
- * Traefik replicas answered the current poll — never a fleet-wide
- * average, and a freshly restarted pod shows a short window. F4
- * (dashboard-plan.md) names the CONCRETE replica (admin.go's g.replica,
- * echoed as overview.replica) rather than the abstract warning alone — a
- * reader can now tell not just THAT this figure is replica-scoped, but
- * WHICH replica it came from. Falls back to the generic "this replica"
- * phrasing for a version-skewed server build that has not shipped the
- * field yet (undefined, never a fabricated id).
- */
 function perReplicaCaveat(): string {
   const replica = overview.value?.replica
   const who = replica ? `replica ${replica}` : 'this replica'
   return `Per-replica (${who}), in-process only — not a fleet-wide average across this deployment’s replicas.`
 }
 
-/** streamingLatencyTitle is the streaming ttfb badge's hover/title detail. */
 function streamingLatencyTitle(v: AdminLatencyView): string {
   return `Average time to first byte, the load-sensitive reading for streaming traffic. ${latencyObservationCount(v)}. ${perReplicaCaveat()}`
 }
 
-/** nonStreamingLatencyTitle is the non-streaming avg-duration badge's hover/title detail — explicit that this is NOT a latency/ttfb reading (correctness rule 2). */
 function nonStreamingLatencyTitle(v: AdminLatencyView): string {
   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. ${latencyObservationCount(v)}. ${perReplicaCaveat()}`
 }
 
-// --- usage provenance (feat: expose token-accounting provenance) ---
-//
-// Token accounting has three provenances (see AdminProvenanceView's own
-// doc comment): reported (the healthy default — no badge, mirroring the
-// health/latency badges' own "nothing to show reads as no badge"
-// convention), estimated (a non-streaming response carried no usage, so
-// prompt was substituted from request body size), and unbilled (a
-// streaming response carried no usage, so the request was counted but
-// zero tokens were billed — a provider potentially serving completions
-// entirely free against every budget). estimated/unbilled are two
-// DISTINCT badges, never merged into one "not reported" indicator —
-// collapsing them would hide exactly the fact this feature exists to
-// surface (task brief's own correctness rule).
+// --- usage provenance (feat: expose token-accounting provenance) — unchanged from ProvidersView.vue ---
 
-/** estimatedProvenance/unbilledProvenance pull p.provenance's two known kind keys (admin.go's buildAdminProvenanceViews emits only these two strings, never "reported") — undefined when that kind has no observations yet. */
 function estimatedProvenance(p: AdminProviderView): AdminProvenanceView | undefined {
   return p.provenance?.estimated
 }
@@ -310,34 +204,48 @@ function unbilledProvenance(p: AdminProviderView): AdminProvenanceView | undefin
   return p.provenance?.unbilled
 }
 
-/** estimatedProvenanceTitle is the estimated-accounting badge's hover/title detail. */
 function estimatedProvenanceTitle(v: AdminProvenanceView): string {
   const plural = v.requests === 1 ? '' : 's'
   return `${v.requests} non-streaming response${plural} carried no usage from the provider — prompt tokens were estimated from request body size instead (${v.tokens} tokens billed from the estimate), completion billed as zero. ${perReplicaCaveat()}`
 }
 
-/** unbilledProvenanceTitle is the unbilled-accounting badge's hover/title detail — explicit about the budget-exposure implication (task brief's own framing). */
 function unbilledProvenanceTitle(v: AdminProvenanceView): string {
   const plural = v.requests === 1 ? '' : 's'
   return `${v.requests} streaming response${plural} 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. ${perReplicaCaveat()}`
 }
 
-// --- model aliases (sortable DataTable, operator directive) ---
+// --- fleet-wide performance (NEW: GET /admin/api/performance?kind=provider) ---
 //
-// The alias id gets the ModelChip copy treatment (an alias name IS the
-// routable string a caller sends as `model`); the target column stays
-// plain text.
+// Fleet-wide (Redis-backed via the latency histogram counters, WP-A), UNLIKE
+// every badge above this point in the file — a provider's own p50/p95
+// here is the SAME reading regardless which replica answered the poll,
+// the opposite of the per-replica caveat every latency/provenance badge
+// above carries. timeouts/failovers are always populated (they do not
+// need admin.stats.latency — only the percentile fields do, AdminPerfRow's
+// own doc comment); a provider with zero of either renders no badge at
+// all, mirroring every other "nothing to show" convention in this file.
+
+function providerPerfFor(name: string): AdminPerfRow | undefined {
+  return models.providerPerf.find((r) => r.id === name)
+}
+
+function fleetLatencyTitle(kind: 'p50' | 'p95'): string {
+  const { window, span } = models.perfWindow
+  return `Fleet-wide (every replica combined) ${kind === 'p50' ? 'median' : '95th percentile'} response time, over the last ${span} ${window}${span === 1 ? '' : 's'}.`
+}
+
+function fleetCountTitle(kind: 'timeouts' | 'failovers'): string {
+  const { window, span } = models.perfWindow
+  const noun = kind === 'timeouts' ? 'requests that exceeded the deadline' : "requests failed away from this provider to another candidate"
+  return `${noun}, fleet-wide, over the last ${span} ${window}${span === 1 ? '' : 's'}.`
+}
+
+// --- model aliases (sortable DataTable) — unchanged from ProvidersView.vue ---
 const aliasColumns: ColumnDef<AdminAliasView, unknown>[] = [
   {
     id: 'alias',
     header: 'Alias',
     accessorFn: (a) => a.alias,
-    // Optional-chained (review fix, folded minor) the same way
-    // modelMetaFor guards the provider path below: AdminAliasView.
-    // modelMeta is typed as always-present, but a real response from a
-    // server build older than this field (version skew) would otherwise
-    // throw on `.modelMeta.contextTokens` here instead of just omitting
-    // the hover detail.
     cell: ({ row }) =>
       h(ModelChip, {
         id: row.original.alias,
@@ -425,12 +333,17 @@ const aliasEmptyMessage = computed(() =>
       <CardHeader>
         <CardTitle>Providers</CardTitle>
         <CardDescription>
-          Every configured upstream and its last discovery refresh. Search filters providers and aliases by
-          model id.
+          Every configured upstream, its last discovery refresh, and fleet-wide performance. Search filters providers and
+          aliases by model id.
         </CardDescription>
         <SearchInput v-model="modelQuery" placeholder="Search models or aliases..." class="mt-2 max-w-sm" />
       </CardHeader>
-      <CardContent>
+      <CardContent class="flex flex-col gap-3">
+        <Alert v-if="!models.latencyEnabled" variant="warn">
+          <AlertDescription>
+            Fleet p50/p95 are off for this deployment. Enable <code>admin.stats.latency</code> to see them.
+          </AlertDescription>
+        </Alert>
         <p v-if="!overview?.providers.length" class="py-6 text-center text-sm text-muted-foreground">none</p>
         <p
           v-else-if="hasQuery && filteredProviders.length === 0"
@@ -439,31 +352,15 @@ const aliasEmptyMessage = computed(() =>
           no providers match &quot;{{ modelQuery }}&quot;
         </p>
         <template v-else>
-          <!-- F4 (dashboard-plan.md): latency/provenance badges below are per-replica, in-process figures — this caption names which replica this poll answered from, up front, instead of leaving it to each badge's own hover title. -->
-          <p class="mb-2 text-xs text-muted-foreground">{{ perReplicaCaveat() }}</p>
+          <p class="text-xs text-muted-foreground">{{ perReplicaCaveat() }} Fleet p50/p95/timeouts/failovers below are fleet-wide, not per-replica.</p>
           <Accordion v-model="expandedProviderValues" type="multiple" class="rounded-md border px-3">
           <AccordionItem v-for="p in filteredProviders" :key="p.name" :value="p.name">
-            <!--
-              P2 review fix: the provider-name link moved OUTSIDE
-              AccordionTrigger — see goToProviderModels' own doc comment
-              above for why. `py-2.5` matches AccordionTrigger.vue's own
-              vertical padding so the two line up in this row.
-              `header-class="flex-1"` fills the AccordionHeader (<h3>) that
-              wraps the trigger button, since AccordionTrigger's own
-              `class` prop lands on the inner button, not the header — see
-              AccordionTrigger.vue's doc comment. Without it the header
-              shrinks to content width, so the chevron drifts left of the
-              row's right edge and the empty space to its right stops
-              being clickable. The sr-only span gives the toggle button an
-              accessible name that names the provider, since the visible
-              text beside it is just badges and counts.
-            -->
             <div class="flex items-center gap-2">
               <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 ${p.name}'s models in Charts`"
-                :title="`View ${p.name}'s models in Charts`"
+                :aria-label="`View ${p.name}'s models in the Models table`"
+                :title="`View ${p.name}'s models in the Models table`"
                 @click="goToProviderModels(p.name)"
               >{{ p.name }}</button>
               <AccordionTrigger header-class="flex-1">
@@ -477,12 +374,6 @@ const aliasEmptyMessage = computed(() =>
                   :attempts-minute="p.attemptsMinute"
                   :failures-minute="p.failuresMinute"
                 />
-                <!--
-                  Discovery circuit breaker (feat/provider-health): no
-                  badge at all while 'closed' (the healthy, common case),
-                  mirroring modelIsDegraded's own convention for the
-                  per-model rate badge above.
-                -->
                 <Badge
                   v-if="p.healthState !== 'closed'"
                   as="span"
@@ -492,15 +383,6 @@ const aliasEmptyMessage = computed(() =>
                 >
                   {{ healthBadgeLabel(p) }}
                 </Badge>
-                <!--
-                  Upstream latency (feat: instrument upstream latency):
-                  streaming's ttfb is the load-sensitive figure; the
-                  non-streaming badge deliberately says "avg", never
-                  "ttfb"/"latency" — see nonStreamingLatencyTitle's own
-                  doc comment for why that number is not a load signal.
-                  No badge at all for a stream state with no observations
-                  yet, mirroring the health badge's own convention above.
-                -->
                 <Badge
                   v-if="streamingLatency(p)?.avgTtfbMs !== undefined"
                   as="span"
@@ -519,15 +401,42 @@ const aliasEmptyMessage = computed(() =>
                 >
                   non-streaming avg {{ formatLatencyMs(nonStreamingLatency(p)!.avgDurationMs as number) }}
                 </Badge>
-                <!--
-                  Usage provenance (feat: expose token-accounting
-                  provenance): no badge at all for a kind with no
-                  observations yet, mirroring the health/latency badges'
-                  own convention above. estimated and unbilled are two
-                  distinct badges — never merged (correctness rule, task
-                  brief) — since one substitutes an approximation and the
-                  other bills nothing at all.
-                -->
+                <Badge
+                  v-if="providerPerfFor(p.name)?.p50Ms !== undefined"
+                  as="span"
+                  variant="outline"
+                  class="font-normal tabular-nums"
+                  :title="fleetLatencyTitle('p50')"
+                >
+                  fleet p50 {{ formatLatencyMs(providerPerfFor(p.name)!.p50Ms as number) }}
+                </Badge>
+                <Badge
+                  v-if="providerPerfFor(p.name)?.p95Ms !== undefined"
+                  as="span"
+                  variant="outline"
+                  class="font-normal tabular-nums"
+                  :title="fleetLatencyTitle('p95')"
+                >
+                  fleet p95 {{ formatLatencyMs(providerPerfFor(p.name)!.p95Ms as number) }}
+                </Badge>
+                <Badge
+                  v-if="(providerPerfFor(p.name)?.timeouts ?? 0) > 0"
+                  as="span"
+                  variant="secondary"
+                  class="font-normal tabular-nums"
+                  :title="fleetCountTitle('timeouts')"
+                >
+                  {{ providerPerfFor(p.name)!.timeouts }} timeouts
+                </Badge>
+                <Badge
+                  v-if="(providerPerfFor(p.name)?.failovers ?? 0) > 0"
+                  as="span"
+                  variant="secondary"
+                  class="font-normal tabular-nums"
+                  :title="fleetCountTitle('failovers')"
+                >
+                  {{ providerPerfFor(p.name)!.failovers }} failovers
+                </Badge>
                 <Badge
                   v-if="estimatedProvenance(p)"
                   as="span"
@@ -583,17 +492,7 @@ const aliasEmptyMessage = computed(() =>
                     :input-per-m-tok-usd="modelMetaFor(p, m).inputPerMTokUsd"
                     :output-per-m-tok-usd="modelMetaFor(p, m).outputPerMTokUsd"
                   />
-                  <!-- ScopeLink (F6): jumps to Charts, scoped to this exact model — renders here as a real <button> inside AccordionContent (not AccordionTrigger), same as the provider-name button above (P2 review fix moved both out of the trigger). -->
-
-                  <ScopeLink :label="routableModelId(p.name, m)" :scope="`model:${routableModelId(p.name, m)}`" />
-                  <!--
-                    Context chip, visible, muted (feature v0.23) — only
-                    when known. Cost stays hover-only on ModelChip itself
-                    (operator directive: chips + hover would otherwise
-                    show the identical price figures twice; context
-                    visible for scanning, price on hover for the exact
-                    numbers).
-                  -->
+                  <EntityLink :label="routableModelId(p.name, m)" kind="model" :id="routableModelId(p.name, m)" />
                   <span
                     v-if="modelMetaFor(p, m).contextTokens !== undefined"
                     title="context window"
@@ -601,14 +500,6 @@ const aliasEmptyMessage = computed(() =>
                   >
                     {{ formatContextWindow(modelMetaFor(p, m).contextTokens as number) }}
                   </span>
-                  <!--
-                    attempts-minute/failures-minute deliberately omitted
-                    (SHOULD-2, v0.22 review round): AdminModelRateView no
-                    longer carries them at all, so leaving them unbound
-                    (undefined) is what tells ProviderRateBadge to render
-                    its day-window-only detail (dayRateTitle) instead of
-                    claiming a live minute-window reading no data backs.
-                  -->
                   <ProviderRateBadge
                     v-if="modelIsDegraded(p, m)"
                     :attempts-day="modelRateFor(p, m).attemptsDay"
diff --git a/webui/src/components/ProviderRateBadge.vue b/webui/src/components/ProviderRateBadge.vue
index 5bdeb7e..21ac4d3 100644
--- a/webui/src/components/ProviderRateBadge.vue
+++ b/webui/src/components/ProviderRateBadge.vue
@@ -5,10 +5,10 @@ import { Badge } from '@/components/ui/badge'
 import { dayRateTitle, formatRatePercent, minuteRateTitle, providerRateStatus, providerSuccessRate } from '@/lib/provider-rate'
 
 /**
- * ProviderRateBadge is the Providers tab's success-rate badge (Feature A,
- * v0.22) — reused for both a provider's own row (ProvidersView.vue's
+ * ProviderRateBadge is the Models page's success-rate badge (Feature A,
+ * v0.22) — reused for both a provider's own row (ProviderHealthPanel.vue's
  * accordion trigger, always shown) and a single degraded model beside its
- * ModelChip (ProvidersView.vue's accordion content, shown only when
+ * ModelChip (ProviderHealthPanel.vue's accordion content, shown only when
  * isModelDegraded). attemptsMinute/failuresMinute are OPTIONAL (SHOULD-2,
  * v0.22 review round): the provider-row call site passes them (admin.go's
  * adminProviderView carries minute counters); the per-model call site
@@ -56,11 +56,11 @@ const detail = computed(() =>
 
 // Badge has no dedicated "amber"/"muted" variant (ui/badge/index.ts) —
 // severe reuses the built-in `destructive` variant exactly like every
-// other error state in this panel (e.g. ProvidersView's own lastErr
-// icon); healthy/no-traffic reuse `secondary`/`outline`, the panel's
-// existing "quiet" idioms (ProvidersView's provider-type badge is
-// `variant="secondary"`); degraded borrows the semantic --status-warn
-// token (main.css — MUST-1, v0.22 review round: --chart-tokens-out, this
+// other error state in this panel (e.g. ProviderHealthPanel.vue's own
+// lastErr icon); healthy/no-traffic reuse `secondary`/`outline`, the
+// panel's existing "quiet" idioms (ProviderHealthPanel.vue's
+// provider-type badge is `variant="secondary"`); degraded borrows the
+// semantic --status-warn token (main.css — MUST-1, v0.22 review round: --chart-tokens-out, this
 // component's original choice, measures ~2.22:1 against --card in light
 // mode, a WCAG 1.4.3 text-contrast failure on exactly the "something's
 // wrong" tier; --status-warn is tuned for body-text contrast instead,
diff --git a/webui/src/components/ScopeLink.vue b/webui/src/components/ScopeLink.vue
deleted file mode 100644
index 2f8904b..0000000
--- a/webui/src/components/ScopeLink.vue
+++ /dev/null
@@ -1,69 +0,0 @@
-<script setup lang="ts">
-import { faChartLine } from '@fortawesome/free-solid-svg-icons'
-
-import { useNavStore } from '@/stores/nav'
-
-/**
- * ScopeLink (F6) is the one "jump to this scope's Charts view" control in
- * this panel: usage-columns.ts's id cell (Users/Groups tables and the
- * nested Members table), UsageView.vue's Groups accordion header, and
- * WP-B2's ProvidersView.vue per-model chips all render one of these
- * instead of each hand-rolling their own click-through-to-Charts wiring.
- *
- * A real `<button type="button">` (P2 review fix). This used to be a
- * `<span role="link" tabindex="0">`, justified at the time by the Groups
- * accordion trigger use site nesting it INSIDE shadcn-vue's
- * AccordionTrigger — itself a real `<button>` (reka-ui's own
- * AccordionTrigger primitive). That justification was wrong on its own
- * terms: the HTML button content model forbids ANY descendant carrying a
- * `tabindex` attribute, not just a nested button/anchor, and ARIA's
- * `button` role additionally declares "children presentational: true", so
- * assistive technology flattened the inner span and never exposed it as
- * its own link at all — axe flags this as `nested-interactive`. Reka's
- * AccordionTrigger also only listens for `click` (not `keydown`), so
- * `stopPropagation()` on click and Enter suppressed the accordion's own
- * toggle, but Space on the focused span did nothing and fell through to
- * page scroll instead of activating anything.
- *
- * The actual fix is structural, not a markup trick: every call site now
- * renders this component as a SIBLING of whatever it used to nest inside
- * (UsageView.vue's Groups header, ProvidersView.vue's provider-name
- * header — see both templates), never a descendant of another interactive
- * element, so a real `<button>` is valid there. No `role` override: a
- * plain button's implicit role is already correct here (activating it
- * performs an action — a programmatic Pinia-store navigation, not a
- * traditional `href` follow — which is exactly what a native `<button>`,
- * not `<a>`, is for; WAI-ARIA's first rule of ARIA use is not to override
- * a native element's semantics without a reason, and there is none left
- * here). `stopPropagation` on click stays — harmless everywhere (a table
- * cell, ProvidersView's per-model chips) and still correct defensively at
- * the Groups/Providers headers, where this button sits next to, not
- * inside, the accordion's own trigger.
- */
-const props = defineProps<{
-  /** The visible + accessible label, e.g. a user id, group id, or model id. */
-  label: string
-  /** The scope string useNavStore.goToCharts expects — "total" | "user:{id}" | "group:{id}" | "model:{id}" (history.ts's own convention). */
-  scope: string
-}>()
-
-const nav = useNavStore()
-
-function onClick(event: MouseEvent): void {
-  event.stopPropagation()
-  nav.goToCharts(props.scope)
-}
-</script>
-
-<template>
-  <button
-    type="button"
-    :aria-label="`View ${label} in Charts`"
-    :title="`View ${label} in Charts`"
-    class="inline-flex cursor-pointer items-center gap-1 rounded-sm text-inherit hover:text-primary hover:underline focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring/50"
-    @click="onClick"
-  >
-    <span>{{ label }}</span>
-    <FontAwesomeIcon :icon="faChartLine" class="size-3" aria-hidden="true" />
-  </button>
-</template>
diff --git a/webui/src/components/SearchInput.vue b/webui/src/components/SearchInput.vue
index 1e25fd8..3d3ce2f 100644
--- a/webui/src/components/SearchInput.vue
+++ b/webui/src/components/SearchInput.vue
@@ -9,11 +9,13 @@ import { cn } from '@/lib/utils'
 
 /**
  * SearchInput is the one search-box control every filter in this panel
- * uses — ProvidersView's model search, UsageView's user/group search, and
- * ChartsView's scope-picker search each grew an identical ~22-line
- * magnifying-glass-icon + Input + clear-button block; extracted into one
- * component (vue.md: "if you've written it twice, you owe an
- * abstraction"). A controlled component (modelValue/update:modelValue),
+ * uses (today: ProviderHealthPanel's model search, ConsumerDirectory's
+ * user/group search, TargetsView's target search, EventsView's user
+ * filter, ModelCatalogTable's model search) — each pre-redesign call site
+ * grew an identical ~22-line magnifying-glass-icon + Input + clear-button
+ * block on its own; extracted into one component (vue.md: "if you've
+ * written it twice, you owe an abstraction"). A controlled component
+ * (modelValue/update:modelValue),
  * not v-model'd internally, since the incoming modelValue is a prop —
  * callers pair it with `useSearchQuery()` (composables/useSearchQuery.ts)
  * for the query/normalized/hasQuery/clear state, or v-model it against any
diff --git a/webui/src/components/SidebarNav.vue b/webui/src/components/SidebarNav.vue
new file mode 100644
index 0000000..6f9a8a3
--- /dev/null
+++ b/webui/src/components/SidebarNav.vue
@@ -0,0 +1,40 @@
+<script setup lang="ts">
+import { PAGE_NAV } from '@/lib/pages'
+import { useNavStore } from '@/stores/nav'
+
+/**
+ * SidebarNav (redesign-plan.md section 3.1) is the shell's primary
+ * navigation: a vertical list of pages on a normal-width viewport,
+ * collapsing to a horizontally-scrollable bar on a narrow one (the
+ * `md:` breakpoint below) rather than a hamburger/drawer — every page is
+ * still one tap away, and the panel is an internal admin tool with no
+ * phone-first audience to justify hiding the list behind an extra tap.
+ *
+ * Real `<button>` elements, not `<a href>` (mirrors EntityLink.vue's own
+ * structural note): activating one is a programmatic Pinia navigation
+ * (nav.goTo), not a traditional link follow, and there is no separate
+ * URL to navigate to server-side — the hash is derived FROM this state
+ * (composables/useHashState.ts), not the other way around.
+ */
+const nav = useNavStore()
+</script>
+
+<template>
+  <nav
+    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"
+  >
+    <button
+      v-for="entry in PAGE_NAV"
+      :key="entry.id"
+      type="button"
+      :aria-current="nav.page === entry.id ? 'page' : undefined"
+      class="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"
+      :class="nav.page === entry.id ? 'bg-accent text-accent-foreground' : 'text-muted-foreground hover:bg-muted hover:text-foreground'"
+      @click="nav.goTo(entry.id)"
+    >
+      <FontAwesomeIcon :icon="entry.icon" class="size-4" aria-hidden="true" />
+      <span>{{ entry.label }}</span>
+    </button>
+  </nav>
+</template>
diff --git a/webui/src/components/SnippetBlock.vue b/webui/src/components/SnippetBlock.vue
new file mode 100644
index 0000000..7a075cd
--- /dev/null
+++ b/webui/src/components/SnippetBlock.vue
@@ -0,0 +1,60 @@
+<script setup lang="ts">
+import { faCheck, faCopy, faTriangleExclamation } from '@fortawesome/free-solid-svg-icons'
+import { onUnmounted, ref, useTemplateRef } from 'vue'
+
+import { Button } from '@/components/ui/button'
+import { copyText } from '@/lib/clipboard'
+
+/**
+ * SnippetBlock (redesign-plan.md section 3.4) is the one "here is text to
+ * paste into a file" surface every ChangeHelper form and ConfigTree.vue
+ * share — a `<pre>` plus a copy button (lib/clipboard.ts's copyText, same
+ * Clipboard-API-with-selection-fallback convention CsvExportButton.vue's
+ * download path and ModelChip.vue's own click-to-copy already use).
+ */
+const props = defineProps<{
+  /** The exact text to display and copy — YAML (lib/snippets.ts) or a single-line JSON fragment, verbatim, never re-formatted by this component. */
+  text: string
+  /** A short caption above the block, e.g. "Paste into middleware.yaml" or "Add to the user's users.json line". */
+  label?: string
+}>()
+
+const preRef = useTemplateRef<HTMLElement>('pre')
+const state = ref<'idle' | 'copied' | 'selected' | 'failed'>('idle')
+let resetTimer: ReturnType<typeof setTimeout> | undefined
+
+async function onCopy(): Promise<void> {
+  state.value = await copyText(props.text, preRef.value ?? undefined)
+  clearTimeout(resetTimer)
+  resetTimer = setTimeout(() => {
+    state.value = 'idle'
+  }, 1500)
+}
+
+const BUTTON_LABEL: Record<typeof state.value, string> = {
+  idle: 'Copy',
+  copied: 'Copied',
+  selected: 'Selected — press ⌘/Ctrl+C',
+  failed: 'Copy failed',
+}
+
+onUnmounted(() => clearTimeout(resetTimer))
+</script>
+
+<template>
+  <div class="flex flex-col gap-1.5">
+    <div class="flex items-center justify-between gap-2">
+      <span v-if="label" class="text-xs font-medium text-muted-foreground">{{ label }}</span>
+      <Button type="button" variant="outline" size="sm" class="ml-auto" @click="onCopy">
+        <FontAwesomeIcon
+          :icon="state === 'idle' ? faCopy : state === 'failed' ? faTriangleExclamation : faCheck"
+          class="size-3.5"
+          :class="state === 'failed' ? 'text-destructive' : undefined"
+          aria-hidden="true"
+        />
+        {{ BUTTON_LABEL[state] }}
+      </Button>
+    </div>
+    <pre ref="pre" class="overflow-x-auto rounded-md border bg-muted p-3 font-mono text-xs select-text whitespace-pre">{{ text }}</pre>
+  </div>
+</template>
diff --git a/webui/src/components/SortHeaderButton.vue b/webui/src/components/SortHeaderButton.vue
index c20408f..50b7f0c 100644
--- a/webui/src/components/SortHeaderButton.vue
+++ b/webui/src/components/SortHeaderButton.vue
@@ -7,8 +7,9 @@ import { computed } from 'vue'
 /**
  * SortHeaderButton is the one clickable, sortable-column control every
  * sortable header in the panel uses — DataTable.vue's real `<th>` header
- * buttons AND UsageView.vue's Groups sort toolbar (which has no `<table>`
- * to put a `<th>` in — see that view's own doc comment for why).
+ * buttons AND ConsumerDirectory.vue's Groups sort toolbar (which has no
+ * `<table>` to put a `<th>` in — see that component's own "Groups
+ * accordion" doc comment for why).
  * Extracted so the button markup, sort-icon logic, click handler, and
  * accessible name exist in exactly one place (vue.md: "if you've written
  * it twice, you owe an abstraction"). Extra classes on this component
diff --git a/webui/src/components/TargetCallers.vue b/webui/src/components/TargetCallers.vue
new file mode 100644
index 0000000..33c120f
--- /dev/null
+++ b/webui/src/components/TargetCallers.vue
@@ -0,0 +1,103 @@
+<script setup lang="ts">
+import { computed, ref, watch } from 'vue'
+
+import ClampedRangeNotice from '@/components/ClampedRangeNotice.vue'
+import DataTable from '@/components/DataTable.vue'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { adminFetch } from '@/lib/api'
+import { dayOrMonthWindow, totalsUrl } from '@/lib/range'
+import { targetCallerColumns } from '@/lib/target-columns'
+import { useFiltersStore } from '@/stores/filters'
+import type { AdminTotalsResponse } from '@/types/api'
+
+/**
+ * TargetCallers (redesign-plan.md section 3.4, MCP & Agents page) reads
+ * GET /admin/api/usage/totals?kind=targetcaller — per-caller request
+ * counts, ranked descending, dropped to zero rows server-side. Used in two
+ * modes from TargetsPage.vue, sharing this one component (vue.md: "if
+ * you've written it twice, you owe an abstraction") rather than a
+ * near-duplicate for each:
+ *
+ * - Per-target ("TargetCallers.vue expander"): `target` is set to the
+ *   composed "mcp/{name}"/"agent/{name}" id (lib/target-columns.ts's
+ *   composeTargetId) of whichever row the reader clicked in TargetsView.vue
+ *   — shows only that target's own callers, no Target column (the panel's
+ *   own heading already names it).
+ * - Fleet-wide ("top callers" card): `target` omitted — every configured
+ *   target's callers, ranked together, WITH a Target column so a caller
+ *   who reaches more than one target is not ambiguous.
+ *
+ * `kind=targetcaller` only supports day/month windows (redesign-plan.md
+ * section 1.3.v) — lib/range.ts's dayOrMonthWindow clamps the global
+ * filters store's current (possibly hour-window) range down to a window
+ * this endpoint actually accepts, rather than firing an invalid request
+ * whenever the reader has an hour-resolution range (24h/48h) selected.
+ */
+const props = withDefaults(
+  defineProps<{
+    /** Composed "mcp/{name}" / "agent/{name}" id — omitted means fleet-wide, every target. */
+    target?: string
+    title: string
+    limit?: number
+  }>(),
+  { limit: 10 },
+)
+
+const filters = useFiltersStore()
+
+const rows = ref<AdminTotalsResponse['rows']>([])
+const loading = ref(false)
+const loaded = ref(false)
+const error = ref('')
+/** reqId guards against an out-of-order response overwriting a newer one (latest-request-wins, stores/catalog.ts's own convention) — a quick target switch, or a range change mid-flight, no longer risks showing a STALE target's callers under the new heading. */
+let reqId = 0
+
+async function load(): Promise<void> {
+  const requestId = ++reqId
+  loading.value = true
+  try {
+    const { window, span } = dayOrMonthWindow(filters.window, filters.span)
+    const res = await adminFetch<AdminTotalsResponse>(
+      totalsUrl({ kind: 'targetcaller', window, span, metrics: ['req'], limit: props.limit, target: props.target }),
+    )
+    if (requestId !== reqId) return
+    rows.value = res.rows
+    error.value = ''
+  } catch (err) {
+    if (requestId !== reqId) return
+    error.value = err instanceof Error ? err.message : String(err)
+  } finally {
+    if (requestId === reqId) {
+      loading.value = false
+      loaded.value = true
+    }
+  }
+}
+
+watch(
+  [() => props.target, () => filters.window, () => filters.span],
+  () => void load(),
+  { immediate: true },
+)
+
+const columns = computed(() => targetCallerColumns(!props.target))
+
+const emptyMessage = computed(() => {
+  if (!loaded.value) return 'loading…'
+  return 'no callers recorded in this window'
+})
+</script>
+
+<template>
+  <Card>
+    <CardHeader>
+      <CardTitle>{{ title }}</CardTitle>
+      <CardDescription>Ranked by requests, most recent day/month window available for the current range.</CardDescription>
+    </CardHeader>
+    <CardContent class="flex flex-col gap-3">
+      <ClampedRangeNotice :window="filters.window" :span="filters.span" />
+      <p v-if="error" class="text-sm text-destructive">{{ error }}</p>
+      <DataTable :columns="columns" :data="rows" :empty-message="emptyMessage" />
+    </CardContent>
+  </Card>
+</template>
diff --git a/webui/src/components/TargetsView.vue b/webui/src/components/TargetsView.vue
index 154d12c..7ccf2eb 100644
--- a/webui/src/components/TargetsView.vue
+++ b/webui/src/components/TargetsView.vue
@@ -5,20 +5,38 @@ import DataTable from '@/components/DataTable.vue'
 import SearchInput from '@/components/SearchInput.vue'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
 import { useSearchQuery } from '@/composables/useSearchQuery'
-import { targetColumns } from '@/lib/target-columns'
+import { composeTargetId, targetColumns } from '@/lib/target-columns'
+import type { TargetKind } from '@/lib/target-columns'
 import { useDashboardStore } from '@/stores/dashboard'
 import type { AdminTargetView } from '@/types/api'
 
-// This component backs the "MCP & Agents" tab (App.vue) — GET
-// /admin/api/targets (admin.go: adminTargetsResponse, Feature B v0.21).
+// This component backs the "MCP & Agents" page (redesign-plan.md section
+// 3.4, TargetsPage.vue) — GET /admin/api/targets (admin.go:
+// adminTargetsResponse, Feature B v0.21).
 const dashboard = useDashboardStore()
 const targets = computed(() => dashboard.targets)
 
+/**
+ * select (redesign-plan.md section 3.4's "TargetCallers.vue expander")
+ * fires with the composed "mcp/{name}"/"agent/{name}" id and the target's
+ * own display name — TargetsPage.vue listens and renders TargetCallers.vue
+ * for whichever target the reader last clicked. Two separate
+ * targetColumns() instantiations below (MCP servers, Agents) close over
+ * their own fixed `kind` so a click always composes the correct prefix,
+ * without this component needing to carry a per-row kind field itself.
+ */
+const emit = defineEmits<{ select: [id: string, label: string] }>()
+
+function onSelect(kind: TargetKind): (t: AdminTargetView) => void {
+  return (t) => emit('select', composeTargetId(kind, t.name), t.name)
+}
+
 // Simple, single-field substring match on name — no separate lib/*-search
-// module: ProvidersView.vue's own aliasMatches/providerMatches stay inline
-// for the identical reason (one field, one comparison), reserving the
-// extracted-and-tested lib/usage-search.ts treatment for UsageView.vue's
-// genuinely multi-entity (user-or-group-member) matching semantics.
+// module: ProviderHealthPanel.vue's own aliasMatches/providerMatches stay
+// inline for the identical reason (one field, one comparison), reserving
+// the extracted-and-tested lib/usage-search.ts treatment for
+// ConsumerDirectory.vue's genuinely multi-entity (user-or-group-member)
+// matching semantics.
 const { query, normalized: normalizedQuery, hasQuery } = useSearchQuery()
 
 function nameMatches(t: AdminTargetView): boolean {
@@ -34,7 +52,7 @@ const filteredAgents = computed<AdminTargetView[]>(() => {
   return hasQuery.value ? all.filter(nameMatches) : all
 })
 
-/** emptyMessage mirrors UsageView.vue's groupsEmptyMessage/usersEmptyMessage three-way pattern: distinguishes nothing configured from nothing matching the active query. */
+/** emptyMessage mirrors ConsumerDirectory.vue's groupsEmptyMessage/usersEmptyMessage three-way pattern: distinguishes nothing configured from nothing matching the active query. */
 function emptyMessage(configuredCount: number, filteredCount: number): string {
   if (!configuredCount) return 'none configured'
   if (hasQuery.value && filteredCount === 0) return `no targets match "${query.value}"`
@@ -44,10 +62,13 @@ function emptyMessage(configuredCount: number, filteredCount: number): string {
 const mcpEmptyMessage = computed(() => emptyMessage(targets.value?.mcpServers.length ?? 0, filteredMCPServers.value.length))
 const agentsEmptyMessage = computed(() => emptyMessage(targets.value?.agents.length ?? 0, filteredAgents.value.length))
 
-// One shared column-def set (lib/target-columns.ts) for both tables below —
-// stateless ColumnDef objects, safe to reuse across DataTable's two
-// separate useVueTable instances (each owns its own sorting state).
-const columns = targetColumns()
+// Two separate column-def sets (lib/target-columns.ts) — MCP servers and
+// Agents each close over their own fixed `kind` (see onSelect above) so a
+// name click composes the right "mcp/…"/"agent/…" id. Stateless ColumnDef
+// objects otherwise, safe to reuse across DataTable's two separate
+// useVueTable instances (each owns its own sorting state).
+const mcpColumns = targetColumns(onSelect('mcp'))
+const agentColumns = targetColumns(onSelect('agent'))
 </script>
 
 <template>
@@ -57,20 +78,26 @@ const columns = targetColumns()
     <Card>
       <CardHeader>
         <CardTitle>MCP servers</CardTitle>
-        <CardDescription>Configured MCP proxy targets, the groups allowed to reach them, and their request counters.</CardDescription>
+        <CardDescription>
+          Configured MCP proxy targets, the groups allowed to reach them, and their request counters. Click a name to see its
+          callers.
+        </CardDescription>
       </CardHeader>
       <CardContent>
-        <DataTable :columns="columns" :data="filteredMCPServers" :empty-message="mcpEmptyMessage" />
+        <DataTable :columns="mcpColumns" :data="filteredMCPServers" :empty-message="mcpEmptyMessage" />
       </CardContent>
     </Card>
 
     <Card>
       <CardHeader>
         <CardTitle>Agents</CardTitle>
-        <CardDescription>Configured A2A agent proxy targets, the groups allowed to reach them, and their request counters.</CardDescription>
+        <CardDescription>
+          Configured A2A agent proxy targets, the groups allowed to reach them, and their request counters. Click a name to
+          see its callers.
+        </CardDescription>
       </CardHeader>
       <CardContent>
-        <DataTable :columns="columns" :data="filteredAgents" :empty-message="agentsEmptyMessage" />
+        <DataTable :columns="agentColumns" :data="filteredAgents" :empty-message="agentsEmptyMessage" />
       </CardContent>
     </Card>
   </div>
diff --git a/webui/src/components/TimeSeriesChart.vue b/webui/src/components/TimeSeriesChart.vue
new file mode 100644
index 0000000..5fa1026
--- /dev/null
+++ b/webui/src/components/TimeSeriesChart.vue
@@ -0,0 +1,183 @@
+<script setup lang="ts">
+import type { ChartData, ChartOptions } from 'chart.js'
+import { computed, useId } from 'vue'
+import { Line } from 'vue-chartjs'
+
+import '@/lib/chart-setup'
+import { useThemeColors } from '@/composables/useThemeColors'
+import { formatExactInt } from '@/lib/format'
+
+/** One line-chart series: a label, its values (index-aligned with the `labels` prop below), and which main.css --chart-* token colors it. */
+export interface TimeSeriesDataset {
+  label: string
+  data: number[]
+  /** A main.css --chart-* custom property name (e.g. '--chart-requests') — resolved live via getComputedStyle (this component's own resolveToken, below), so a chart already on screen repaints on a `prefers-color-scheme` flip. */
+  color: string
+}
+
+/**
+ * TimeSeriesComparisonDataset is one `comparisonDatasets` entry — a plain
+ * TimeSeriesDataset plus an OPT-IN `labelSuffix`, appended to `label`
+ * verbatim (undefined/empty appends nothing). Callers decide per dataset,
+ * not this component for all of them: SpendPage.vue's own "vs previous
+ * period" comparison sets `labelSuffix: ' (previous period)'` (Q5), while
+ * BurnDownChart.vue's flat budget reference line — also rendered through
+ * this same `comparisonDatasets` prop, since a budget ceiling is exactly
+ * the "reference overlay, not a component of the current total" this prop
+ * already means — sets none, so its line reads plain "Budget", never the
+ * misleading "Budget (previous period)" (P2 item 5: a fixed
+ * budget line is not a previous-period ANYTHING).
+ */
+export interface TimeSeriesComparisonDataset extends TimeSeriesDataset {
+  labelSuffix?: string
+}
+
+/**
+ * TimeSeriesChart (redesign-plan.md section 3.4) is the redesign's shared
+ * line-chart primitive — Spend's cost breakdown (stacked), Reliability's
+ * per-provider error rate (overlaid, not stacked), and any other
+ * multi-series-over-time view build on this ONE component rather than
+ * each growing its own vue-chartjs wiring. It is the only chart component
+ * in this panel — lib/chart-setup.ts registers exactly the Line/Filler
+ * pieces it uses, nothing more.
+ *
+ * `comparisonDatasets` (Q5/section 3.1 "vs previous period", and
+ * BurnDownChart.vue's budget reference line) renders as a SEPARATE set of
+ * dashed lines, one per entry, matched to its solid counterpart by array
+ * index and color — never stacked, never filled, regardless of `stacked`,
+ * since a comparison line is a reference overlay, not a component of the
+ * current total.
+ */
+const props = withDefaults(
+  defineProps<{
+    labels: string[]
+    datasets: TimeSeriesDataset[]
+    /** A reference/overlay series, one dashed line per entry — omitted/empty draws no comparison. Each entry's own `labelSuffix` (TimeSeriesComparisonDataset) decides whether its label reads "vs previous period" or plain. */
+    comparisonDatasets?: TimeSeriesComparisonDataset[]
+    /** Stack every dataset into one filled total (Spend's cost breakdown) instead of overlaying them as independent lines (Reliability's per-provider error rate). */
+    stacked?: boolean
+    /** Formats a raw value for the tooltip and y-axis ticks — defaults to formatExactInt (lib/format.ts). Cost callers pass formatCost, a ratio series a percent formatter, and so on. */
+    valueFormatter?: (value: number) => string
+    /**
+     * ariaLabel is this chart's accessible name (P3 item 16) — a bare
+     * `<canvas>` has no text alternative at all for a screen reader, so
+     * every call site supplies a short description of what the chart
+     * shows (e.g. "Spend by model over time"). Required, not optional:
+     * there is no safe generic default that would be meaningful across
+     * this component's very different callers (Spend's breakdown,
+     * BurnDownChart's burn-down, Reliability's five series charts,
+     * UserDetail's two per-user charts).
+     */
+    ariaLabel: string
+  }>(),
+  {
+    comparisonDatasets: () => [],
+    stacked: false,
+    valueFormatter: formatExactInt,
+  },
+)
+
+const descId = `timeseries-chart-desc-${useId()}`
+
+/**
+ * srSummary is the sr-only fallback's own text content (P3 item 16's fix
+ * instruction: "an sr-only summary (latest value, total)") — one short
+ * sentence per dataset, latest bucket's value and the sum across the
+ * whole range, run through the SAME valueFormatter the visible tooltip/
+ * axis use, so a screen reader hears figures in the identical units a
+ * sighted reader sees. Comparison datasets are left out: they are a
+ * reference overlay of the SAME primary series shifted back a period,
+ * not new information this summary needs to repeat.
+ */
+const srSummary = computed<string>(() => {
+  if (props.datasets.length === 0 || props.labels.length === 0) return 'No data for this range.'
+  return props.datasets
+    .map((d) => {
+      const latest = d.data.length > 0 ? d.data[d.data.length - 1] : 0
+      const total = d.data.reduce((sum, v) => sum + v, 0)
+      return `${d.label}: latest ${props.valueFormatter(latest)}, total ${props.valueFormatter(total)} over ${props.labels.length} buckets.`
+    })
+    .join(' ')
+})
+
+const { foreground, mutedForeground, border } = useThemeColors()
+
+/** resolveToken reads one of main.css's --chart-* custom properties from :root, live — see this component's own doc comment on `color` above. */
+function resolveToken(cssVar: string): string {
+  return getComputedStyle(document.documentElement).getPropertyValue(cssVar).trim()
+}
+
+const chartData = computed<ChartData<'line'>>(() => {
+  // Touch the theme ref so this computed re-runs (and re-reads the CSS
+  // custom properties via resolveToken) on a `prefers-color-scheme` flip.
+  void foreground.value
+  const solid = props.datasets.map((d) => {
+    const color = resolveToken(d.color)
+    return {
+      label: d.label,
+      data: d.data,
+      borderColor: color,
+      backgroundColor: color,
+      fill: props.stacked,
+      stack: props.stacked ? 'main' : undefined,
+      tension: 0.2,
+      pointRadius: 2,
+      borderWidth: 2,
+    }
+  })
+  const comparison = props.comparisonDatasets.map((d) => {
+    const color = resolveToken(d.color)
+    return {
+      label: `${d.label}${d.labelSuffix ?? ''}`,
+      data: d.data,
+      borderColor: color,
+      backgroundColor: 'transparent',
+      borderDash: [6, 4],
+      fill: false,
+      tension: 0.2,
+      pointRadius: 0,
+      borderWidth: 1.5,
+    }
+  })
+  return { labels: props.labels, datasets: [...solid, ...comparison] }
+})
+
+const chartOptions = computed<ChartOptions<'line'>>(() => ({
+  responsive: true,
+  maintainAspectRatio: false,
+  animation: false,
+  interaction: { mode: 'index', intersect: false },
+  scales: {
+    x: {
+      stacked: props.stacked,
+      grid: { color: border.value, display: false },
+      ticks: { color: mutedForeground.value },
+    },
+    y: {
+      // Zero-based, honest axis (dataviz rule) — never a truncated y-scale that would exaggerate a small change.
+      stacked: props.stacked,
+      beginAtZero: true,
+      grid: { color: border.value },
+      ticks: { color: mutedForeground.value, callback: (value) => props.valueFormatter(Number(value)) },
+    },
+  },
+  plugins: {
+    legend: {
+      display: props.datasets.length > 1 || props.comparisonDatasets.length > 0,
+      labels: { color: foreground.value },
+    },
+    tooltip: {
+      callbacks: {
+        label: (ctx) => `${ctx.dataset.label}: ${props.valueFormatter(ctx.parsed.y ?? 0)}`,
+      },
+    },
+  },
+}))
+</script>
+
+<template>
+  <div class="h-72 w-full" role="img" :aria-label="ariaLabel" :aria-describedby="descId">
+    <Line :data="chartData" :options="chartOptions" />
+    <p :id="descId" class="sr-only">{{ srSummary }}</p>
+  </div>
+</template>
diff --git a/webui/src/components/TopList.vue b/webui/src/components/TopList.vue
new file mode 100644
index 0000000..1f0f248
--- /dev/null
+++ b/webui/src/components/TopList.vue
@@ -0,0 +1,50 @@
+<script setup lang="ts">
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
+import EntityLink from '@/components/EntityLink.vue'
+
+/** One TopList.vue row — an entity id/label, its formatted value, and which EntityLink.vue target it opens. */
+export interface TopListItem {
+  /** The raw entity id EntityLink.vue navigates on (a user id or a canonical model id). */
+  id: string
+  /** The visible label — usually the same as `id`, but callers may pass a friendlier form. */
+  label: string
+  /** Already-formatted display value (lib/format.ts) — this component renders it verbatim, never reformats. */
+  value: string
+  kind: 'user' | 'model'
+}
+
+/**
+ * TopList (redesign-plan.md section 3.4) is the Home page's ranked-list
+ * card: "top 5 users by cost", "top 5 models". Each row is an EntityLink
+ * so clicking a user opens Consumers pre-filtered to them, a model opens
+ * Models — the SAME "jump to detail" affordance every table's id column
+ * (usage-columns.ts, model-table-columns.ts) offers, reused here rather
+ * than a plain unlinked list.
+ */
+defineProps<{
+  title: string
+  items: TopListItem[]
+  /** Shown in place of the list when `items` is empty — e.g. "no traffic in this range yet". */
+  emptyText: string
+}>()
+</script>
+
+<template>
+  <Card>
+    <CardHeader>
+      <CardTitle>{{ title }}</CardTitle>
+    </CardHeader>
+    <CardContent>
+      <p v-if="items.length === 0" class="text-sm text-muted-foreground">{{ emptyText }}</p>
+      <ol v-else class="flex flex-col gap-1.5">
+        <li v-for="(item, i) in items" :key="item.id" class="flex items-center justify-between gap-3 text-sm">
+          <span class="flex min-w-0 items-center gap-2">
+            <span class="w-4 shrink-0 text-right text-xs text-muted-foreground">{{ i + 1 }}</span>
+            <EntityLink :label="item.label" :kind="item.kind" :id="item.id" class="min-w-0 truncate" />
+          </span>
+          <span class="shrink-0 font-medium tabular-nums">{{ item.value }}</span>
+        </li>
+      </ol>
+    </CardContent>
+  </Card>
+</template>
diff --git a/webui/src/components/UsageBar.vue b/webui/src/components/UsageBar.vue
index 01bea21..3082aa4 100644
--- a/webui/src/components/UsageBar.vue
+++ b/webui/src/components/UsageBar.vue
@@ -15,12 +15,13 @@ import { ratioTier } from '@/lib/usage-bars'
  * `aria-valuetext`, so a screen reader announces the same number a
  * sighted reader sees in the fill width and the `title` tooltip.
  *
- * Used two places (usage-columns.ts's numeric cells, UsageView.vue's
- * group detail grid) — both pass a fully-computed BudgetRatio plus the
- * caller's own human-readable `valueText`, so this component has no
- * formatting opinion of its own (formatCost/formatExactInt stay the
- * caller's job, same "logic lives in lib/, not the component" split
- * every other shared component in this panel follows).
+ * Used across the panel (usage-columns.ts's numeric cells,
+ * ConsumerDirectory.vue's group detail grid, UserDetail.vue's headroom
+ * bars) — every caller passes a fully-computed BudgetRatio plus its own
+ * human-readable `valueText`, so this component has no formatting
+ * opinion of its own (formatCost/formatExactInt stay the caller's job,
+ * same "logic lives in lib/, not the component" split every other
+ * shared component in this panel follows).
  */
 const props = defineProps<{
   /** used / limit — may exceed 1 (a scope's usage window can roll past its limit before the next request is rejected). */
diff --git a/webui/src/components/UsageChart.vue b/webui/src/components/UsageChart.vue
deleted file mode 100644
index 9acaa02..0000000
--- a/webui/src/components/UsageChart.vue
+++ /dev/null
@@ -1,153 +0,0 @@
-<script setup lang="ts">
-import type { ChartData, ChartOptions } from 'chart.js'
-import { computed } from 'vue'
-import { Bar } from 'vue-chartjs'
-
-import '@/lib/chart-setup'
-import { useThemeColors } from '@/composables/useThemeColors'
-import { formatBucketLabel, formatCompactCount, formatCost, formatExactInt } from '@/lib/format'
-import type { TimeSeriesTab } from '@/stores/history'
-import type { HistoryMetric, HistoryWindow, UsageHistoryPoint } from '@/types/api'
-
-const props = defineProps<{
-  tab: TimeSeriesTab
-  window: HistoryWindow
-  seriesByMetric: Partial<Record<HistoryMetric, UsageHistoryPoint[]>>
-}>()
-
-const { foreground, mutedForeground, border } = useThemeColors()
-
-/** One dataset spec per tab: which metric(s), its label, and its token color. */
-const DATASET_SPECS: Record<TimeSeriesTab, { metric: HistoryMetric; label: string; color: string }[]> = {
-  requests: [{ metric: 'req', label: 'Requests', color: '--chart-requests' }],
-  tokens: [
-    { metric: 'tokin', label: 'Tokens in', color: '--chart-tokens-in' },
-    { metric: 'tokout', label: 'Tokens out', color: '--chart-tokens-out' },
-  ],
-  cost: [{ metric: 'cost', label: 'Cost (USD)', color: '--chart-cost' }],
-}
-
-/** cost is stored as micro-USD (limits.go's account/history convention) — every other metric is already the display unit. */
-function toDisplayValue(metric: HistoryMetric, raw: number): number {
-  return metric === 'cost' ? raw / 1_000_000 : raw
-}
-
-/**
- * canonicalBuckets is the union of every active dataset's bucket keys,
- * sorted. The "tokens" tab fetches tokin and tokout as two separate HTTP
- * requests (history.ts's metricsForTab) — not one atomic call — so a
- * window rollover landing between the two requests can leave one series
- * one bucket ahead of the other. Zipping the two arrays positionally
- * would silently mis-stack that refresh's chart. Bucket strings are
- * fixed-width, zero-padded digit strings (limits.go's windowKey: hour
- * "2006010215", day "20060102", month "200601"), so a plain lexicographic
- * sort is also a chronological sort — no date parsing needed to align
- * them.
- */
-const canonicalBuckets = computed<string[]>(() => {
-  const specs = DATASET_SPECS[props.tab]
-  const bucketSet = new Set<string>()
-  for (const spec of specs) {
-    for (const p of props.seriesByMetric[spec.metric] ?? []) bucketSet.add(p.bucket)
-  }
-  return Array.from(bucketSet).sort()
-})
-
-const labels = computed<string[]>(() => canonicalBuckets.value.map((b) => formatBucketLabel(b, props.window)))
-
-/** resolveToken reads one of main.css's --chart-* custom properties from :root, live — so a chart already on screen repaints on a `prefers-color-scheme` flip exactly like useThemeColors does for axis/legend text. */
-function resolveToken(cssVar: string): string {
-  return getComputedStyle(document.documentElement).getPropertyValue(cssVar).trim()
-}
-
-const chartData = computed<ChartData<'bar'>>(() => {
-  // Touch the theme refs so this computed re-runs (and re-reads the CSS
-  // custom properties via resolveToken) on a `prefers-color-scheme` flip —
-  // resolveToken's own getComputedStyle read is not itself reactive.
-  void foreground.value
-  const buckets = canonicalBuckets.value
-  return {
-    labels: labels.value,
-    datasets: DATASET_SPECS[props.tab].map((spec) => {
-      // Map<bucket, value> per series, so each canonical bucket looks up
-      // its own value rather than assuming index i means the same bucket
-      // across every dataset (the mis-stacking canonicalBuckets exists to
-      // avoid — see its own doc comment). A bucket this series has no
-      // point for reads as 0, matching the zero-based axis: a genuinely
-      // missing bucket (not yet reported by the store) is indistinguishable
-      // from zero usage, which is the honest reading for a bar chart.
-      const byBucket = new Map((props.seriesByMetric[spec.metric] ?? []).map((p) => [p.bucket, p.value]))
-      return {
-        label: spec.label,
-        backgroundColor: resolveToken(spec.color),
-        data: buckets.map((b) => toDisplayValue(spec.metric, byBucket.get(b) ?? 0)),
-      }
-    }),
-  }
-})
-
-const stacked = computed<boolean>(() => DATASET_SPECS[props.tab].length > 1)
-
-const chartOptions = computed<ChartOptions<'bar'>>(() => ({
-  responsive: true,
-  maintainAspectRatio: false,
-  animation: false,
-  scales: {
-    x: {
-      stacked: stacked.value,
-      grid: { color: border.value, display: false },
-      ticks: { color: mutedForeground.value },
-    },
-    y: {
-      // Zero-based, honest axis (dataviz rule): a bar chart's y-axis never
-      // starts anywhere but 0, so bar length always means what it looks
-      // like it means.
-      stacked: stacked.value,
-      beginAtZero: true,
-      grid: { color: border.value },
-      ticks: {
-        color: mutedForeground.value,
-        // Axis ticks stay compact (feature v0.23 addendum) — no room for
-        // the exact figure on an axis label; the tooltip below carries
-        // it. Cost reuses formatCost (the same formatter cost/day and
-        // cost/month already render through elsewhere in the app) rather
-        // than interpolating the raw tick float directly — Chart.js hands
-        // this callback whatever value it picked for gridline placement,
-        // which for a non-terminating division (e.g. cost/3) prints as
-        // "0.30000000000000004" without it. formatCost takes micro-USD, so
-        // the already-converted display value (toDisplayValue above) is
-        // scaled back up before the call — .toFixed(4) inside it then
-        // resolves any such float noise the same way the tooltip below
-        // already does by hand.
-        callback: (value) => (props.tab === 'cost' ? formatCost(Number(value) * 1_000_000) : formatCompactCount(Number(value))),
-      },
-    },
-  },
-  plugins: {
-    legend: {
-      display: stacked.value,
-      labels: { color: foreground.value },
-    },
-    tooltip: {
-      callbacks: {
-        // Tooltip shows the compact form WITH the precise raw value
-        // alongside (feature v0.23 addendum) — e.g. "Tokens in: 1.23M
-        // (1,234,567)" — since a tooltip, unlike an axis tick, has room
-        // for both and precision must never be lost. Cost stays its
-        // existing $-with-4-decimals format, unchanged.
-        label: (ctx) => {
-          const value = ctx.parsed.y ?? 0
-          if (props.tab === 'cost') return `${ctx.dataset.label}: $${value.toFixed(4)}`
-          return `${ctx.dataset.label}: ${formatCompactCount(value)} (${formatExactInt(value)})`
-        },
-      },
-    },
-  },
-}))
-</script>
-
-<template>
-  <div class="h-72 w-full">
-    <Bar :data="chartData" :options="chartOptions" />
-  </div>
-</template>
diff --git a/webui/src/components/UsageTable.vue b/webui/src/components/UsageTable.vue
index a571a79..ea46b83 100644
--- a/webui/src/components/UsageTable.vue
+++ b/webui/src/components/UsageTable.vue
@@ -24,13 +24,17 @@ const props = defineProps<{
   emptyMessage?: string
   /** P1: the shared reactive clock (composables/useNow.ts) — threaded into usageColumns() below so this table's own costMonthProj column recomputes as the clock ticks, instead of freezing at whatever instant this computed first ran. */
   now: Date
-  /** P6: optional controlled sort state, forwarded to DataTable's own `v-model:sorting` (see that component's identical prop doc comment) — omitted everywhere except UsageView.vue's top-level Users table, whose export must reflect the table's current sort. */
+  /** P6: optional controlled sort state, forwarded to DataTable's own `v-model:sorting` (see that component's identical prop doc comment) — omitted everywhere except ConsumerDirectory.vue's top-level Users table, whose export must reflect the table's current sort. */
   sorting?: SortingState
+  /** Optional per-row source lookup ('inline'/'file'/undefined), forwarded to usage-columns.ts's usageColumns — see that module's sourceColumn doc comment. Omitted everywhere except ConsumerDirectory.vue's flat Users table. */
+  sourceValue?: (entry: AdminUsageEntryView) => string | undefined
 }>()
 
 const emit = defineEmits<{ 'update:sorting': [value: SortingState] }>()
 
-const columns = computed(() => usageColumns(props.idLabel, props.secondaryColumnLabel, props.secondaryValue, props.now))
+const columns = computed(() =>
+  usageColumns(props.idLabel, props.secondaryColumnLabel, props.secondaryValue, props.now, props.sourceValue),
+)
 </script>
 
 <template>
diff --git a/webui/src/components/UserDetail.vue b/webui/src/components/UserDetail.vue
new file mode 100644
index 0000000..b1bd97b
--- /dev/null
+++ b/webui/src/components/UserDetail.vue
@@ -0,0 +1,274 @@
+<script setup lang="ts">
+import { faArrowLeft } from '@fortawesome/free-solid-svg-icons'
+import { computed, onMounted, onUnmounted, watch } from 'vue'
+
+import ClampedRangeNotice from '@/components/ClampedRangeNotice.vue'
+import CompactNumber from '@/components/CompactNumber.vue'
+import ModelChip from '@/components/ModelChip.vue'
+import TimeSeriesChart from '@/components/TimeSeriesChart.vue'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Badge } from '@/components/ui/badge'
+import { Button } from '@/components/ui/button'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table'
+import UsageBar from '@/components/UsageBar.vue'
+import { useNow } from '@/composables/useNow'
+import { runOutDate as computeRunOutDate } from '@/lib/burndown'
+import { formatBucketLabel, formatCost, formatExactInt, formatLimits, formatTimestamp } from '@/lib/format'
+import { BUDGET_RATIO_LABEL, budgetRatios } from '@/lib/usage-bars'
+import { useConsumersStore } from '@/stores/consumers'
+import { useDashboardStore } from '@/stores/dashboard'
+import { useEventsStore } from '@/stores/events'
+import { useFiltersStore } from '@/stores/filters'
+
+/**
+ * UserDetail (redesign-plan.md section 3.4) is the Consumers page's
+ * `user=<name>` drill-down: a timeline of the user's own req/cost series,
+ * their per-model breakdown (usermodel totals, when admin.stats.userModel
+ * is on), recent errors filtered from the shared Events store, headroom
+ * bars + an estimated run-out date, and their limits/grants.
+ */
+const props = defineProps<{ userId: string }>()
+const emit = defineEmits<{ close: [] }>()
+
+const dashboard = useDashboardStore()
+const consumers = useConsumersStore()
+const events = useEventsStore()
+const filters = useFiltersStore()
+const { now, start: startClock, stop: stopClock } = useNow()
+onMounted(startClock)
+onUnmounted(stopClock)
+
+/** entry is this user's own row from the polled /admin/api/usage response — live counters, limits, lastSeen. undefined for a configured user who has never made a request (no usage scope created yet) or an id that does not exist at all. */
+const entry = computed(() => dashboard.usage?.users.find((u) => u.id === props.userId))
+
+/** consumerUser is this user's own row from GET /admin/api/consumers — source, admin flag, personal grant. */
+const consumerUser = computed(() => consumers.data?.users.find((u) => u.name === props.userId))
+
+const featuresUserModelStats = computed(() => dashboard.overview?.features.userModelStats ?? false)
+
+function loadDetail(): void {
+  void consumers.fetchUserDetail(props.userId, filters.window, filters.span, featuresUserModelStats.value)
+}
+
+onMounted(() => {
+  loadDetail()
+  void events.refresh()
+})
+// featuresUserModelStats is included alongside userId/range: on a deep
+// link or reload (#consumers?user=x), this component mounts and fires
+// loadDetail() BEFORE the polled overview (stores/dashboard.ts) has
+// necessarily landed its first response, so the very first loadDetail()
+// call can run with userModelStatsEnabled still false even though the
+// feature really is on. Once the overview lands and that computed flips
+// true, this watch refetches — otherwise "Models used" stayed
+// permanently empty for the rest of the session even after the alert
+// telling the reader to enable it disappeared (P2).
+watch([() => props.userId, () => filters.range, featuresUserModelStats], loadDetail)
+
+const detail = computed(() => consumers.detail[props.userId])
+
+// Labels are built from the RESPONSE's own `window` (AdminSeriesResponse),
+// not from the current filters.window directly — two fetchUserDetail
+// calls for different ranges can land out of order, and reading the
+// window off the live global filter would then mislabel a still-
+// displayed stale response's buckets (P1 item 7). Falls back to
+// filters.window only before any response has ever landed.
+const reqLabels = computed(() =>
+  (detail.value?.reqSeries?.buckets ?? []).map((b) => formatBucketLabel(b, detail.value?.reqSeries?.window ?? filters.window)),
+)
+const reqDatasets = computed(() => [
+  { label: 'Requests', data: detail.value?.reqSeries?.series[0]?.points ?? [], color: '--chart-requests' },
+])
+const costLabels = computed(() =>
+  (detail.value?.costSeries?.buckets ?? []).map((b) => formatBucketLabel(b, detail.value?.costSeries?.window ?? filters.window)),
+)
+const costDatasets = computed(() => [
+  { label: 'Cost', data: (detail.value?.costSeries?.series[0]?.points ?? []).map((v) => v), color: '--chart-cost' },
+])
+
+/** showUserModelHint mirrors AttributionDrilldown.vue's own convention (Spend page): the hint shows when the client's own feature flag reads off, OR the usermodel call itself came back 404 (stores/consumers.ts's modelTotalsUnavailable) — the second case catches a stale/not-yet-loaded overview on a deep link or reload, where featuresUserModelStats can read true for a moment while the server still says otherwise. */
+const showUserModelHint = computed(() => !featuresUserModelStats.value || detail.value?.modelTotalsUnavailable === true)
+
+/** modelRows ranks usermodel totals by cost desc (falling back to req when cost is absent from the requested metrics) — a small, page-local sort since this table has no other consumer that would justify a shared column/sort helper. */
+const modelRows = computed(() => {
+  const rows = detail.value?.modelTotals?.rows ?? []
+  return [...rows].sort((a, b) => (b.values.cost ?? b.values.req ?? 0) - (a.values.cost ?? a.values.req ?? 0))
+})
+
+/** recentErrors filters the shared Events store (WP-F, read-only import) down to this user — the newest 10, matching the store's own newest-first order. */
+const recentErrors = computed(() => events.events.filter((e) => e.user === props.userId).slice(0, 10))
+
+const ratios = computed(() => (entry.value ? budgetRatios(entry.value) : []))
+
+function budgetValueText(id: string, used: number, limit: number): string {
+  if (id.startsWith('cost')) return `${formatCost(used)} / ${formatCost(limit)}`
+  return `${formatExactInt(used)} / ${formatExactInt(limit)}`
+}
+
+/**
+ * runOutDate reuses lib/burndown.ts's own runOutDate — the SAME function
+ * BurnDownChart.vue projects the Spend page's burn-down line with — rather
+ * than a second, disagreeing implementation (P2 item 14: the two used to
+ * differ on an already-exceeded budget and on day 1 of the month).
+ */
+const runOutDate = computed(() => {
+  const limitUsd = entry.value?.limits?.costPerMonthUSD
+  if (!entry.value || !limitUsd) return null
+  return computeRunOutDate(entry.value.costPerMonthMicroUsd, Math.round(limitUsd * 1_000_000), now.value)
+})
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="flex items-center gap-2">
+      <Button type="button" variant="ghost" size="sm" @click="emit('close')">
+        <FontAwesomeIcon :icon="faArrowLeft" class="size-3.5" aria-hidden="true" />
+        Back to directory
+      </Button>
+    </div>
+
+    <Card>
+      <CardHeader>
+        <div class="flex flex-wrap items-center gap-2">
+          <CardTitle class="font-mono">{{ userId }}</CardTitle>
+          <Badge v-if="consumerUser?.admin" variant="destructive">admin</Badge>
+          <Badge v-if="consumerUser?.source" variant="secondary">{{ consumerUser.source }}</Badge>
+        </div>
+        <CardDescription v-if="entry?.groups?.length || entry?.groupName">
+          Member of {{ (entry?.groups ?? [entry?.groupName]).filter(Boolean).join(', ') }}
+        </CardDescription>
+      </CardHeader>
+      <CardContent v-if="!entry" class="text-sm text-muted-foreground">
+        No usage scope for this user yet — it appears after their first request.
+      </CardContent>
+      <CardContent v-else class="grid grid-cols-2 gap-4 text-sm sm:grid-cols-4">
+        <div>
+          <p class="text-muted-foreground">Requests/day</p>
+          <p class="text-lg font-semibold tabular-nums"><CompactNumber :value="entry.requestsPerDay" /></p>
+        </div>
+        <div>
+          <p class="text-muted-foreground">Cost/day</p>
+          <p class="text-lg font-semibold tabular-nums">{{ formatCost(entry.costPerDayMicroUsd) }}</p>
+        </div>
+        <div>
+          <p class="text-muted-foreground">Cost/month</p>
+          <p class="text-lg font-semibold tabular-nums">{{ formatCost(entry.costPerMonthMicroUsd) }}</p>
+        </div>
+        <div>
+          <p class="text-muted-foreground">Limits</p>
+          <p class="text-sm">{{ formatLimits(entry.limits) }}</p>
+        </div>
+      </CardContent>
+    </Card>
+
+    <Card v-if="entry && ratios.length">
+      <CardHeader>
+        <CardTitle>Headroom</CardTitle>
+        <CardDescription v-if="runOutDate">At the current pace, cost/month runs out around {{ formatTimestamp(runOutDate.toISOString()) }}.</CardDescription>
+      </CardHeader>
+      <CardContent class="flex flex-wrap items-center gap-x-4 gap-y-1.5">
+        <span v-for="ratio in ratios" :key="ratio.id" class="inline-flex items-center gap-1.5 text-xs text-muted-foreground">
+          {{ BUDGET_RATIO_LABEL[ratio.id] }}
+          <UsageBar
+            :ratio="ratio.ratio"
+            :label="BUDGET_RATIO_LABEL[ratio.id]"
+            :value-text="budgetValueText(ratio.id, ratio.used, ratio.limit)"
+          />
+        </span>
+      </CardContent>
+    </Card>
+
+    <Card>
+      <CardHeader>
+        <CardTitle>Requests over time</CardTitle>
+      </CardHeader>
+      <CardContent>
+        <p v-if="detail?.loading" class="text-sm text-muted-foreground">loading…</p>
+        <p v-else-if="detail?.error" class="text-sm text-destructive">{{ detail.error }}</p>
+        <TimeSeriesChart v-else :labels="reqLabels" :datasets="reqDatasets" :ariaLabel="`Requests over time for ${userId}`" />
+      </CardContent>
+    </Card>
+
+    <Card>
+      <CardHeader>
+        <CardTitle>Cost over time</CardTitle>
+      </CardHeader>
+      <CardContent>
+        <p v-if="detail?.loading" class="text-sm text-muted-foreground">loading…</p>
+        <p v-else-if="detail?.error" class="text-sm text-destructive">{{ detail.error }}</p>
+        <TimeSeriesChart v-else :labels="costLabels" :datasets="costDatasets" :value-formatter="formatCost" :ariaLabel="`Cost over time for ${userId}`" />
+      </CardContent>
+    </Card>
+
+    <Card>
+      <CardHeader>
+        <CardTitle>Models used</CardTitle>
+      </CardHeader>
+      <CardContent class="flex flex-col gap-3">
+        <ClampedRangeNotice :window="filters.window" :span="filters.span" />
+        <Alert v-if="showUserModelHint" variant="warn">
+          <AlertDescription>Enable admin.stats.userModel in the plugin config to see a per-model breakdown for this user.</AlertDescription>
+        </Alert>
+        <Table v-else-if="modelRows.length">
+          <TableHeader>
+            <TableRow>
+              <TableHead>Model</TableHead>
+              <TableHead class="text-right">Requests</TableHead>
+              <TableHead class="text-right">Cost</TableHead>
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            <TableRow v-for="row in modelRows" :key="row.id">
+              <TableCell><ModelChip :id="row.id" /></TableCell>
+              <TableCell class="text-right tabular-nums"><CompactNumber :value="row.values.req ?? 0" /></TableCell>
+              <TableCell class="text-right tabular-nums">{{ formatCost(row.values.cost ?? 0) }}</TableCell>
+            </TableRow>
+          </TableBody>
+        </Table>
+        <p v-else class="py-6 text-center text-sm text-muted-foreground">no model usage in this range</p>
+      </CardContent>
+    </Card>
+
+    <Card>
+      <CardHeader>
+        <CardTitle>Recent errors</CardTitle>
+      </CardHeader>
+      <CardContent>
+        <ul v-if="recentErrors.length" class="flex flex-col gap-2 text-sm">
+          <li v-for="(event, index) in recentErrors" :key="index" class="border-b pb-2 last:border-0 last:pb-0">
+            <p class="flex flex-wrap items-center gap-2">
+              <Badge variant="secondary">{{ event.kind }}</Badge>
+              <span class="text-muted-foreground">{{ formatTimestamp(event.time) }}</span>
+            </p>
+            <p class="text-muted-foreground">{{ event.message }}</p>
+          </li>
+        </ul>
+        <p v-else class="py-6 text-center text-sm text-muted-foreground">none in the current event window</p>
+      </CardContent>
+    </Card>
+
+    <Card v-if="consumerUser?.providers?.length || consumerUser?.models?.length">
+      <CardHeader>
+        <CardTitle>Personal grant</CardTitle>
+        <CardDescription>Access this user has beyond their group's own.</CardDescription>
+      </CardHeader>
+      <CardContent class="grid grid-cols-1 gap-4 sm:grid-cols-2">
+        <div>
+          <p class="mb-1.5 text-xs text-muted-foreground">Providers</p>
+          <div class="flex flex-wrap gap-1.5">
+            <Badge v-for="name in consumerUser?.providers ?? []" :key="name" as="span" variant="secondary" class="font-mono font-normal">
+              {{ name }}
+            </Badge>
+          </div>
+        </div>
+        <div>
+          <p class="mb-1.5 text-xs text-muted-foreground">Models</p>
+          <div class="flex flex-wrap gap-1.5">
+            <ModelChip v-for="id in consumerUser?.models ?? []" :key="id" :id="id" />
+          </div>
+        </div>
+      </CardContent>
+    </Card>
+  </div>
+</template>
diff --git a/webui/src/components/forms/GrantForm.vue b/webui/src/components/forms/GrantForm.vue
new file mode 100644
index 0000000..fd8a8f5
--- /dev/null
+++ b/webui/src/components/forms/GrantForm.vue
@@ -0,0 +1,138 @@
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+
+import SnippetBlock from '@/components/SnippetBlock.vue'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Input } from '@/components/ui/input'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { groupGrantSnippet, isValidName, isValidUserName, userGrantJsonFragment, validatePersonalGrant } from '@/lib/snippets'
+
+/**
+ * GrantForm (ChangeHelper, redesign-plan.md section 3.4) builds a group's
+ * access-list snippet (providers/models/mcpServers/agents, YAML) or a
+ * user's personal grant (providers/models only — GroupConfig has no
+ * per-user mcpServers/agents grant field, auth.go's own UserConfig shape)
+ * as a bare JSON fragment for an existing users.json entry.
+ *
+ * Every list field is a comma-separated text Input rather than a proper
+ * multi-select (no such shadcn-vue primitive is installed in this panel) —
+ * parsed, trimmed, and de-duplicated below.
+ */
+const props = defineProps<{
+  groupNames: string[]
+  userNames: string[]
+}>()
+
+const targetKind = ref<'group' | 'user'>('group')
+const targetName = ref('')
+const providersRaw = ref('')
+const modelsRaw = ref('')
+const mcpServersRaw = ref('')
+const agentsRaw = ref('')
+
+/** parseList splits a comma-separated field into trimmed, non-empty, de-duplicated entries — the one shared parser every list field below uses. */
+function parseList(raw: string): string[] {
+  const seen = new Set<string>()
+  for (const part of raw.split(',')) {
+    const trimmed = part.trim()
+    if (trimmed) seen.add(trimmed)
+  }
+  return Array.from(seen)
+}
+
+const providers = computed(() => parseList(providersRaw.value))
+const models = computed(() => parseList(modelsRaw.value))
+const mcpServers = computed(() => parseList(mcpServersRaw.value))
+const agents = computed(() => parseList(agentsRaw.value))
+
+const targetNames = computed(() => (targetKind.value === 'group' ? props.groupNames : props.userNames))
+// A group name follows NAME_PATTERN (auth.go's configNamePattern — a
+// route-path-segment safety rule); a user name only needs to be
+// non-empty (auth.go's buildEntry, no character restriction at all —
+// P3 item 27). isValidUserName, not isValidName, for targetKind === 'user'.
+const nameValid = computed(() => (targetKind.value === 'group' ? isValidName(targetName.value.trim()) : isValidUserName(targetName.value)))
+
+// validatePersonalGrant is a USER-ONLY rule (lib/snippets.ts's own doc
+// comment) — a group's own `providers: []` legitimately means "every
+// provider" and Go applies it with no such check at group-construction
+// time (auth.go). Gated on targetKind so a group grant with an empty
+// providers list + a models list (a perfectly valid group config) no
+// longer shows a rejection that does not apply to it (P1 item 13).
+const grantError = computed(() => (targetKind.value === 'user' ? validatePersonalGrant(providers.value, models.value) : null))
+
+const isEmpty = computed(
+  () => providers.value.length === 0 && models.value.length === 0 && mcpServers.value.length === 0 && agents.value.length === 0,
+)
+
+const snippet = computed<string | null>(() => {
+  if (!nameValid.value || grantError.value || isEmpty.value) return null
+  if (targetKind.value === 'group') {
+    return groupGrantSnippet(targetName.value.trim(), {
+      providers: providers.value,
+      models: models.value,
+      mcpServers: mcpServers.value,
+      agents: agents.value,
+    })
+  }
+  const fragment = userGrantJsonFragment({ providers: providers.value, models: models.value })
+  return fragment || null
+})
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="grid grid-cols-1 gap-3 sm:grid-cols-2">
+      <div class="flex flex-col gap-1">
+        <label id="grant-target-kind-label" class="text-xs font-medium text-muted-foreground">Target</label>
+        <Select :model-value="targetKind" @update:model-value="(v) => (targetKind = v as 'group' | 'user')">
+          <SelectTrigger aria-labelledby="grant-target-kind-label"><SelectValue /></SelectTrigger>
+          <SelectContent>
+            <SelectItem value="group">Group</SelectItem>
+            <SelectItem value="user">User (personal grant, existing users.json entry)</SelectItem>
+          </SelectContent>
+        </Select>
+      </div>
+      <div class="flex flex-col gap-1">
+        <label id="grant-target-name-label" class="text-xs font-medium text-muted-foreground">{{ targetKind === 'group' ? 'Group name' : 'User name' }}</label>
+        <Select :model-value="targetName" @update:model-value="(v) => (targetName = String(v))">
+          <SelectTrigger aria-labelledby="grant-target-name-label"><SelectValue placeholder="Select…" /></SelectTrigger>
+          <SelectContent>
+            <SelectItem v-for="name in targetNames" :key="name" :value="name">{{ name }}</SelectItem>
+          </SelectContent>
+        </Select>
+      </div>
+    </div>
+
+    <div class="grid grid-cols-1 gap-3 sm:grid-cols-2">
+      <div class="flex flex-col gap-1">
+        <label for="grant-providers" class="text-xs font-medium text-muted-foreground">Providers (comma-separated, empty = all)</label>
+        <Input id="grant-providers" v-model="providersRaw" placeholder="anthropic, openai" />
+      </div>
+      <div class="flex flex-col gap-1">
+        <label for="grant-models" class="text-xs font-medium text-muted-foreground">Models (comma-separated, empty = all)</label>
+        <Input id="grant-models" v-model="modelsRaw" placeholder="anthropic/claude-sonnet-5" />
+      </div>
+      <template v-if="targetKind === 'group'">
+        <div class="flex flex-col gap-1">
+          <label for="grant-mcp" class="text-xs font-medium text-muted-foreground">MCP servers (comma-separated, empty = all)</label>
+          <Input id="grant-mcp" v-model="mcpServersRaw" placeholder="fetch, weather" />
+        </div>
+        <div class="flex flex-col gap-1">
+          <label for="grant-agents" class="text-xs font-medium text-muted-foreground">Agents (comma-separated, empty = all)</label>
+          <Input id="grant-agents" v-model="agentsRaw" placeholder="agentkit" />
+        </div>
+      </template>
+    </div>
+
+    <Alert v-if="grantError" variant="destructive">
+      <AlertDescription>{{ grantError }}</AlertDescription>
+    </Alert>
+
+    <SnippetBlock
+      v-if="snippet"
+      :label="targetKind === 'group' ? 'Paste into middleware.yaml' : `Merge into ${targetName}’s users.json line`"
+      :text="snippet"
+    />
+    <p v-else class="text-sm text-muted-foreground">Pick a target and at least one list to build a snippet.</p>
+  </div>
+</template>
diff --git a/webui/src/components/forms/LimitsForm.vue b/webui/src/components/forms/LimitsForm.vue
new file mode 100644
index 0000000..9515a8e
--- /dev/null
+++ b/webui/src/components/forms/LimitsForm.vue
@@ -0,0 +1,143 @@
+<script setup lang="ts">
+import { computed, reactive, ref } from 'vue'
+
+import SnippetBlock from '@/components/SnippetBlock.vue'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Input } from '@/components/ui/input'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { groupLimitsSnippet, isValidName, isValidNonNegative, isValidNonNegativeInt, isValidUserName, userLimitsJsonFragment } from '@/lib/snippets'
+import type { LimitsConfig } from '@/types/api'
+
+/**
+ * LimitsForm (ChangeHelper, redesign-plan.md section 3.4) builds a
+ * group's or a user's limits snippet — a group's is a full YAML block
+ * (lib/snippets.ts's groupLimitsSnippet); a user's own limits live inside
+ * their users.json line, so it is a bare JSON field fragment
+ * (userLimitsJsonFragment) meant to be merged into that user's existing
+ * entry, not a whole new line (UserForm.vue owns building a whole new
+ * line).
+ */
+const props = defineProps<{
+  groupNames: string[]
+  userNames: string[]
+}>()
+
+const targetKind = ref<'group' | 'user'>('group')
+const targetName = ref('')
+
+/** INTEGER_FIELDS is every LimitsConfig field Go decodes as `int64` (llmgateway.go) — requestsPerMinute/requestsPerDay/tokensPerDay/tokensPerMonth reject a fractional value like "1.5" at json.Unmarshal outright (P2 item 12), unlike costPerDayUSD/costPerMonthUSD, which are `float64`. */
+const INTEGER_FIELDS = new Set<keyof LimitsConfig>(['requestsPerMinute', 'requestsPerDay', 'tokensPerDay', 'tokensPerMonth'])
+
+/** fieldValid applies isValidNonNegativeInt to the four int64 fields and isValidNonNegative (fractions allowed) to the two float64 cost fields — the ONE gate both invalidFields and limits below share, so they can never disagree on which fields are int-only. */
+function fieldValid(key: keyof LimitsConfig, value: number): boolean {
+  return INTEGER_FIELDS.has(key) ? isValidNonNegativeInt(value) : isValidNonNegative(value)
+}
+
+const FIELDS: { key: keyof LimitsConfig; label: string }[] = [
+  { 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)' },
+]
+
+const raw = reactive<Record<keyof LimitsConfig, string>>({
+  requestsPerMinute: '',
+  requestsPerDay: '',
+  tokensPerDay: '',
+  tokensPerMonth: '',
+  costPerDayUSD: '',
+  costPerMonthUSD: '',
+})
+
+const targetNames = computed(() => (targetKind.value === 'group' ? props.groupNames : props.userNames))
+
+/** invalidFields lists every field whose entered text is non-empty but fails its own domain check (fieldValid above) — surfaced individually rather than one generic "invalid input" message, so the operator can see exactly which field to fix. Split by INTEGER_FIELDS so the error text is accurate for both: a fraction is invalid for requestsPerMinute etc. but perfectly valid for costPerDayUSD/costPerMonthUSD. */
+const invalidFields = computed(() =>
+  FIELDS.filter(({ key }) => raw[key].trim() !== '' && !fieldValid(key, Number(raw[key]))).map((f) => f.label),
+)
+const invalidIntegerFields = computed(() =>
+  FIELDS.filter(({ key }) => INTEGER_FIELDS.has(key) && raw[key].trim() !== '' && !fieldValid(key, Number(raw[key]))).map((f) => f.label),
+)
+const invalidDecimalFields = computed(() =>
+  FIELDS.filter(({ key }) => !INTEGER_FIELDS.has(key) && raw[key].trim() !== '' && !fieldValid(key, Number(raw[key]))).map((f) => f.label),
+)
+
+const limits = computed<LimitsConfig>(() => {
+  const out: LimitsConfig = {}
+  for (const { key } of FIELDS) {
+    const value = Number(raw[key])
+    if (raw[key].trim() !== '' && fieldValid(key, value) && value > 0) out[key] = value
+  }
+  return out
+})
+
+// A group name follows NAME_PATTERN (auth.go's configNamePattern — a
+// route-path-segment safety rule); a user name only needs to be
+// non-empty (auth.go's buildEntry, no character restriction at all —
+// P3 item 27). isValidUserName, not isValidName, for targetKind === 'user'.
+const nameValid = computed(() => (targetKind.value === 'group' ? isValidName(targetName.value.trim()) : isValidUserName(targetName.value)))
+
+const snippet = computed<string | null>(() => {
+  if (!nameValid.value || invalidFields.value.length > 0) return null
+  if (Object.keys(limits.value).length === 0) return null
+  return targetKind.value === 'group'
+    ? groupLimitsSnippet(targetName.value.trim(), limits.value)
+    : userLimitsJsonFragment(limits.value)
+})
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="grid grid-cols-1 gap-3 sm:grid-cols-2">
+      <div class="flex flex-col gap-1">
+        <label id="limits-target-kind-label" class="text-xs font-medium text-muted-foreground">Target</label>
+        <Select :model-value="targetKind" @update:model-value="(v) => (targetKind = v as 'group' | 'user')">
+          <SelectTrigger aria-labelledby="limits-target-kind-label"><SelectValue /></SelectTrigger>
+          <SelectContent>
+            <SelectItem value="group">Group</SelectItem>
+            <SelectItem value="user">User (existing users.json entry)</SelectItem>
+          </SelectContent>
+        </Select>
+      </div>
+      <div class="flex flex-col gap-1">
+        <label id="limits-target-name-label" class="text-xs font-medium text-muted-foreground">{{ targetKind === 'group' ? 'Group name' : 'User name' }}</label>
+        <Select :model-value="targetName" @update:model-value="(v) => (targetName = String(v))">
+          <SelectTrigger aria-labelledby="limits-target-name-label"><SelectValue placeholder="Select…" /></SelectTrigger>
+          <SelectContent>
+            <SelectItem v-for="name in targetNames" :key="name" :value="name">{{ name }}</SelectItem>
+          </SelectContent>
+        </Select>
+      </div>
+    </div>
+
+    <div class="grid grid-cols-1 gap-3 sm:grid-cols-3">
+      <div v-for="field in FIELDS" :key="field.key" class="flex flex-col gap-1">
+        <label :for="`limits-${field.key}`" class="text-xs font-medium text-muted-foreground">{{ field.label }}</label>
+        <Input
+          :id="`limits-${field.key}`"
+          v-model="raw[field.key]"
+          type="number"
+          min="0"
+          :step="INTEGER_FIELDS.has(field.key) ? '1' : 'any'"
+          placeholder="unset"
+        />
+      </div>
+    </div>
+
+    <Alert v-if="invalidFields.length" variant="destructive">
+      <AlertDescription>
+        <p v-if="invalidIntegerFields.length">Enter a non-negative whole number for: {{ invalidIntegerFields.join(', ') }}.</p>
+        <p v-if="invalidDecimalFields.length">Enter a non-negative number for: {{ invalidDecimalFields.join(', ') }}.</p>
+      </AlertDescription>
+    </Alert>
+
+    <SnippetBlock
+      v-if="snippet"
+      :label="targetKind === 'group' ? 'Paste into middleware.yaml' : `Merge into ${targetName}’s users.json line`"
+      :text="snippet"
+    />
+    <p v-else class="text-sm text-muted-foreground">Pick a target and at least one limit to build a snippet.</p>
+  </div>
+</template>
diff --git a/webui/src/components/forms/ModelMetaForm.vue b/webui/src/components/forms/ModelMetaForm.vue
new file mode 100644
index 0000000..4ba5582
--- /dev/null
+++ b/webui/src/components/forms/ModelMetaForm.vue
@@ -0,0 +1,64 @@
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+
+import SnippetBlock from '@/components/SnippetBlock.vue'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Input } from '@/components/ui/input'
+import { isValidNonNegativeInt, modelMetaSnippet } from '@/lib/snippets'
+
+/**
+ * ModelMetaForm (ChangeHelper, redesign-plan.md section 3.4) builds a
+ * model's contextTokens/free modelMeta entry — independent fields (unlike
+ * PricingForm.vue's paired input/output price), either or both may be
+ * set: contextTokens alone documents a window the upstream cannot report;
+ * free alone marks a self-hosted model billed as 0 regardless of any
+ * discovered/override price (pricing.go: modelMetaFree short-circuits
+ * before override/builtin/LiteLLM resolution).
+ */
+const modelId = ref('')
+const contextRaw = ref('')
+const free = ref(false)
+
+const modelIdValid = computed(() => modelId.value.trim() !== '')
+const contextValue = computed(() => Number(contextRaw.value))
+const contextEntered = computed(() => contextRaw.value.trim() !== '')
+// ModelMetaConfig.ContextTokens is Go `int` (llmgateway.go) — a fraction
+// like "128000.5" fails json.Unmarshal outright, so isValidNonNegativeInt
+// (not isValidNonNegative) is the right domain check here (P2 item 12).
+const contextValid = computed(() => !contextEntered.value || (isValidNonNegativeInt(contextValue.value) && contextValue.value > 0))
+
+const snippet = computed<string | null>(() => {
+  if (!modelIdValid.value || !contextValid.value) return null
+  if (!contextEntered.value && !free.value) return null
+  return modelMetaSnippet(modelId.value.trim(), {
+    contextTokens: contextEntered.value ? contextValue.value : undefined,
+    free: free.value || undefined,
+  })
+})
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="flex flex-col gap-1">
+      <label for="modelmeta-model-id" class="text-xs font-medium text-muted-foreground">Model id (provider/model)</label>
+      <Input id="modelmeta-model-id" v-model="modelId" placeholder="gx10/current" class="font-mono" />
+    </div>
+    <div class="grid grid-cols-1 gap-3 sm:grid-cols-2 sm:items-end">
+      <div class="flex flex-col gap-1">
+        <label for="modelmeta-context" class="text-xs font-medium text-muted-foreground">Context window (tokens)</label>
+        <Input id="modelmeta-context" v-model="contextRaw" type="number" min="1" step="1" placeholder="131072" />
+      </div>
+      <label class="flex items-center gap-2 pb-1.5 text-sm">
+        <input id="modelmeta-free" v-model="free" type="checkbox" class="size-4 rounded border-input" />
+        Free (billed as $0 regardless of any resolved price)
+      </label>
+    </div>
+
+    <Alert v-if="contextEntered && !contextValid" variant="destructive">
+      <AlertDescription>Context window must be a positive whole number of tokens.</AlertDescription>
+    </Alert>
+
+    <SnippetBlock v-if="snippet" label="Paste into middleware.yaml" :text="snippet" />
+    <p v-else class="text-sm text-muted-foreground">Enter a model id and set a context window and/or free to build a snippet.</p>
+  </div>
+</template>
diff --git a/webui/src/components/forms/PricingForm.vue b/webui/src/components/forms/PricingForm.vue
new file mode 100644
index 0000000..765a53c
--- /dev/null
+++ b/webui/src/components/forms/PricingForm.vue
@@ -0,0 +1,74 @@
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+
+import SnippetBlock from '@/components/SnippetBlock.vue'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Input } from '@/components/ui/input'
+import { isValidNonNegative, pricingSnippet } from '@/lib/snippets'
+
+/**
+ * PricingForm (ChangeHelper, redesign-plan.md section 3.4) builds a
+ * model's per-token pricing override — inputPerM/outputPerM, the two
+ * ModelPricing fields (llmgateway.go) that live in the top-level
+ * Config.Pricing map (`spec.plugin.llmgateway.pricing`) and OVERRIDE the
+ * built-in/LiteLLM-derived price for one model id (pricing.go's
+ * billingPriceSource: `override` always wins). This is a DIFFERENT config
+ * section from ModelMetaForm.vue's own modelMeta entry — ModelMeta's own
+ * cost fields drive metadata exposure only, never billing (see
+ * lib/snippets.ts's own ModelMeta doc comment). Both fields are required
+ * together — a one-sided price makes no billing sense — unlike
+ * ModelMetaForm.vue's independent contextTokens/free fields.
+ */
+const modelId = ref('')
+const inputRaw = ref('')
+const outputRaw = ref('')
+
+const modelIdValid = computed(() => modelId.value.trim() !== '')
+const inputValue = computed(() => Number(inputRaw.value))
+const outputValue = computed(() => Number(outputRaw.value))
+const inputValid = computed(() => inputRaw.value.trim() !== '' && isValidNonNegative(inputValue.value))
+const outputValid = computed(() => outputRaw.value.trim() !== '' && isValidNonNegative(outputValue.value))
+
+const errors = computed(() => {
+  const out: string[] = []
+  if (inputRaw.value.trim() !== '' && !inputValid.value) out.push('Input price/MTok must be a non-negative number.')
+  if (outputRaw.value.trim() !== '' && !outputValid.value) out.push('Output price/MTok must be a non-negative number.')
+  if ((inputValid.value && !outputValid.value) || (!inputValid.value && outputValid.value)) {
+    out.push('Set both input and output price/MTok — a one-sided override has no billing meaning.')
+  }
+  return out
+})
+
+const snippet = computed<string | null>(() => {
+  if (!modelIdValid.value || !inputValid.value || !outputValid.value) return null
+  return pricingSnippet(modelId.value.trim(), { inputPerM: inputValue.value, outputPerM: outputValue.value })
+})
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="flex flex-col gap-1">
+      <label for="pricing-model-id" class="text-xs font-medium text-muted-foreground">Model id (provider/model)</label>
+      <Input id="pricing-model-id" v-model="modelId" placeholder="openai/gpt-4" class="font-mono" />
+    </div>
+    <div class="grid grid-cols-1 gap-3 sm:grid-cols-2">
+      <div class="flex flex-col gap-1">
+        <label for="pricing-input" class="text-xs font-medium text-muted-foreground">Input price / MTok (USD)</label>
+        <Input id="pricing-input" v-model="inputRaw" type="number" min="0" step="any" placeholder="0.50" />
+      </div>
+      <div class="flex flex-col gap-1">
+        <label for="pricing-output" class="text-xs font-medium text-muted-foreground">Output price / MTok (USD)</label>
+        <Input id="pricing-output" v-model="outputRaw" type="number" min="0" step="any" placeholder="1.50" />
+      </div>
+    </div>
+
+    <Alert v-if="errors.length" variant="destructive">
+      <AlertDescription>
+        <p v-for="(error, index) in errors" :key="index">{{ error }}</p>
+      </AlertDescription>
+    </Alert>
+
+    <SnippetBlock v-if="snippet" label="Paste into middleware.yaml" :text="snippet" />
+    <p v-else class="text-sm text-muted-foreground">Enter a model id and both prices to build a snippet.</p>
+  </div>
+</template>
diff --git a/webui/src/components/forms/UserForm.vue b/webui/src/components/forms/UserForm.vue
new file mode 100644
index 0000000..15a1aab
--- /dev/null
+++ b/webui/src/components/forms/UserForm.vue
@@ -0,0 +1,123 @@
+<script setup lang="ts">
+import { computed, ref } from 'vue'
+
+import SnippetBlock from '@/components/SnippetBlock.vue'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { API_KEY_PLACEHOLDER, generateApiKey, isValidUserName, userJsonLine, validatePersonalGrant } from '@/lib/snippets'
+
+/**
+ * UserForm (ChangeHelper, redesign-plan.md section 3.4) builds a whole new
+ * users.json line — name, apiKey (placeholder by default, Q10 DECISION;
+ * "Generate" produces a real client-side random key, never sent anywhere),
+ * a primary group (production's own single-`group` convention) plus an
+ * optional comma list of ADDITIONAL groups that switches the emitted field
+ * to plural `groups` (lib/snippets.ts's userJsonLine), an optional
+ * personal grant (validated the same way GrantForm.vue's user-target path
+ * is), and an admin checkbox.
+ */
+const props = defineProps<{ groupNames: string[] }>()
+
+const name = ref('')
+const apiKey = ref(API_KEY_PLACEHOLDER)
+const primaryGroup = ref('')
+const extraGroupsRaw = ref('')
+const providersRaw = ref('')
+const modelsRaw = ref('')
+const admin = ref(false)
+
+function generate(): void {
+  apiKey.value = generateApiKey()
+}
+
+function parseList(raw: string): string[] {
+  const seen = new Set<string>()
+  for (const part of raw.split(',')) {
+    const trimmed = part.trim()
+    if (trimmed) seen.add(trimmed)
+  }
+  return Array.from(seen)
+}
+
+const extraGroups = computed(() => parseList(extraGroupsRaw.value))
+const providers = computed(() => parseList(providersRaw.value))
+const models = computed(() => parseList(modelsRaw.value))
+
+const nameValid = computed(() => isValidUserName(name.value))
+const groupValid = computed(() => primaryGroup.value !== '')
+const apiKeyValid = computed(() => apiKey.value.trim() !== '' && apiKey.value !== API_KEY_PLACEHOLDER)
+const grantError = computed(() => validatePersonalGrant(providers.value, models.value))
+
+const snippet = computed<string | null>(() => {
+  if (!nameValid.value || !groupValid.value || !apiKeyValid.value || grantError.value) return null
+  const allGroups = extraGroups.value.length > 0 ? [primaryGroup.value, ...extraGroups.value] : null
+  return userJsonLine({
+    name: name.value.trim(),
+    apiKey: apiKey.value.trim(),
+    group: allGroups ? undefined : primaryGroup.value,
+    groups: allGroups ?? undefined,
+    providers: providers.value,
+    models: models.value,
+    admin: admin.value,
+  })
+})
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="grid grid-cols-1 gap-3 sm:grid-cols-2">
+      <div class="flex flex-col gap-1">
+        <label for="user-name" class="text-xs font-medium text-muted-foreground">Name</label>
+        <Input id="user-name" v-model="name" placeholder="alice" />
+      </div>
+      <div class="flex flex-col gap-1">
+        <label id="user-group-label" class="text-xs font-medium text-muted-foreground">Primary group</label>
+        <Select :model-value="primaryGroup" @update:model-value="(v) => (primaryGroup = String(v))">
+          <SelectTrigger aria-labelledby="user-group-label"><SelectValue placeholder="Select…" /></SelectTrigger>
+          <SelectContent>
+            <SelectItem v-for="g in props.groupNames" :key="g" :value="g">{{ g }}</SelectItem>
+          </SelectContent>
+        </Select>
+      </div>
+    </div>
+
+    <div class="flex flex-col gap-1">
+      <label for="user-api-key" class="text-xs font-medium text-muted-foreground">API key</label>
+      <div class="flex gap-2">
+        <Input id="user-api-key" v-model="apiKey" class="font-mono" />
+        <Button type="button" variant="outline" size="sm" @click="generate">Generate</Button>
+      </div>
+      <p v-if="apiKey === API_KEY_PLACEHOLDER" class="text-xs text-muted-foreground">Still the placeholder — click Generate for a real key.</p>
+    </div>
+
+    <div class="flex flex-col gap-1">
+      <label for="user-extra-groups" class="text-xs font-medium text-muted-foreground">Additional groups (comma-separated, optional)</label>
+      <Input id="user-extra-groups" v-model="extraGroupsRaw" placeholder="friends" />
+    </div>
+
+    <div class="grid grid-cols-1 gap-3 sm:grid-cols-2">
+      <div class="flex flex-col gap-1">
+        <label for="user-providers" class="text-xs font-medium text-muted-foreground">Personal grant: providers (optional)</label>
+        <Input id="user-providers" v-model="providersRaw" placeholder="gx10" />
+      </div>
+      <div class="flex flex-col gap-1">
+        <label for="user-models" class="text-xs font-medium text-muted-foreground">Personal grant: models (optional)</label>
+        <Input id="user-models" v-model="modelsRaw" placeholder="gx10/current" />
+      </div>
+    </div>
+
+    <label class="flex items-center gap-2 text-sm">
+      <input v-model="admin" type="checkbox" class="size-4 rounded border-input" />
+      Admin (full access to /admin/api/*)
+    </label>
+
+    <Alert v-if="grantError" variant="destructive">
+      <AlertDescription>{{ grantError }}</AlertDescription>
+    </Alert>
+
+    <SnippetBlock v-if="snippet" label="Add as a new line in users.json" :text="snippet" />
+    <p v-else class="text-sm text-muted-foreground">Fill in a name, group, and a real (generated) API key to build a snippet.</p>
+  </div>
+</template>
diff --git a/webui/src/composables/useHashState.ts b/webui/src/composables/useHashState.ts
index 96384a2..9674ea4 100644
--- a/webui/src/composables/useHashState.ts
+++ b/webui/src/composables/useHashState.ts
@@ -1,148 +1,97 @@
 import { computed, onMounted, onUnmounted, watch } from 'vue'
 
-import {
-  buildHash,
-  parseChartsParams,
-  parseEventsParams,
-  parseHashState,
-  parseUsageParams,
-} from '@/lib/hash-state'
-import { useEventsStore } from '@/stores/events'
-import { useHistoryStore } from '@/stores/history'
+import { buildHash, parseGlobalParams, parseHashState, parsePageParams } from '@/lib/hash-state'
+import { DEFAULT_CMP, DEFAULT_RANGE } from '@/lib/range'
+import { DEFAULT_SCOPE, useFiltersStore } from '@/stores/filters'
 import { useNavStore } from '@/stores/nav'
-import type { ChartTab, ModelMetric } from '@/stores/history'
-import type { HistoryWindow } from '@/types/api'
-
-/** The five defaults every per-tab param omits from the built hash when the field is already at its default value (buildHash's own "caller decides what's default" contract, lib/hash-state.ts). */
-const DEFAULT_WINDOW: HistoryWindow = 'hour'
-const DEFAULT_CHART_TAB: ChartTab = 'requests'
-/**
- * DEFAULT_METRIC mirrors stores/history.ts's own initial `modelMetric`
- * state (free-models-plan.md: 'req', not 'cost' — a cost-default ranking
- * hides every free model). An omitted `metric` hash param, or one this
- * build does not recognize (parseChartsParams' own independent-field
- * validation, lib/hash-state.ts), falls back to this value here; an
- * explicit `metric=cost` in the hash still parses and applies normally.
- */
-const DEFAULT_METRIC: ModelMetric = 'req'
-const DEFAULT_SCOPE = 'total'
-const DEFAULT_MODEL_FILTER = ''
 
 /**
- * useHashState (F9, dashboard-plan.md) is the single composable that keeps
- * the URL hash and every store it names in sync, both ways:
+ * useHashState (redesign-plan.md section 3.1) is the single composable
+ * that keeps the URL hash and the two shell stores it drives — stores/
+ * filters.ts (range/cmp/scope) and stores/nav.ts (page/params) — in sync,
+ * both ways:
  *
- * - On creation, it parses the CURRENT hash exactly once and applies it to
- *   stores/nav.ts (activeTab, usageQuery), stores/history.ts (Charts'
- *   scope/window/tab/modelMetric/modelFilter), and stores/events.ts (kindFilter/
- *   userFilter) — "on load: read hash -> restore state" for all three, not
- *   just the active tab the old useTabHash() composable covered.
- * - A single computed re-derives the hash from whichever store the
- *   CURRENT nav.activeTab reads from, and writes it back via
- *   history.replaceState whenever it changes — never pushState (one
- *   browser-history entry per admin session, not per click) and never a
- *   bare `location.hash =` assignment (which would also jump scroll
- *   position to any element whose id happens to match).
+ * - On creation, it parses the CURRENT hash exactly once and applies it:
+ *   the three global filters to filters.setFilters, and the page plus
+ *   its own opaque param record to nav.goTo. Every per-page STORE
+ *   (spend/consumers/models/reliability, each owned by its own work
+ *   package) is responsible for reading nav.params itself when its page
+ *   mounts — this composable never touches a page-specific store, by
+ *   design (stores/nav.ts's own doc comment).
+ * - A single computed re-derives the hash from filters' current state
+ *   plus nav.page/nav.params, and writes it back via history.
+ *   replaceState whenever it changes — never pushState (one browser-
+ *   history entry per admin session, not per click) and never a bare
+ *   `location.hash =` assignment (which would also jump scroll position
+ *   to any element whose id happens to match).
  * - It listens for the browser's own `hashchange` event (back/forward
  *   navigation, or a hand-edited URL) and re-parses from scratch,
  *   reapplying the same restore path as the initial read.
  *
  * MUST be called from App.vue's setup, before the `v-if="!auth.
- * isAuthenticated"` branch (dashboard-plan.md's own Risks section:
- * "load-with-hash-then-authenticate") — every store action this touches
- * (history.setScope, etc.) is safe to call before a key is stored (each
- * one's own fetch no-ops on an unauthenticated auth store), so the hash's
- * selection is captured immediately and is already in place the moment
- * the reader authenticates, rather than being lost because this composable
- * was never constructed while the AuthGate was showing.
+ * isAuthenticated"` branch — filters.setFilters/nav.goTo are plain
+ * synchronous state writes, safe to call before an admin key is stored,
+ * so the hash's selection is already restored by the time the reader
+ * authenticates.
  *
  * Guarded for a `window`-less environment (vitest's node test
- * environment, vite.config.ts) the same way useTabHash's old
- * implementation was: every DOM/history/location access sits behind one
- * hasWindow check computed once. Being a real Vue lifecycle-hook user
- * (onMounted/onUnmounted) exercised through App.vue in the real browser,
- * not unit-tested directly — lib/hash-state.ts's own pure functions are
- * what hash-state.spec.ts covers.
+ * environment, vite.config.ts): every DOM/history/location access sits
+ * behind one hasWindow check computed once. Exercised through App.vue in
+ * the real browser, not unit-tested directly — lib/hash-state.ts's own
+ * pure functions are what hash-state.spec.ts covers.
  */
 export function useHashState(): void {
+  const filters = useFiltersStore()
   const nav = useNavStore()
-  const history = useHistoryStore()
-  const events = useEventsStore()
 
   function applyFromHash(hash: string): void {
-    const { tab, query } = parseHashState(hash)
-    nav.activeTab = tab
-    if (tab === 'charts') {
-      // P7 review fix: this used to apply ONLY the params present in the
-      // hash, so a PARTIAL Charts hash on hashchange (back/forward
-      // navigation, or the reader hand-editing the URL down to a bare
-      // "#charts") left every OMITTED field exactly as it was — buildHash
-      // itself treats an omitted param as "use the default" (its own doc
-      // comment), but this restore path never actually reset anything to
-      // that default, so the address bar and the rendered chart silently
-      // disagreed. Every field is now applied on EVERY call — explicitly
-      // falling back to its own default when the hash omits it — so a
-      // partial or bare hash genuinely resets whatever it doesn't name —
-      // including `filter` (P7 review follow-up): the Models tab's
-      // provider-prefix filter is a hash param now (lib/hash-state.ts's
-      // ChartsHashParams.filter), so it falls back to
-      // DEFAULT_MODEL_FILTER exactly like every other field here, rather
-      // than being left over from whatever the store already had.
-      //
-      // P12 review fix: applied through ONE history.setSelection() call
-      // (batches the state writes and fires exactly one refresh(), plus
-      // one fetchModelOptions() only when window is part of the change)
-      // instead of up to four separate setWindow/setTab/setModelMetric/
-      // setScope calls, each of which used to fire its OWN refresh() —
-      // every fetch but the last immediately discarded.
-      const p = parseChartsParams(query)
-      history.setSelection({
-        window: p.window ?? DEFAULT_WINDOW,
-        tab: p.tab ?? DEFAULT_CHART_TAB,
-        modelMetric: p.metric ?? DEFAULT_METRIC,
-        scope: p.scope ?? DEFAULT_SCOPE,
-        modelFilter: p.filter ?? DEFAULT_MODEL_FILTER,
-      })
-    } else if (tab === 'usage') {
-      const p = parseUsageParams(query)
-      nav.usageQuery = p.q ?? ''
-    } else if (tab === 'events') {
-      const p = parseEventsParams(query)
-      events.setKindFilter(p.kind ?? '')
-      events.setUserFilter(p.user ?? '')
-    }
+    const { page, query } = parseHashState(hash)
+    const globals = parseGlobalParams(query)
+    filters.setFilters({
+      range: globals.range ?? DEFAULT_RANGE,
+      cmp: globals.cmp ?? DEFAULT_CMP,
+      scope: globals.scope ?? DEFAULT_SCOPE,
+    })
+    nav.goTo(page, parsePageParams(query))
   }
 
   const hasWindow = typeof window !== 'undefined'
   if (hasWindow) applyFromHash(window.location.hash)
 
   const currentHash = computed<string>(() => {
-    if (nav.activeTab === 'charts') {
-      const params: Record<string, string> = {}
-      if (history.window !== DEFAULT_WINDOW) params.window = history.window
-      if (history.tab !== DEFAULT_CHART_TAB) params.tab = history.tab
-      if (history.modelMetric !== DEFAULT_METRIC) params.metric = history.modelMetric
-      if (history.scope !== DEFAULT_SCOPE) params.scope = history.scope
-      if (history.modelFilter !== DEFAULT_MODEL_FILTER) params.filter = history.modelFilter
-      return buildHash(nav.activeTab, params)
-    }
-    if (nav.activeTab === 'usage') {
-      return buildHash(nav.activeTab, nav.usageQuery ? { q: nav.usageQuery } : {})
-    }
-    if (nav.activeTab === 'events') {
-      const params: Record<string, string> = {}
-      if (events.kindFilter) params.kind = events.kindFilter
-      if (events.userFilter) params.user = events.userFilter
-      return buildHash(nav.activeTab, params)
-    }
-    return buildHash(nav.activeTab, {})
+    const params: Record<string, string> = {}
+    if (filters.range !== DEFAULT_RANGE) params.range = filters.range
+    if (filters.cmp !== DEFAULT_CMP) params.cmp = filters.cmp
+    if (filters.scope !== DEFAULT_SCOPE) params.scope = filters.scope
+    // Page params are merged in AFTER the three global keys, so the
+    // built query string always lists range/cmp/scope first — readable,
+    // and matches redesign-plan.md section 3.1's own example ordering.
+    // No current page uses a param named range/cmp/scope (see stores/
+    // nav.ts's own doc comment on `params` staying opaque), so this
+    // merge never actually overwrites one of the three above in
+    // practice; it is a plain Object.assign, not a defensive filter.
+    Object.assign(params, nav.params)
+    return buildHash(nav.page, params)
   })
 
-  watch(currentHash, (hash) => {
-    if (!hasWindow) return
-    if (window.location.hash === hash) return
-    window.history.replaceState(null, '', hash)
-  })
+  // `immediate: true` (P3 item 24): applyFromHash already normalized
+  // filters/nav state from window.location.hash above, synchronously,
+  // before this watch is even registered — so currentHash's FIRST
+  // computed value is already the canonical hash for whatever the reader
+  // arrived with. Without `immediate`, that first value is never written
+  // back until some LATER state change happens to fire the watch, so a
+  // legacy or garbage hash (`#charts`, `#nope?range=30d`) stayed in the
+  // address bar — correct app state, stale URL — until the reader
+  // happened to touch a filter.
+  watch(
+    currentHash,
+    (hash) => {
+      if (!hasWindow) return
+      if (window.location.hash === hash) return
+      window.history.replaceState(null, '', hash)
+    },
+    { immediate: true },
+  )
 
   function onHashChange(): void {
     applyFromHash(window.location.hash)
diff --git a/webui/src/composables/useNow.ts b/webui/src/composables/useNow.ts
index 98d986d..5d4f7a0 100644
--- a/webui/src/composables/useNow.ts
+++ b/webui/src/composables/useNow.ts
@@ -11,7 +11,7 @@ import { createVisibilityPoller, type VisibilityPoller } from '@/lib/polling'
 const NOW_TICK_MS = 60_000
 
 export interface UseNow {
-  /** The shared clock — every time-dependent read on the Usage tab (CostForecastCard's elapsedFraction, usageColumns()'s own `now` parameter, UsageView.vue's groupCostProjection) reads THIS ref, never its own `new Date()`. */
+  /** The shared clock — every time-dependent read on the Consumers page (CostForecastCard's elapsedFraction, usageColumns()'s own `now` parameter, ConsumerDirectory.vue's groupCostProjection, UserDetail.vue's runOutDate) reads THIS ref, never its own `new Date()`. */
   now: Ref<Date>
   /** Idempotent, mirrors createVisibilityPoller's own start() — call from the owning component's onMounted. */
   start: () => void
@@ -20,9 +20,12 @@ export interface UseNow {
 }
 
 /**
- * useNow (P1) is the ONE reactive clock every time-dependent read on the
- * Usage tab shares, instead of each freezing its own `new Date()` at mount
- * or re-deriving a fresh one on every render:
+ * useNow (P1) is the ONE reactive clock every time-dependent read across
+ * the admin UI shares (today: SpendPage.vue's cost forecast, UserDetail.vue's
+ * run-out date, ConsumerDirectory.vue's group cost projection — see this
+ * file's own UseNow doc comment for the full current-caller list), instead
+ * of each freezing its own `new Date()` at mount or re-deriving a fresh one
+ * on every render:
  *
  * - CostForecastCard.vue used `withDefaults(..., { now: () => new Date() })`
  *   — Vue caches a prop's default once per component instance
@@ -30,12 +33,14 @@ export interface UseNow {
  *   instant the card happened to mount, never advancing again.
  * - usage-columns.ts's usageColumns() takes `now` as a plain parameter,
  *   evaluated once per call — UsageTable.vue's `computed(() =>
- *   usageColumns(...))` and UsageView.vue's headless Groups toolbar
- *   columns both called it with no reactive dependency on the current
- *   time, so neither ever recomputed either.
- * - UsageView.vue's groupCostProjection called `new Date()` fresh on every
- *   invocation instead, so the group grid could disagree with the above
- *   two on what "now" even was, mid-render.
+ *   usageColumns(...))` and the pre-redesign Usage tab's own headless
+ *   Groups toolbar columns (UsageView.vue, deleted) both called it with no
+ *   reactive dependency on the current time, so neither ever recomputed
+ *   either.
+ * - The pre-redesign Usage tab's own groupCostProjection (UsageView.vue,
+ *   deleted) called `new Date()` fresh on every invocation instead, so the
+ *   group grid could disagree with the above two on what "now" even was,
+ *   mid-render.
  *
  * Driven by the shared createVisibilityPoller (lib/polling.ts — the same
  * primitive every store's own poll timer uses): ticks once immediately on
@@ -43,11 +48,13 @@ export interface UseNow {
  * hidden and catching up the moment it is looked at again (and, per P13,
  * never ticking at all if started while already hidden).
  *
- * This composable does NOT call onMounted/onUnmounted itself — the caller
- * (UsageView.vue) owns its lifecycle explicitly via the returned start/stop,
- * the same reason lib/polling.ts itself takes no lifecycle-hook dependency:
- * it keeps this composable callable, and testable, outside a mounted
- * component.
+ * This composable does NOT call onMounted/onUnmounted itself — each of its
+ * three current callers (SpendPage.vue, UserDetail.vue,
+ * ConsumerDirectory.vue) owns its OWN clock instance's lifecycle
+ * explicitly via the returned start/stop (`onMounted(startClock)` /
+ * `onUnmounted(stopClock)`), the same reason lib/polling.ts itself takes
+ * no lifecycle-hook dependency: it keeps this composable callable, and
+ * testable, outside a mounted component.
  */
 export function useNow(intervalMs = NOW_TICK_MS): UseNow {
   const now = ref(new Date())
diff --git a/webui/src/composables/useSearchQuery.spec.ts b/webui/src/composables/useSearchQuery.spec.ts
index 13b8237..011ca4f 100644
--- a/webui/src/composables/useSearchQuery.spec.ts
+++ b/webui/src/composables/useSearchQuery.spec.ts
@@ -24,8 +24,10 @@ describe('useSearchQuery', () => {
 
   // F9 (hash-state): a caller can supply the ref this composable reads and
   // writes instead of a private local one, so the query round-trips
-  // through an external owner (nav.usageQuery, UsageView.vue) rather than
-  // being lost on remount.
+  // through an external owner (e.g. ConsumerDirectory.vue's own
+  // `nav.params.q`-backed computed, or EventsView.vue's store-backed
+  // `userFilter` — useSearchQuery.ts's own doc comment) rather than being
+  // lost on remount.
   describe('with an external ref', () => {
     it('reads and derives from the external ref\'s current value, rather than starting blank', () => {
       const external = ref('preset')
diff --git a/webui/src/composables/useSearchQuery.ts b/webui/src/composables/useSearchQuery.ts
index de3dc07..485c6fb 100644
--- a/webui/src/composables/useSearchQuery.ts
+++ b/webui/src/composables/useSearchQuery.ts
@@ -3,14 +3,15 @@ import { computed, ref } from 'vue'
 
 /**
  * useSearchQuery is the one raw-query → {normalized, hasQuery} adapter
- * every search filter in this panel uses — ProvidersView's model search,
- * UsageView's user/group search, ChartsView's scope-picker search all had
- * their own copy of this identical query/normalizedQuery/hasQuery
- * pairing; extracted so it exists once (vue.md: "if you've written it
- * twice, you owe an abstraction"). Callers still own their own matching
- * logic entirely (ProvidersView's modelMatches/providerMatches,
- * lib/usage-search.ts's helpers) — this only normalizes the raw input the
- * same way every call site already agreed on: trimmed, lowercased.
+ * every search filter in this panel uses — ProviderHealthPanel's
+ * model/provider search, ConsumerDirectory's user/group search
+ * (lib/usage-search.ts), EventsView's user/group filter, TargetsView's
+ * target search, each with its own matching logic but the identical
+ * query/normalizedQuery/hasQuery pairing; extracted so it exists once
+ * (vue.md: "if you've written it twice, you owe an abstraction"). Callers
+ * still own their own matching logic entirely — this only normalizes the
+ * raw input the same way every call site already agreed on: trimmed,
+ * lowercased.
  *
  * No `clear()` here — clearing is just setting `query.value = ''`, and
  * every caller already gets that for free from SearchInput.vue's own
@@ -19,14 +20,19 @@ import { computed, ref } from 'vue'
  * caller needs.
  *
  * `external` (F9, hash-state) lets a caller supply the ref this composable
- * reads and writes instead of owning a private local one — UsageView.vue
- * binds `nav.usageQuery` (stores/nav.ts) so the Usage tab's own search
- * text round-trips through the URL hash (lib/hash-state.ts's `q` param)
- * the same way ChartsView's scope/window/tab selection already does.
- * Every OTHER caller (ProvidersView, ChartsView's own scope-picker search,
- * EventsView) omits it and keeps its private, hash-independent ref exactly
- * as before — passing `external` changes nothing about `normalized`/
- * `hasQuery`'s own derivation, only where the raw value itself lives.
+ * reads and writes instead of owning a private local one, so that ref's
+ * own search text round-trips through the URL hash. Two current callers
+ * pass it: ConsumerDirectory.vue binds a local `computed` get/set over
+ * `nav.params.q` directly (stores/nav.ts's own `params` is opaque, so the
+ * page owns interpreting/writing its own `q` key — see that computed's
+ * own doc comment for why this replaced an earlier, page-specific
+ * `nav.usageQuery` special case), and EventsView.vue binds
+ * `storeToRefs(events).userFilter`, which composables/useHashState.ts
+ * reads/writes directly against the same hash. Every OTHER caller
+ * (ProviderHealthPanel's model/provider search, TargetsView's target
+ * search) omits it and keeps its private, hash-independent ref instead —
+ * passing `external` changes nothing about `normalized`/`hasQuery`'s own
+ * derivation, only where the raw value itself lives.
  */
 export function useSearchQuery(external?: Ref<string>) {
   const query = external ?? ref('')
diff --git a/webui/src/composables/useTabHash.spec.ts b/webui/src/composables/useTabHash.spec.ts
deleted file mode 100644
index ab76a85..0000000
--- a/webui/src/composables/useTabHash.spec.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { hashToTab, tabToHash } from './useTabHash'
-
-const TAB_VALUES = ['providers', 'usage', 'charts', 'targets'] as const
-
-describe('hashToTab', () => {
-  it('maps a recognized hash (with leading #) to its tab value', () => {
-    expect(hashToTab('#usage', TAB_VALUES, 'providers')).toBe('usage')
-  })
-
-  it('maps a recognized hash without a leading # too (defensive: a caller might pass window.location.hash.slice(1) already)', () => {
-    expect(hashToTab('charts', TAB_VALUES, 'providers')).toBe('charts')
-  })
-
-  it('falls back to defaultTab for an empty hash (absent, load with no hash at all)', () => {
-    expect(hashToTab('', TAB_VALUES, 'providers')).toBe('providers')
-  })
-
-  it('falls back to defaultTab for a bare "#" (empty fragment)', () => {
-    expect(hashToTab('#', TAB_VALUES, 'providers')).toBe('providers')
-  })
-
-  it('falls back to defaultTab for an unrecognized hash (hand-edited URL)', () => {
-    expect(hashToTab('#nonexistent-tab', TAB_VALUES, 'providers')).toBe('providers')
-  })
-
-  it('is case-sensitive: a differently-cased match still falls back to defaultTab', () => {
-    expect(hashToTab('#Providers', TAB_VALUES, 'providers')).toBe('providers')
-  })
-
-  it('every valid tab round-trips to itself', () => {
-    for (const tab of TAB_VALUES) {
-      expect(hashToTab(`#${tab}`, TAB_VALUES, 'providers')).toBe(tab)
-    }
-  })
-})
-
-describe('tabToHash', () => {
-  it('prefixes the tab value with "#"', () => {
-    expect(tabToHash('targets')).toBe('#targets')
-  })
-
-  it('round-trips through hashToTab back to the same tab', () => {
-    for (const tab of TAB_VALUES) {
-      expect(hashToTab(tabToHash(tab), TAB_VALUES, 'providers')).toBe(tab)
-    }
-  })
-})
diff --git a/webui/src/composables/useTabHash.ts b/webui/src/composables/useTabHash.ts
deleted file mode 100644
index f5edc89..0000000
--- a/webui/src/composables/useTabHash.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-// Feature C (v0.22) introduced hashToTab/tabToHash below, plus a
-// useTabHash() composable wrapping them. F9 (dashboard-plan.md) supersedes
-// that composable with useHashState() (composables/useHashState.ts):
-// App.vue now needs a single hash that carries BOTH the active tab AND
-// each tab's own query-string state (scope/window/tab/metric for Charts, q
-// for Usage, kind/user for Events — lib/hash-state.ts), not the tab alone,
-// so useTabHash() itself was removed as the now-superseded, unreachable
-// half of this file. hashToTab/tabToHash stay: useHashState.ts still
-// builds the OUTER "#<tab>" portion of the combined hash directly on top
-// of these same two pure functions, and this module's own spec exercises
-// them directly (vite.config.ts's `test` block runs in a Node environment
-// — no `window`, no component mount).
-//
-// TAB_VALUES/TabValue also live here — the single source of truth for the
-// app's tab union (vue.md: "share types once, import everywhere"):
-// stores/nav.ts's `activeTab`, composables/useHashState.ts, and App.vue's
-// own Tabs all import the SAME union rather than each redeclaring it.
-export const TAB_VALUES = ['providers', 'usage', 'charts', 'targets', 'events'] as const
-export type TabValue = (typeof TAB_VALUES)[number]
-
-/**
- * hashToTab maps a raw location.hash string (with or without its leading
- * "#") to one of validTabs. An absent, empty, or unrecognized hash
- * returns defaultTab — never throws, and never returns a value outside
- * validTabs. Matching is a plain string comparison: a tab value is
- * already a fixed lowercase identifier (App.vue's TabsTrigger value=
- * strings), never re-cased anywhere in this pipeline.
- *
- * Two intentional URL-normalization quirks (folded review minors, v0.22
- * review round), both worth naming rather than leaving implicit:
- *
- * 1. Case sensitivity: "#Providers" does NOT match "providers" — it falls
- *    back to defaultTab like any other unrecognized hash, rather than
- *    being normalized case-insensitively. A URL a person typed or edited
- *    by hand with different casing is treated as invalid, not corrected.
- * 2. An invalid or absent hash is normalized only in memory (this
- *    function's own return value), never in the address bar itself:
- *    useHashState's initial read (composables/useHashState.ts) never
- *    calls history.replaceState on its own — only a LATER state change
- *    does (see its own doc comment) — so loading "#bogus" shows the
- *    Providers tab while the address bar still reads "#bogus" until the
- *    reader switches tabs, or something else changes, at least once.
- */
-export function hashToTab<T extends string>(hash: string, validTabs: readonly T[], defaultTab: T): T {
-  const raw = hash.startsWith('#') ? hash.slice(1) : hash
-  return (validTabs as readonly string[]).includes(raw) ? (raw as T) : defaultTab
-}
-
-/** tabToHash is hashToTab's inverse: the URL hash (leading "#" included) one tab value maps to. */
-export function tabToHash(tab: string): string {
-  return `#${tab}`
-}
diff --git a/webui/src/lib/access-matrix.spec.ts b/webui/src/lib/access-matrix.spec.ts
new file mode 100644
index 0000000..4fb4560
--- /dev/null
+++ b/webui/src/lib/access-matrix.spec.ts
@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'vitest'
+
+import { buildAccessMatrix, providerAccessCell, targetAccessCell } from './access-matrix'
+import type { AdminConsumerGroup, AdminTargetView } from '@/types/api'
+
+function group(overrides: Partial<AdminConsumerGroup> = {}): AdminConsumerGroup {
+  return {
+    name: 'friends',
+    allowedProviders: [],
+    modelAccess: {},
+    memberCount: 3,
+    ...overrides,
+  }
+}
+
+function target(overrides: Partial<AdminTargetView> = {}): AdminTargetView {
+  return {
+    name: 'fetch',
+    url: 'http://mcp-fetch/mcp',
+    counters: { requestsPerMinute: 0, requestsPerDay: 0, requestsPerMonth: 0 },
+    health: { state: 'unknown', consecutiveFailures: 0 },
+    ...overrides,
+  }
+}
+
+describe('providerAccessCell', () => {
+  it('not allowed when the provider is absent from allowedProviders', () => {
+    const g = group({ allowedProviders: ['minimax'] })
+    expect(providerAccessCell(g, 'uni')).toEqual({ allowed: false })
+  })
+
+  it('allowed with a "n/m models" detail when modelAccess has an entry', () => {
+    const g = group({ allowedProviders: ['minimax'], modelAccess: { minimax: { allowed: 2, total: 5 } } })
+    expect(providerAccessCell(g, 'minimax')).toEqual({ allowed: true, detail: '2/5 models' })
+  })
+
+  it('allowed with no detail when modelAccess has no entry for this provider', () => {
+    const g = group({ allowedProviders: ['minimax'], modelAccess: {} })
+    expect(providerAccessCell(g, 'minimax')).toEqual({ allowed: true, detail: undefined })
+  })
+
+  // P3 item 18: allowed but 0 of the provider's models are reachable
+  // (a `models` glob matching none of it) must NOT render identically to
+  // an ordinary, genuinely-unrestricted allowed cell.
+  it('sets zero: true when the provider is allowed but 0 of its models are reachable', () => {
+    const g = group({ allowedProviders: ['minimax'], modelAccess: { minimax: { allowed: 0, total: 5 } } })
+    expect(providerAccessCell(g, 'minimax')).toEqual({ allowed: true, detail: '0/5 models', zero: true })
+  })
+
+  it('does NOT set zero when the provider itself has 0 total models (unrelated to the grant)', () => {
+    const g = group({ allowedProviders: ['minimax'], modelAccess: { minimax: { allowed: 0, total: 0 } } })
+    expect(providerAccessCell(g, 'minimax')).toEqual({ allowed: true, detail: '0/0 models' })
+  })
+})
+
+describe('targetAccessCell', () => {
+  it('allowed for every group when access is undefined (unrestricted)', () => {
+    expect(targetAccessCell(group({ name: 'friends' }), target({ access: undefined }))).toEqual({ allowed: true })
+  })
+
+  it('allowed for every group when access is null (unrestricted)', () => {
+    expect(targetAccessCell(group({ name: 'friends' }), target({ access: null }))).toEqual({ allowed: true })
+  })
+
+  it('not allowed for any group when access is an empty array', () => {
+    expect(targetAccessCell(group({ name: 'friends' }), target({ access: [] }))).toEqual({ allowed: false })
+  })
+
+  it('allowed only for a named group', () => {
+    expect(targetAccessCell(group({ name: 'friends' }), target({ access: ['friends'] }))).toEqual({ allowed: true })
+    expect(targetAccessCell(group({ name: 'home' }), target({ access: ['friends'] }))).toEqual({ allowed: false })
+  })
+})
+
+describe('buildAccessMatrix', () => {
+  it('builds one row per group, keyed by column name', () => {
+    const groups = [
+      group({ name: 'home', allowedProviders: ['anthropic', 'openai'], modelAccess: { anthropic: { allowed: 5, total: 5 } } }),
+      group({ name: 'friends', allowedProviders: ['minimax'] }),
+    ]
+    const mcp = [target({ name: 'fetch', access: undefined }), target({ name: 'weather', access: ['home'] })]
+    const agents = [target({ name: 'agentkit', access: [] })]
+    const rows = buildAccessMatrix(groups, ['anthropic', 'openai', 'minimax'], mcp, agents)
+
+    expect(rows).toHaveLength(2)
+    expect(rows[0].group).toBe('home')
+    expect(rows[0].providers.anthropic).toEqual({ allowed: true, detail: '5/5 models' })
+    expect(rows[0].providers.openai).toEqual({ allowed: true, detail: undefined })
+    expect(rows[0].providers.minimax).toEqual({ allowed: false })
+    expect(rows[0].mcpServers.fetch).toEqual({ allowed: true })
+    expect(rows[0].mcpServers.weather).toEqual({ allowed: true })
+    expect(rows[0].agents.agentkit).toEqual({ allowed: false })
+
+    expect(rows[1].group).toBe('friends')
+    expect(rows[1].mcpServers.weather).toEqual({ allowed: false })
+  })
+
+  it('returns an empty array for no groups', () => {
+    expect(buildAccessMatrix([], ['anthropic'], [], [])).toEqual([])
+  })
+})
diff --git a/webui/src/lib/access-matrix.ts b/webui/src/lib/access-matrix.ts
new file mode 100644
index 0000000..99c0b5b
--- /dev/null
+++ b/webui/src/lib/access-matrix.ts
@@ -0,0 +1,94 @@
+// AccessMatrix.vue (redesign-plan.md section 3.4): pure matrix-building
+// logic — rows are groups, columns are providers (an allowed check plus
+// "n/m models") and every configured MCP server/agent target. Kept out of
+// the component the same way every other pure data-shaping helper in this
+// panel is (lib/usage-bars.ts, lib/forecast.ts) — vitest's node-environment
+// config exercises it directly, no component mount required.
+import type { AdminConsumerGroup, AdminTargetView } from '@/types/api'
+
+/**
+ * AccessCell is one matrix cell's reading: whether the group can reach
+ * this provider/target at all, plus an optional human-readable detail (a
+ * provider cell's "n/m models"; a target cell has none). `zero` (P3 item
+ * 18) marks a provider cell where the provider itself is allowed but the
+ * group's own model grant resolves to 0 of the provider's models — e.g.
+ * a `models` glob that happens to match nothing this provider currently
+ * serves — distinct from an ordinary allowed cell (0 usable models is
+ * not the same reading as "unrestricted access", even though both would
+ * otherwise render an identical green check).
+ */
+export interface AccessCell {
+  allowed: boolean
+  detail?: string
+  zero?: boolean
+}
+
+/**
+ * providerAccessCell reads a group's resolved provider access (admin.go:
+ * adminConsumerGroup.AllowedProviders — never nil, already glob-matched
+ * server-side, so this is a plain membership check, not a re-implementation
+ * of path.Match) plus its per-provider model count (modelAccess, "n/m
+ * models") when the provider is allowed at all. A provider absent from
+ * modelAccess (the group is allowed the provider but the server reported no
+ * model breakdown for it — should not happen in practice, but the type
+ * itself is a plain Record with no guaranteed key) renders `allowed: true`
+ * with no detail, rather than a fabricated "0/0 models". `zero` is set only
+ * when the provider genuinely serves models (`total > 0`) but the group's
+ * grant reaches none of them (`allowed === 0`) — a `total` of 0 (a
+ * provider with no discovered models at all) is a different, unrelated
+ * situation and does not trip it.
+ */
+export function providerAccessCell(group: AdminConsumerGroup, providerName: string): AccessCell {
+  if (!group.allowedProviders.includes(providerName)) return { allowed: false }
+  const access = group.modelAccess[providerName]
+  if (!access) return { allowed: true }
+  // `zero` follows this module's own "undefined means unset" convention
+  // (every other optional AccessCell/BudgetRatio-style field in this
+  // panel) — omitted (never a literal `false`) so the ordinary allowed
+  // case's shape stays exactly `{ allowed, detail }`.
+  const zero = access.allowed === 0 && access.total > 0 ? true : undefined
+  return { allowed: true, detail: `${access.allowed}/${access.total} models`, zero }
+}
+
+/**
+ * targetAccessCell reads a group's access to one MCP server/agent target
+ * from that target's OWN `access` field (admin.go: adminTargetView.Access —
+ * types/api.ts's own doc comment): `null`/`undefined` means every
+ * configured group can reach it, `[]` means none can, a non-empty list
+ * names the groups that can. No detail (unlike a provider cell) — a
+ * target has no "n/m" breakdown, only reachable or not.
+ */
+export function targetAccessCell(group: AdminConsumerGroup, target: Pick<AdminTargetView, 'name' | 'access'>): AccessCell {
+  if (target.access === undefined || target.access === null) return { allowed: true }
+  return { allowed: target.access.includes(group.name) }
+}
+
+/** AccessMatrixRow is one group's full row: its own provider/MCP-server/agent cells, each keyed by that column's own name — AccessMatrix.vue iterates `providerNames`/`mcpServers`/`agents` (the caller's own column order) and looks up each cell by name rather than relying on object key iteration order. */
+export interface AccessMatrixRow {
+  group: string
+  providers: Record<string, AccessCell>
+  mcpServers: Record<string, AccessCell>
+  agents: Record<string, AccessCell>
+}
+
+/**
+ * buildAccessMatrix builds one row per group, over the given provider
+ * names and MCP-server/agent target lists — the caller (AccessMatrix.vue)
+ * supplies the column universe (every configured provider name from GET
+ * /admin/api/overview; every target from GET /admin/api/targets) so this
+ * function stays a pure join, with no fetching or ordering opinion of
+ * its own.
+ */
+export function buildAccessMatrix(
+  groups: AdminConsumerGroup[],
+  providerNames: string[],
+  mcpServers: AdminTargetView[],
+  agents: AdminTargetView[],
+): AccessMatrixRow[] {
+  return groups.map((group) => ({
+    group: group.name,
+    providers: Object.fromEntries(providerNames.map((name) => [name, providerAccessCell(group, name)])),
+    mcpServers: Object.fromEntries(mcpServers.map((target) => [target.name, targetAccessCell(group, target)])),
+    agents: Object.fromEntries(agents.map((target) => [target.name, targetAccessCell(group, target)])),
+  }))
+}
diff --git a/webui/src/lib/burndown.spec.ts b/webui/src/lib/burndown.spec.ts
new file mode 100644
index 0000000..9f80dc0
--- /dev/null
+++ b/webui/src/lib/burndown.spec.ts
@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest'
+
+import { cumulative, currentMonthDaySpan, MIN_ELAPSED_DAYS, runOutDate } from './burndown'
+
+describe('currentMonthDaySpan', () => {
+  it('returns the UTC day-of-month', () => {
+    expect(currentMonthDaySpan(new Date(Date.UTC(2026, 8, 23, 12, 0, 0)))).toBe(23)
+  })
+
+  it('returns 1 on the first day of the month', () => {
+    expect(currentMonthDaySpan(new Date(Date.UTC(2026, 8, 1, 0, 0, 0)))).toBe(1)
+  })
+})
+
+describe('cumulative', () => {
+  it('returns a running total, oldest first', () => {
+    expect(cumulative([1, 2, 3])).toEqual([1, 3, 6])
+  })
+
+  it('returns an empty array for empty input', () => {
+    expect(cumulative([])).toEqual([])
+  })
+
+  it('handles a single point', () => {
+    expect(cumulative([5])).toEqual([5])
+  })
+})
+
+describe('runOutDate', () => {
+  it('returns null when no budget is configured (limitMicros <= 0)', () => {
+    expect(runOutDate(1_000_000, 0, new Date(Date.UTC(2026, 3, 15)))).toBeNull()
+    expect(runOutDate(1_000_000, -10, new Date(Date.UTC(2026, 3, 15)))).toBeNull()
+  })
+
+  it('returns now itself once spend has already met or exceeded the limit', () => {
+    const now = new Date(Date.UTC(2026, 3, 15, 8, 0, 0))
+    expect(runOutDate(5_000_000, 5_000_000, now)).toEqual(now)
+    expect(runOutDate(6_000_000, 5_000_000, now)).toEqual(now)
+  })
+
+  it('returns null before MIN_ELAPSED_DAYS have elapsed in the month', () => {
+    // A few hours into day 1 — well under one full elapsed day.
+    const earlyMonth = new Date(Date.UTC(2026, 3, 1, 2, 0, 0))
+    expect(runOutDate(1000, 1_000_000, earlyMonth)).toBeNull()
+  })
+
+  it('returns null when the daily rate so far is 0 — spend has not started', () => {
+    const now = new Date(Date.UTC(2026, 3, 16, 0, 0, 0))
+    expect(runOutDate(0, 1_000_000, now)).toBeNull()
+  })
+
+  it('projects forward at the MTD average daily rate', () => {
+    // April 2026 (30 days): 15 full days elapsed, 15,000,000 micros spent
+    // -> 1,000,000 micros/day. A 20,000,000 limit has 5,000,000 remaining
+    // -> 5 more days to exhaust.
+    const now = new Date(Date.UTC(2026, 3, 16, 0, 0, 0))
+    const result = runOutDate(15_000_000, 20_000_000, now)
+    expect(result).not.toBeNull()
+    expect(result!.getTime()).toBe(now.getTime() + 5 * 24 * 60 * 60 * 1000)
+  })
+
+  it('exposes MIN_ELAPSED_DAYS as a stable, importable constant', () => {
+    expect(MIN_ELAPSED_DAYS).toBe(1)
+  })
+})
diff --git a/webui/src/lib/burndown.ts b/webui/src/lib/burndown.ts
new file mode 100644
index 0000000..b53fa04
--- /dev/null
+++ b/webui/src/lib/burndown.ts
@@ -0,0 +1,93 @@
+// Pure math behind BurnDownChart.vue (redesign-plan.md section 3.4): a
+// cumulative month-to-date spend line against a flat budget reference, and
+// the date that spend would cross the budget at the current pace. Kept out
+// of the component the same way lib/forecast.ts keeps CostForecastCard.vue's
+// own month-end projection math out of it — every function here takes `now`
+// as an explicit argument (never reads Date.now() itself), so vitest's
+// node-environment config exercises the real calendar-boundary cases
+// deterministically.
+//
+// All month-boundary math is UTC, mirroring lib/forecast.ts's own
+// monthProgress (costPerMonthMicroUsd/AdminSeriesResponse's day buckets
+// both accumulate against a UTC calendar month — limits.go's windowKey
+// "200601"/"20060102" — so projecting against the LOCAL calendar month
+// would silently misalign on the first/last day of a month in any
+// non-UTC timezone).
+import { monthProgress } from '@/lib/forecast'
+
+const MS_PER_DAY = 24 * 60 * 60 * 1000
+
+/**
+ * daysInMonthUTC returns how many days are in `now`'s own UTC calendar
+ * month (28-31) — correct for every month length, including a leap
+ * February, via the same Date.UTC month-rollover normalization
+ * monthProgress (lib/forecast.ts) already relies on, never a hardcoded
+ * days-per-month table.
+ */
+function daysInMonthUTC(now: Date): number {
+  const year = now.getUTCFullYear()
+  const month = now.getUTCMonth()
+  return (Date.UTC(year, month + 1, 1) - Date.UTC(year, month, 1)) / MS_PER_DAY
+}
+
+/**
+ * currentMonthDaySpan is how many day buckets (1..31) `now`'s own UTC
+ * calendar month has elapsed so far, INCLUDING today — the `span` the
+ * spend store requests from GET /admin/api/usage/series for the burn-down
+ * line (redesign-plan.md section 3.3: "burn-down current-month day series
+ * span=dayOfMonth"), so a day-3-of-the-month poll asks for exactly 3
+ * buckets, never the whole month's worth of not-yet-existing future ones.
+ */
+export function currentMonthDaySpan(now: Date): number {
+  return now.getUTCDate()
+}
+
+/**
+ * cumulative turns a bucket-per-day points array (day-window
+ * AdminSeriesResponse series, oldest first) into a running total —
+ * BurnDownChart.vue's own "spend so far" line, since the series endpoint
+ * itself reports each day's OWN cost, not a running sum.
+ */
+export function cumulative(points: number[]): number[] {
+  let sum = 0
+  return points.map((p) => (sum += p))
+}
+
+/**
+ * MIN_ELAPSED_DAYS is runOutDate's own extrapolation floor, mirroring
+ * lib/forecast.ts's MIN_PROJECTION_FRACTION for the identical reason: the
+ * first day of a month is too little data for a daily-average run rate to
+ * mean anything, so runOutDate reports "not enough data yet" (null) below
+ * it rather than a wildly overstated projection from a single day's spend.
+ */
+export const MIN_ELAPSED_DAYS = 1
+
+/**
+ * runOutDate projects the date month-to-date spend would cross
+ * `limitMicros`, extrapolating from the MTD average daily rate
+ * (mtdMicros / elapsed days so far) — redesign-plan.md section 3.4:
+ * "run-out date lib/burndown.ts runOutDate(mtdMicros, limitMicros, now) at
+ * MTD average daily rate". Mirrors lib/forecast.ts's headroom() null
+ * conventions: null when there is no budget to compare against
+ * (`limitMicros <= 0`), and null when there is too little of the month
+ * elapsed to extrapolate from (MIN_ELAPSED_DAYS) or the rate so far is 0
+ * (spend has not started — "never" is not representable as a date, so
+ * this reports "no forecast" rather than a fabricated far-future one).
+ * Already-exceeded budgets return `now` itself (the run-out already
+ * happened, as of this read) rather than a nonsensical past-vs-future date
+ * from continuing the division.
+ */
+export function runOutDate(mtdMicros: number, limitMicros: number, now: Date): Date | null {
+  if (limitMicros <= 0) return null
+  if (mtdMicros >= limitMicros) return new Date(now.getTime())
+
+  const elapsedDays = monthProgress(now) * daysInMonthUTC(now)
+  if (elapsedDays < MIN_ELAPSED_DAYS) return null
+
+  const dailyRateMicros = mtdMicros / elapsedDays
+  if (dailyRateMicros <= 0) return null
+
+  const remainingMicros = limitMicros - mtdMicros
+  const daysToExhaust = remainingMicros / dailyRateMicros
+  return new Date(now.getTime() + daysToExhaust * MS_PER_DAY)
+}
diff --git a/webui/src/lib/cache-savings.spec.ts b/webui/src/lib/cache-savings.spec.ts
new file mode 100644
index 0000000..c6f902d
--- /dev/null
+++ b/webui/src/lib/cache-savings.spec.ts
@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import { cacheSavingsStatus } from './cache-savings'
+
+describe('cacheSavingsStatus (N2)', () => {
+  it('is unavailable for an hour window, with a reason naming the granularity, not a fabricated $0', () => {
+    const status = cacheSavingsStatus('hour')
+    expect(status.available).toBe(false)
+    expect(status.note).toMatch(/hour/i)
+  })
+
+  it('is available with no caveat for a day window (exact figure)', () => {
+    expect(cacheSavingsStatus('day')).toEqual({ available: true, note: null })
+  })
+
+  it('is available but notes the 35-day retention cap for a month window', () => {
+    const status = cacheSavingsStatus('month')
+    expect(status.available).toBe(true)
+    expect(status.note).toMatch(/35/)
+  })
+})
diff --git a/webui/src/lib/cache-savings.ts b/webui/src/lib/cache-savings.ts
new file mode 100644
index 0000000..bee10f3
--- /dev/null
+++ b/webui/src/lib/cache-savings.ts
@@ -0,0 +1,47 @@
+import type { HistoryWindow } from '@/types/api'
+
+/**
+ * CacheSavingsStatus is cacheSavingsStatus's own result: whether the
+ * requested bucket window can report a cache-savings figure at all, and
+ * any caveat text worth showing alongside a figure that IS available but
+ * incomplete.
+ */
+export interface CacheSavingsStatus {
+  available: boolean
+  note: string | null
+}
+
+/**
+ * cacheSavingsStatus (N2 fix, verify-redesign-final.md) reports whether
+ * GET /admin/api/usage/models' `detail=1` `cacheSavedMicroUsd` figure is
+ * available for `window`, and any caveat note CostAvoidedCard.vue should
+ * show alongside it — grounded in admin.go's own cache-savings read
+ * (serveAdminUsageModelsDetail, admin.go:~1826-1851):
+ *   - `'hour'`: chit/csave are OMITTED entirely (both fields left
+ *     undefined, never a fabricated `$0.00`) — recordCacheHit only ever
+ *     writes them at DAY granularity (plan §1.2: "model day only"), so
+ *     there is no per-hour figure to recover at all, exact or otherwise.
+ *   - `'day'`: read directly at the exact requested day buckets — exact,
+ *     no caveat needed.
+ *   - `'month'`: read via monthRangeToDayBuckets' exact covering day
+ *     buckets, but those are capped at the day counter's own 35-day
+ *     retention (historyMaxSpan(windowDay), admin.go) — a 3mo/6mo/12mo
+ *     range's figure only ever covers the most recent 35 days of it,
+ *     never silently more, and never the whole selected range once that
+ *     range exceeds 35 days.
+ *
+ * This replaces an earlier, stale note ("reflects the last N-bucket
+ * window, not the selected range") that described a DIFFERENT, already-
+ * fixed backend bug (P3 item 15: cache savings used to always sum DAY
+ * buckets regardless of the requested window) — the current backend
+ * behaviour above is what ships now, not that one.
+ */
+export function cacheSavingsStatus(window: HistoryWindow): CacheSavingsStatus {
+  if (window === 'hour') {
+    return { available: false, note: 'Cache savings are not tracked per hour — pick a day or month range instead.' }
+  }
+  if (window === 'month') {
+    return { available: true, note: 'Covers only the most recent 35 days (day-bucket retention), not the full selected range.' }
+  }
+  return { available: true, note: null }
+}
diff --git a/webui/src/lib/chart-setup.ts b/webui/src/lib/chart-setup.ts
index 7a84037..72796a2 100644
--- a/webui/src/lib/chart-setup.ts
+++ b/webui/src/lib/chart-setup.ts
@@ -1,15 +1,18 @@
-import {
-  BarController,
-  BarElement,
-  CategoryScale,
-  Chart,
-  Legend,
-  LinearScale,
-  Tooltip,
-} from 'chart.js'
+import { CategoryScale, Chart, Filler, Legend, LinearScale, LineController, LineElement, PointElement, Tooltip } from 'chart.js'
 
 // Registered once at module load (ES module caching makes this a true
-// singleton regardless of how many components import it) — only the bar
-// chart pieces this panel actually uses, not chart.js's full auto-registry,
-// to keep the baked-in bundle lean.
-Chart.register(BarController, BarElement, CategoryScale, LinearScale, Legend, Tooltip)
+// singleton regardless of how many components import it) — only the
+// chart pieces this panel actually uses, not chart.js's full
+// auto-registry, to keep the baked-in bundle lean. TimeSeriesChart.vue
+// (redesign-plan.md section 3.4) is the only chart component in this
+// panel, and it only ever imports `Line` from vue-chartjs (never `Bar`) —
+// so this registers exactly Line's own pieces, plus `Filler`:
+// TimeSeriesChart.vue sets `fill: props.stacked` on every stacked
+// dataset, and without Filler registered chart.js silently ignores that
+// option — a stacked area chart drew UNFILLED lines at cumulative
+// heights, so a reader saw the top line at the height of the whole total
+// rather than its own value (P2). A `BarController`/`BarElement`
+// registration used to sit here too; it was dead — grep confirms no
+// component imports vue-chartjs's `Bar`.
+Chart.register(CategoryScale, LinearScale, Legend, Tooltip, LineController, LineElement, PointElement, Filler)
+
diff --git a/webui/src/lib/cost-avoided.spec.ts b/webui/src/lib/cost-avoided.spec.ts
new file mode 100644
index 0000000..935df37
--- /dev/null
+++ b/webui/src/lib/cost-avoided.spec.ts
@@ -0,0 +1,128 @@
+import { describe, expect, it } from 'vitest'
+
+import { costAvoidedMicros, freeRows, pickReferenceModel } from './cost-avoided'
+import type { AdminCatalogModel, AdminUsageModelEntry } from '@/types/api'
+
+describe('freeRows', () => {
+  it('keeps only entries with free === true, reading out their token counts', () => {
+    const models: AdminUsageModelEntry[] = [
+      { id: 'a/free-model:free', value: 0, free: true, tokensIn: 100, tokensOut: 50 },
+      { id: 'b/paid-model', value: 10, free: false, tokensIn: 20, tokensOut: 10 },
+    ]
+    expect(freeRows(models)).toEqual([{ tokensIn: 100, tokensOut: 50 }])
+  })
+
+  it('defaults missing token counts to 0', () => {
+    const models: AdminUsageModelEntry[] = [{ id: 'a/free', value: 0, free: true }]
+    expect(freeRows(models)).toEqual([{ tokensIn: 0, tokensOut: 0 }])
+  })
+
+  it('returns an empty array when nothing is free', () => {
+    const models: AdminUsageModelEntry[] = [{ id: 'a/paid', value: 5, free: false }]
+    expect(freeRows(models)).toEqual([])
+  })
+})
+
+describe('costAvoidedMicros', () => {
+  it('sums tokensIn*refIn + tokensOut*refOut across rows, already in micro-USD', () => {
+    // 1_000_000 tokensIn at $1/MTok = 1,000,000 micros ($1); 500_000
+    // tokensOut at $2/MTok = 1,000,000 micros ($1). Total 2,000,000.
+    const rows = [{ tokensIn: 1_000_000, tokensOut: 500_000 }]
+    expect(costAvoidedMicros(rows, 1, 2)).toBe(2_000_000)
+  })
+
+  it('sums across multiple rows', () => {
+    const rows = [
+      { tokensIn: 1_000_000, tokensOut: 0 },
+      { tokensIn: 0, tokensOut: 1_000_000 },
+    ]
+    expect(costAvoidedMicros(rows, 0.5, 1.5)).toBe(500_000 + 1_500_000)
+  })
+
+  it('returns 0 for an empty rows array', () => {
+    expect(costAvoidedMicros([], 1, 1)).toBe(0)
+  })
+
+  it('rounds the summed total to the nearest whole micro-USD', () => {
+    const rows = [{ tokensIn: 1, tokensOut: 1 }]
+    expect(costAvoidedMicros(rows, 0.33, 0.33)).toBe(Math.round(0.33 + 0.33))
+  })
+})
+
+describe('pickReferenceModel', () => {
+  const catalog = new Map<string, AdminCatalogModel>([
+    ['a/paid-high', { id: 'a/paid-high', model: 'paid-high', priceSource: 'builtin' }],
+    ['a/paid-low', { id: 'a/paid-low', model: 'paid-low', priceSource: 'override' }],
+    ['a/free', { id: 'a/free', model: 'free', priceSource: 'free' }],
+    ['a/unpriced', { id: 'a/unpriced', model: 'unpriced', priceSource: 'unpriced' }],
+  ])
+
+  it('picks the most-requested model among genuinely priced catalog entries', () => {
+    const models: AdminUsageModelEntry[] = [
+      { id: 'a/paid-low', value: 1, requests: 5 },
+      { id: 'a/paid-high', value: 1, requests: 50 },
+    ]
+    expect(pickReferenceModel(models, catalog)).toBe('a/paid-high')
+  })
+
+  it('skips free and unpriced catalog entries even if most-requested', () => {
+    const models: AdminUsageModelEntry[] = [
+      { id: 'a/free', value: 1, requests: 1000 },
+      { id: 'a/paid-low', value: 1, requests: 1 },
+    ]
+    expect(pickReferenceModel(models, catalog)).toBe('a/paid-low')
+  })
+
+  it('skips a served id missing from the catalog entirely', () => {
+    const models: AdminUsageModelEntry[] = [{ id: 'a/removed', value: 1, requests: 999 }]
+    expect(pickReferenceModel(models, catalog)).toBeNull()
+  })
+
+  it('skips a detail-less entry with no requests field', () => {
+    const models: AdminUsageModelEntry[] = [{ id: 'a/paid-high', value: 1 }]
+    expect(pickReferenceModel(models, catalog)).toBeNull()
+  })
+
+  it('returns null when nothing qualifies', () => {
+    const models: AdminUsageModelEntry[] = [{ id: 'a/free', value: 1, requests: 10 }]
+    expect(pickReferenceModel(models, catalog)).toBeNull()
+  })
+
+  it('returns null for an empty ranking', () => {
+    expect(pickReferenceModel([], catalog)).toBeNull()
+  })
+})
+
+/**
+ * N1 (verify-redesign-final.md): CostAvoidedCard.vue's own `avoidedMicros`
+ * computed is exactly `pickReferenceModel` feeding `costAvoidedMicros`
+ * with the picked model's `cat.inputPerMTokUsd`/`outputPerMTokUsd` — this
+ * end-to-end shape is what broke when the catalog reported `priceSource:
+ * 'override'` alongside undefined prices (admin_catalog.go's now-fixed
+ * bug). This exercises the same two-step flow directly against a fixed-
+ * shape catalog (billing price present for every priced source,
+ * including 'override' — the contract GET /admin/api/catalog now
+ * guarantees) so a regression back to undefined-but-priced catalog
+ * entries fails here, not just in a Go-only test.
+ */
+describe('pickReferenceModel + costAvoidedMicros end-to-end (N1 regression)', () => {
+  it('computes a non-null avoided-cost figure when the picked reference model is override-priced', () => {
+    const catalog = new Map<string, AdminCatalogModel>([
+      ['a/override-priced', { id: 'a/override-priced', model: 'override-priced', priceSource: 'override', inputPerMTokUsd: 5, outputPerMTokUsd: 10 }],
+    ])
+    const models: AdminUsageModelEntry[] = [
+      { id: 'a/override-priced', value: 1, requests: 42, free: false },
+      { id: 'a/free-model', value: 0, free: true, tokensIn: 1_000_000, tokensOut: 500_000 },
+    ]
+
+    const picked = pickReferenceModel(models, catalog)
+    expect(picked).toBe('a/override-priced')
+
+    const cat = catalog.get(picked as string)
+    expect(cat?.inputPerMTokUsd).toBe(5)
+    expect(cat?.outputPerMTokUsd).toBe(10)
+
+    const avoided = costAvoidedMicros(freeRows(models), cat?.inputPerMTokUsd as number, cat?.outputPerMTokUsd as number)
+    expect(avoided).toBe(1_000_000 * 5 + 500_000 * 10)
+  })
+})
diff --git a/webui/src/lib/cost-avoided.ts b/webui/src/lib/cost-avoided.ts
new file mode 100644
index 0000000..875a947
--- /dev/null
+++ b/webui/src/lib/cost-avoided.ts
@@ -0,0 +1,84 @@
+// Pure math behind CostAvoidedCard.vue (redesign-plan.md section 3.4): how
+// much a fleet's FREE-tier traffic would have cost against a real, priced
+// reference model, plus which model to default that reference to. Kept out
+// of the component the same way lib/forecast.ts/lib/burndown.ts keep their
+// own math out of theirs.
+import type { AdminCatalogModel, AdminUsageModelEntry } from '@/types/api'
+
+/**
+ * FreeUsageRow is the subset of a GET /admin/api/usage/models `detail=1`
+ * entry costAvoidedMicros needs — deliberately narrower than
+ * AdminUsageModelEntry so the function is testable against plain literals
+ * without constructing a full entry.
+ */
+export interface FreeUsageRow {
+  tokensIn: number
+  tokensOut: number
+}
+
+/**
+ * freeRows filters a model ranking down to its FREE rows (detail=1's own
+ * `free` flag — a model billed as $0, whether a configured modelMeta.free
+ * override or a genuinely unpriced model, types/api.ts's PriceSource doc
+ * comment) and reads out just the token counts costAvoidedMicros needs.
+ * `tokensIn`/`tokensOut` default to 0 for a detail-less entry (should not
+ * happen once the caller has requested detail=1, but this keeps the
+ * function total rather than reading `undefined` into arithmetic).
+ */
+export function freeRows(models: AdminUsageModelEntry[]): FreeUsageRow[] {
+  return models.filter((m) => m.free).map((m) => ({ tokensIn: m.tokensIn ?? 0, tokensOut: m.tokensOut ?? 0 }))
+}
+
+/**
+ * costAvoidedMicros sums, over every free-tier row, what that traffic
+ * would have cost at a REAL reference model's own per-token-million rates
+ * — the fleet's "cost avoided by routing to free models" figure
+ * (redesign-plan.md section 3.4).
+ *
+ * Unit derivation (why no explicit /1e6 appears despite `refInputPerMTokUsd`
+ * being USD PER MILLION tokens, types/api.ts's AdminCatalogModel doc
+ * comment): cost_usd = tokensIn * (refInputPerMTokUsd / 1_000_000);
+ * cost_micros = cost_usd * 1_000_000 (MICROS_PER_USD, lib/usage-bars.ts) =
+ * tokensIn * refInputPerMTokUsd. The two factors of 1_000_000 cancel
+ * exactly, so multiplying token counts directly by the $-per-million-token
+ * rate already yields micro-USD — the same unit AdminUsageEntryView's own
+ * costPerDayMicroUsd/costPerMonthMicroUsd fields use, with no separate
+ * scaling step. Rounded once, over the summed total, not per-row, so a sum
+ * of many sub-micro rows never underflows to a visibly wrong 0 before
+ * accumulating.
+ */
+export function costAvoidedMicros(rows: FreeUsageRow[], refInputPerMTokUsd: number, refOutputPerMTokUsd: number): number {
+  let total = 0
+  for (const row of rows) total += row.tokensIn * refInputPerMTokUsd + row.tokensOut * refOutputPerMTokUsd
+  return Math.round(total)
+}
+
+/** REFERENCE_INELIGIBLE_SOURCES are the catalog priceSource values pickReferenceModel refuses to default to — a "what would this have cost at a real price" comparison is meaningless against another $0 model. */
+const REFERENCE_INELIGIBLE_SOURCES = new Set(['free', 'unpriced'])
+
+/**
+ * pickReferenceModel defaults the "compare free traffic against" model to
+ * the MOST-REQUESTED genuinely-priced model actually served in the current
+ * range (redesign-plan.md section 3.4: "reference model picker from priced
+ * catalog models, default most-requested paid model in range"). Ranked by
+ * `requests` specifically — NOT by whichever metric the Spend page's own
+ * breakdown happens to be sorted by — since a cost-ranked or token-ranked
+ * list would bias the default toward an expensive or verbose model rather
+ * than the one readers actually reach for most. A model missing from
+ * `catalog` (not currently in the live registry — a stale ranking entry
+ * for a since-removed model) or lacking a `requests` count (a detail-less
+ * entry) is skipped. Returns null when nothing in the range qualifies —
+ * every served model was itself free/unpriced, or usage/models was empty
+ * — the caller then falls back to an explicit picker with no preselection
+ * rather than a fabricated default.
+ */
+export function pickReferenceModel(models: AdminUsageModelEntry[], catalog: Map<string, AdminCatalogModel>): string | null {
+  let best: AdminUsageModelEntry | null = null
+  for (const m of models) {
+    if (m.requests === undefined) continue
+    const cat = catalog.get(m.id)
+    if (!cat || REFERENCE_INELIGIBLE_SOURCES.has(cat.priceSource)) continue
+    if (best === null || m.requests > (best.requests ?? 0)) best = m
+  }
+  return best?.id ?? null
+}
diff --git a/webui/src/lib/csv.ts b/webui/src/lib/csv.ts
index d1a6486..6ec9981 100644
--- a/webui/src/lib/csv.ts
+++ b/webui/src/lib/csv.ts
@@ -1,7 +1,7 @@
 // F8 (CSV export): the one RFC 4180 encoder every CSV export in this panel
-// builds on (usage-csv.ts's usageCsv/modelDetailCsv, the Models tab's
-// export) — one implementation, not a copy per export (vue.md: "if you've
-// written it twice, you owe an abstraction").
+// builds on (usage-csv.ts's usageCsv, PricingHealthTable.vue's own
+// pricingHealthCsv) — one implementation, not a copy per export (vue.md:
+// "if you've written it twice, you owe an abstraction").
 
 /** CSV_LINE_ENDING is RFC 4180's own line terminator (CRLF), not the bare "\n" a JS template literal defaults to — Excel and most spreadsheet importers expect it, and RFC 4180 section 2.1 requires it. */
 const CSV_LINE_ENDING = '\r\n'
diff --git a/webui/src/lib/download.ts b/webui/src/lib/download.ts
index 868d63d..cccd25b 100644
--- a/webui/src/lib/download.ts
+++ b/webui/src/lib/download.ts
@@ -29,8 +29,9 @@ const REVOKE_DELAY_MS = 1000
  * Guarded for a non-DOM environment (this module is never unit-tested —
  * see WP-B1's own test plan, lib/download.ts has no .spec.ts — but a
  * defensive `typeof document` check keeps it from throwing if it is ever
- * imported somewhere `document` is not global, matching useTabHash.ts's
- * own `hasWindow` convention). The clipboard fallback (copyText, Q8) runs
+ * imported somewhere `document` is not global, matching
+ * composables/useHashState.ts's own `hasWindow` convention). The
+ * clipboard fallback (copyText, Q8) runs
  * ONLY when the Blob/URL/anchor machinery itself is unavailable or throws
  * (a Blob/URL API genuinely unsupported, or the synthetic click rejected)
  * — never merely because a download was silently blocked by the browser,
diff --git a/webui/src/lib/events-filter.ts b/webui/src/lib/events-filter.ts
index f6d9a5a..b68f362 100644
--- a/webui/src/lib/events-filter.ts
+++ b/webui/src/lib/events-filter.ts
@@ -64,7 +64,7 @@ export interface EventFilter {
  * filterEvents narrows the (already newest-first) event list to the
  * current kind/user selection. `filter.user` is matched pre-normalized —
  * callers pair this with useSearchQuery()'s own `normalized` the same way
- * every other search filter in this panel does (ProvidersView.vue's
+ * every other search filter in this panel does (ProviderHealthPanel.vue's
  * modelMatches, lib/usage-search.ts) — this function itself does no
  * trimming or casing of its own beyond a defensive `.trim().toLowerCase()`
  * so it is still correct if a caller passes the raw query directly.
diff --git a/webui/src/lib/format.spec.ts b/webui/src/lib/format.spec.ts
index 52be93d..2f8fff3 100644
--- a/webui/src/lib/format.spec.ts
+++ b/webui/src/lib/format.spec.ts
@@ -98,8 +98,8 @@ describe('formatModelCostHover', () => {
 
 // Discovery circuit breaker (feat/provider-health, round 3): openUntil's
 // future-time counterpart to formatAgo's past-time "(Ns ago)". Only
-// caller today is ProvidersView.vue's healthBadgeLabel, rendering the
-// breaker's live "open (in Ns)" countdown.
+// caller today is ProviderHealthPanel.vue's healthBadgeLabel, rendering
+// the breaker's live "open (in Ns)" countdown.
 describe('formatUntil', () => {
   it('renders "" for the unset zero-time sentinel', () => {
     expect(formatUntil(ZERO_TIME)).toBe('')
diff --git a/webui/src/lib/hash-state.spec.ts b/webui/src/lib/hash-state.spec.ts
index 81e643b..73d2d1c 100644
--- a/webui/src/lib/hash-state.spec.ts
+++ b/webui/src/lib/hash-state.spec.ts
@@ -1,153 +1,132 @@
 import { describe, expect, it } from 'vitest'
 
-import {
-  buildHash,
-  DEFAULT_TAB,
-  parseChartsParams,
-  parseEventsParams,
-  parseHashState,
-  parseUsageParams,
-} from './hash-state'
+import { PAGE_IDS } from './pages'
+import { buildHash, parseGlobalParams, parseHashState, parsePageParams } from './hash-state'
 
 describe('parseHashState', () => {
-  it('splits a tab and query string', () => {
-    const { tab, query } = parseHashState('#charts?window=day&scope=user%3Aalice')
-    expect(tab).toBe('charts')
-    expect(query.get('window')).toBe('day')
-    expect(query.get('scope')).toBe('user:alice')
+  it('splits a page and query string', () => {
+    const { page, query } = parseHashState('#spend?range=30d&by=model')
+    expect(page).toBe('spend')
+    expect(query.get('range')).toBe('30d')
+    expect(query.get('by')).toBe('model')
   })
 
-  it('parses a bare tab with no query to an empty query', () => {
-    const { tab, query } = parseHashState('#usage')
-    expect(tab).toBe('usage')
+  it('parses a bare page with no query to an empty query', () => {
+    const { page, query } = parseHashState('#consumers')
+    expect(page).toBe('consumers')
     expect(Array.from(query.keys())).toEqual([])
   })
 
-  it('falls back to DEFAULT_TAB for an empty hash', () => {
-    expect(parseHashState('').tab).toBe(DEFAULT_TAB)
+  it('falls back to DEFAULT_PAGE ("home") for an empty hash', () => {
+    expect(parseHashState('').page).toBe('home')
   })
 
-  it('falls back to DEFAULT_TAB for an unrecognized tab, and still parses its query', () => {
-    const { tab, query } = parseHashState('#bogus?window=day')
-    expect(tab).toBe(DEFAULT_TAB)
-    expect(query.get('window')).toBe('day')
+  it('falls back to DEFAULT_PAGE for an unrecognized, non-legacy page, and still parses its query', () => {
+    const { page, query } = parseHashState('#bogus?range=30d')
+    expect(page).toBe('home')
+    expect(query.get('range')).toBe('30d')
   })
 
   it('accepts a hash with or without the leading #', () => {
-    expect(parseHashState('targets').tab).toBe('targets')
+    expect(parseHashState('targets').page).toBe('targets')
   })
 
-  it('every valid tab round-trips through parseHashState(buildHash(...))', () => {
-    for (const tab of ['providers', 'usage', 'charts', 'targets', 'events'] as const) {
-      expect(parseHashState(buildHash(tab, {})).tab).toBe(tab)
+  it('every current page id round-trips through parseHashState(buildHash(...))', () => {
+    for (const page of PAGE_IDS) {
+      expect(parseHashState(buildHash(page, {})).page).toBe(page)
     }
   })
+
+  describe('legacy tab-name mapping', () => {
+    it.each([
+      ['providers', 'models'],
+      ['usage', 'consumers'],
+      ['charts', 'spend'],
+      ['events', 'reliability'],
+      ['targets', 'targets'],
+    ] as const)('#%s maps to #%s', (legacy, mapped) => {
+      expect(parseHashState(`#${legacy}`).page).toBe(mapped)
+    })
+
+    it('drops the old hash\'s query params entirely, regardless of shape', () => {
+      const { page, query } = parseHashState('#charts?tab=models&metric=cost&scope=user%3Aalice')
+      expect(page).toBe('spend')
+      expect(Array.from(query.keys())).toEqual([])
+    })
+  })
 })
 
 describe('buildHash', () => {
   it('omits the query suffix entirely when params is empty', () => {
-    expect(buildHash('providers', {})).toBe('#providers')
+    expect(buildHash('home', {})).toBe('#home')
   })
 
   it('appends a query string for non-empty params', () => {
-    expect(buildHash('charts', { window: 'day' })).toBe('#charts?window=day')
+    expect(buildHash('spend', { range: '30d' })).toBe('#spend?range=30d')
   })
 
-  it('joins multiple params with &', () => {
-    const hash = buildHash('charts', { window: 'day', scope: 'user:alice' })
-    expect(hash).toBe('#charts?window=day&scope=user%3Aalice')
+  it('joins multiple params with &, in insertion order', () => {
+    const hash = buildHash('spend', { range: '30d', cmp: 'prev', scope: 'user:alice' })
+    expect(hash).toBe('#spend?range=30d&cmp=prev&scope=user%3Aalice')
   })
 
   it('drops a param whose value is an explicit empty string', () => {
-    expect(buildHash('usage', { q: '' })).toBe('#usage')
+    expect(buildHash('consumers', { q: '' })).toBe('#consumers')
   })
 })
 
-describe('parseChartsParams', () => {
-  it('accepts every valid window/tab/metric value', () => {
-    const p = parseChartsParams(new URLSearchParams('window=month&tab=models&metric=tokin'))
-    expect(p).toEqual({ window: 'month', tab: 'models', metric: 'tokin' })
+describe('parseGlobalParams', () => {
+  it('accepts every valid range/cmp/scope value', () => {
+    const p = parseGlobalParams(new URLSearchParams('range=30d&cmp=prev&scope=group:eng'))
+    expect(p).toEqual({ range: '30d', cmp: 'prev', scope: 'group:eng' })
   })
 
-  it('omits window when it is not a recognized HistoryWindow', () => {
-    expect(parseChartsParams(new URLSearchParams('window=fortnight'))).toEqual({})
+  it('omits range when it is not a recognized RangeKey', () => {
+    expect(parseGlobalParams(new URLSearchParams('range=fortnight'))).toEqual({})
   })
 
-  it('omits tab when it is not a recognized ChartTab', () => {
-    expect(parseChartsParams(new URLSearchParams('tab=bogus'))).toEqual({})
-  })
-
-  it('omits metric when it is not a recognized ModelMetric', () => {
-    expect(parseChartsParams(new URLSearchParams('metric=bogus'))).toEqual({})
-  })
-
-  it('reads filter when present (free text, not an enum — same convention as scope/q)', () => {
-    expect(parseChartsParams(new URLSearchParams('filter=openai%2F'))).toEqual({ filter: 'openai/' })
-  })
-
-  it('omits filter when absent', () => {
-    expect(parseChartsParams(new URLSearchParams())).toEqual({})
-  })
-
-  it('omits filter when it is an explicit empty string', () => {
-    expect(parseChartsParams(new URLSearchParams('filter='))).toEqual({})
+  it('omits cmp when it is not "none" or "prev"', () => {
+    expect(parseGlobalParams(new URLSearchParams('cmp=bogus'))).toEqual({})
   })
 
   it.each([
-    ['total', true],
+    ['all', true],
+    ['group:eng', true],
     ['user:alice', true],
-    ['group:ops', true],
-    ['model:openai/gpt-5', true],
-    ['user:', false], // empty id after the colon
+    ['provider:openai', true],
+    ['user:', false],
     ['bogus', false],
     ['', false],
   ] as const)('scope %s valid=%s', (scope, valid) => {
-    const p = parseChartsParams(new URLSearchParams(scope ? `scope=${encodeURIComponent(scope)}` : ''))
+    const p = parseGlobalParams(new URLSearchParams(scope ? `scope=${encodeURIComponent(scope)}` : ''))
     expect(p.scope === scope).toBe(valid)
   })
 
-  it('omits one invalid field while keeping the other valid ones (independent per-field validation)', () => {
-    const p = parseChartsParams(new URLSearchParams('window=fortnight&tab=models&scope=total'))
-    expect(p).toEqual({ tab: 'models', scope: 'total' })
+  it('omits one invalid field while keeping the other valid ones', () => {
+    const p = parseGlobalParams(new URLSearchParams('range=fortnight&cmp=prev&scope=all'))
+    expect(p).toEqual({ cmp: 'prev', scope: 'all' })
   })
 
   it('returns an empty object for an empty query', () => {
-    expect(parseChartsParams(new URLSearchParams())).toEqual({})
+    expect(parseGlobalParams(new URLSearchParams())).toEqual({})
   })
 })
 
-describe('parseUsageParams', () => {
-  it('reads q when present', () => {
-    expect(parseUsageParams(new URLSearchParams('q=alice'))).toEqual({ q: 'alice' })
+describe('parsePageParams', () => {
+  it('excludes range/cmp/scope but keeps every other key', () => {
+    const p = parsePageParams(new URLSearchParams('range=30d&cmp=prev&scope=all&by=model&metric=cost'))
+    expect(p).toEqual({ by: 'model', metric: 'cost' })
   })
 
-  it('omits q when absent', () => {
-    expect(parseUsageParams(new URLSearchParams())).toEqual({})
+  it('drops a key with an explicit empty-string value', () => {
+    expect(parsePageParams(new URLSearchParams('q='))).toEqual({})
   })
 
-  it('omits q when it is an explicit empty string', () => {
-    expect(parseUsageParams(new URLSearchParams('q='))).toEqual({})
-  })
-})
-
-describe('parseEventsParams', () => {
-  it('reads kind and user when both present', () => {
-    expect(parseEventsParams(new URLSearchParams('kind=rate_limit&user=bob'))).toEqual({
-      kind: 'rate_limit',
-      user: 'bob',
-    })
-  })
-
-  it('accepts a kind this build does not recognize as an AdminEventKind (forward-compat, never rejected)', () => {
-    expect(parseEventsParams(new URLSearchParams('kind=some_future_kind'))).toEqual({ kind: 'some_future_kind' })
-  })
-
-  it('omits either field independently when absent', () => {
-    expect(parseEventsParams(new URLSearchParams('kind=budget'))).toEqual({ kind: 'budget' })
-    expect(parseEventsParams(new URLSearchParams('user=alice'))).toEqual({ user: 'alice' })
+  it('passes through a key this build does not recognize (forward-compat)', () => {
+    expect(parsePageParams(new URLSearchParams('someFutureParam=x'))).toEqual({ someFutureParam: 'x' })
   })
 
   it('returns an empty object for an empty query', () => {
-    expect(parseEventsParams(new URLSearchParams())).toEqual({})
+    expect(parsePageParams(new URLSearchParams())).toEqual({})
   })
 })
diff --git a/webui/src/lib/hash-state.ts b/webui/src/lib/hash-state.ts
index 3b3b2c3..3472f5b 100644
--- a/webui/src/lib/hash-state.ts
+++ b/webui/src/lib/hash-state.ts
@@ -1,135 +1,126 @@
-import { hashToTab, TAB_VALUES, tabToHash, type TabValue } from '@/composables/useTabHash'
-import type { ChartTab, ModelMetric } from '@/stores/history'
-import type { HistoryWindow } from '@/types/api'
+import { DEFAULT_PAGE, isPageId } from '@/lib/pages'
+import type { PageId } from '@/lib/pages'
+import { isCmpMode, isRangeKey } from '@/lib/range'
+import type { CmpMode, RangeKey } from '@/lib/range'
 
 /**
- * DEFAULT_TAB is the app's landing tab when the hash names nothing
- * recognized — parseHashState's own fallback, mirroring the old
- * useTabHash's defaultTab parameter (which every call site passed
- * 'providers' for anyway, so this needed no parameter of its own once
- * folded into one composable, composables/useHashState.ts).
+ * LEGACY_PAGE_MAP redirects the pre-redesign flat-tab hash names to their
+ * redesign home (redesign-plan.md section 3.1's legacy mapping): a
+ * bookmark or shared link built against the old #providers/#usage/
+ * #charts/#events/#targets shell still lands somewhere sensible instead
+ * of falling back to the default page. `targets` keeps its own name —
+ * the MCP & Agents page is the one page that did not move.
+ *
+ * The OLD hash's query params never carry over (see parseHashState below)
+ * — they were shaped for the old tab (e.g. #charts's `tab=models&metric=
+ * cost`), and none of that maps cleanly onto the new page's own param
+ * names, so a legacy hash lands on a clean instance of its mapped page
+ * rather than misapplying a stale param.
  */
-export const DEFAULT_TAB: TabValue = 'providers'
+const LEGACY_PAGE_MAP: Record<string, PageId> = {
+  providers: 'models',
+  usage: 'consumers',
+  charts: 'spend',
+  events: 'reliability',
+  targets: 'targets',
+}
 
 export interface HashState {
-  tab: TabValue
+  page: PageId
   query: URLSearchParams
 }
 
 /**
- * parseHashState splits a raw location.hash ("#charts?window=day&scope=
- * user:alice") into its outer tab — validated against TAB_VALUES via
- * hashToTab, falling back to DEFAULT_TAB exactly like the pre-F9 useTabHash
- * did for an absent/unrecognized/bogus tab — and the remaining query
- * string, parsed once into a URLSearchParams every per-tab validator below
- * reads from. A hash with no "?" (a bare "#usage", or the very first load
- * with no hash at all) parses to an empty query, never throws.
+ * parseHashState splits a raw location.hash ("#spend?range=30d&by=model")
+ * into its outer page and the remaining query string. Three cases:
+ *
+ * 1. The page segment is a current PageId (lib/pages.ts) — parse the
+ *    query normally.
+ * 2. The page segment is a legacy tab name (LEGACY_PAGE_MAP) — map to the
+ *    new page, with an EMPTY query (old params dropped, see the map's own
+ *    doc comment).
+ * 3. Anything else (absent, empty, or unrecognized) — DEFAULT_PAGE, query
+ *    parsed as-is (so a malformed page segment does not also swallow an
+ *    otherwise-valid query string).
+ *
+ * Never throws.
  */
 export function parseHashState(hash: string): HashState {
   const raw = hash.startsWith('#') ? hash.slice(1) : hash
   const qIndex = raw.indexOf('?')
-  const tabPart = qIndex === -1 ? raw : raw.slice(0, qIndex)
+  const pagePart = qIndex === -1 ? raw : raw.slice(0, qIndex)
   const queryPart = qIndex === -1 ? '' : raw.slice(qIndex + 1)
-  const tab = hashToTab(tabPart, TAB_VALUES, DEFAULT_TAB)
-  return { tab, query: new URLSearchParams(queryPart) }
+
+  if (isPageId(pagePart)) return { page: pagePart, query: new URLSearchParams(queryPart) }
+
+  const legacy = LEGACY_PAGE_MAP[pagePart]
+  if (legacy) return { page: legacy, query: new URLSearchParams() }
+
+  return { page: DEFAULT_PAGE, query: new URLSearchParams(queryPart) }
 }
 
 /**
- * buildHash re-serializes a tab plus an already-default-stripped param
- * record back into a "#<tab>?<query>" string (F9) — mirrors tabToHash for
- * the tab-only portion, adding a "?<query>" suffix only when `params` has
- * at least one entry, so the common "nothing but the default selection"
- * case round-trips to a bare "#<tab>" rather than a noisy "#<tab>?".
- *
- * "Omit defaults" is the CALLER's job, not this function's: what counts
- * as default differs per field (window's default is 'hour', scope's is
- * 'total', ...), so composables/useHashState.ts's own computed simply
- * never puts a default-valued key into `params` in the first place.
- * buildHash itself only defends against an explicitly empty-string value
- * slipping through, dropping it the same way.
+ * buildHash re-serializes a page plus an already-default-stripped param
+ * record (global filters and/or page params merged by the caller) back
+ * into a "#<page>?<query>" string. "Omit defaults" is the CALLER's job —
+ * composables/useHashState.ts's own computed decides what counts as
+ * default for range/cmp/scope; buildHash itself only defends against an
+ * explicitly empty-string value slipping through, dropping it the same
+ * way. No query suffix at all when `params` ends up empty, so the common
+ * "nothing but defaults" case round-trips to a bare "#<page>".
  */
-export function buildHash(tab: TabValue, params: Record<string, string>): string {
+export function buildHash(page: PageId, params: Record<string, string>): string {
   const entries = Object.entries(params).filter(([, v]) => v !== '')
-  if (entries.length === 0) return tabToHash(tab)
-  return `${tabToHash(tab)}?${new URLSearchParams(entries).toString()}`
+  if (entries.length === 0) return `#${page}`
+  return `#${page}?${new URLSearchParams(entries).toString()}`
 }
 
-const HISTORY_WINDOWS: readonly HistoryWindow[] = ['hour', 'day', 'month']
-const CHART_TABS: readonly ChartTab[] = ['requests', 'tokens', 'cost', 'models']
-const MODEL_METRICS: readonly ModelMetric[] = ['req', 'tokin', 'tokout', 'cost']
-
-/** SCOPE_PATTERN mirrors history.ts's own scope string convention: "total", or one of the three "{kind}:{id}" forms — an id may itself contain almost anything (a model id can contain slashes), so each kind only checks its own prefix plus a non-empty remainder, never the id's own shape. */
-const SCOPE_PATTERN = /^(total|user:.+|group:.+|model:.+)$/
-
-export interface ChartsHashParams {
-  window?: HistoryWindow
-  tab?: ChartTab
-  metric?: ModelMetric
+export interface GlobalHashParams {
+  range?: RangeKey
+  cmp?: CmpMode
   scope?: string
-  /**
-   * The Models tab's provider-prefix filter (stores/history.ts's
-   * modelFilter), round-tripped through the hash so a provider-header
-   * link (nav.goToModels) or a hand-edited `#charts?tab=models&filter=`
-   * URL survives a reload or a hashchange — free text, not an enum, same
-   * convention as `scope` below and Usage's own `q` param.
-   */
-  filter?: string
 }
 
+/** SCOPE_PATTERN mirrors the global filter bar's own scope convention (redesign-plan.md section 3.1): "all", or one of the three "{kind}:{id}" forms — an id may contain almost anything, so each kind only checks its own prefix plus a non-empty remainder. Exported so GlobalFilterBar.vue validates its own scope input against the exact same rule this module uses to parse it back out of the hash. */
+export const SCOPE_PATTERN = /^(all|group:.+|user:.+|provider:.+)$/
+
 /**
- * parseChartsParams validates the Charts tab's own hash query params.
- * Each field is independently OMITTED (never throws, never substitutes a
- * fabricated default itself) when absent or not one of its own known
- * values — a hand-edited or stale-version URL with `window=fortnight` or
- * `metric=bogus` degrades to "use whatever this field already is"
- * (composables/useHashState.ts's own caller decides the actual default),
- * rather than failing the whole hash or resetting every OTHER, valid
- * field alongside the one bad one.
+ * parseGlobalParams validates the three page-independent hash params
+ * (range/cmp/scope) every page's hash shares. Each field is independently
+ * OMITTED (never throws) when absent or not a recognized value — a
+ * hand-edited or stale-version URL with `range=fortnight` degrades to
+ * "use whatever this field already is" (the caller decides the actual
+ * default), rather than failing the whole hash or resetting the other,
+ * valid fields alongside the one bad one.
  */
-export function parseChartsParams(query: URLSearchParams): ChartsHashParams {
-  const result: ChartsHashParams = {}
-  const window = query.get('window')
-  if (window && (HISTORY_WINDOWS as readonly string[]).includes(window)) result.window = window as HistoryWindow
-  const tab = query.get('tab')
-  if (tab && (CHART_TABS as readonly string[]).includes(tab)) result.tab = tab as ChartTab
-  const metric = query.get('metric')
-  if (metric && (MODEL_METRICS as readonly string[]).includes(metric)) result.metric = metric as ModelMetric
+export function parseGlobalParams(query: URLSearchParams): GlobalHashParams {
+  const result: GlobalHashParams = {}
+  const range = query.get('range')
+  if (range && isRangeKey(range)) result.range = range
+  const cmp = query.get('cmp')
+  if (cmp && isCmpMode(cmp)) result.cmp = cmp
   const scope = query.get('scope')
   if (scope && SCOPE_PATTERN.test(scope)) result.scope = scope
-  const filter = query.get('filter')
-  if (filter) result.filter = filter
   return result
 }
 
-export interface UsageHashParams {
-  q?: string
-}
-
-/** parseUsageParams reads the Usage tab's own single `q` param. It is free-text search input, not an enum, so there is nothing to validate beyond "present and non-empty" — any string round-trips as-is. */
-export function parseUsageParams(query: URLSearchParams): UsageHashParams {
-  const q = query.get('q')
-  return q ? { q } : {}
-}
-
-export interface EventsHashParams {
-  kind?: string
-  user?: string
-}
+/** GLOBAL_PARAM_KEYS names the three query keys parseGlobalParams reads — parsePageParams below excludes exactly these, and nothing else, from a page's own param record. */
+const GLOBAL_PARAM_KEYS: ReadonlySet<string> = new Set(['range', 'cmp', 'scope'])
 
 /**
- * parseEventsParams reads the Events tab's own kind/user params. `kind` is
- * deliberately NOT validated against AdminEventKind here (unlike Charts'
- * enum fields above): lib/events-filter.ts's filterEvents already treats
- * an unrecognized kind as "matches nothing" harmlessly, and rejecting it
- * here would silently drop a link built against a server-added kind this
- * webui build predates — the same "still carry it through" convention
- * AdminEventView.kind's own `| string` union documents (types/api.ts).
+ * parsePageParams returns every hash query param EXCEPT the three global
+ * ones, verbatim, as a plain record. Deliberately opaque (no per-page
+ * validation here — see stores/nav.ts's own doc comment for why): each
+ * page owns interpreting its own param names/values, and a key this
+ * build does not recognize (an older link, or one from a newer page)
+ * simply passes through unused rather than being rejected.
  */
-export function parseEventsParams(query: URLSearchParams): EventsHashParams {
-  const result: EventsHashParams = {}
-  const kind = query.get('kind')
-  const user = query.get('user')
-  if (kind) result.kind = kind
-  if (user) result.user = user
+export function parsePageParams(query: URLSearchParams): Record<string, string> {
+  const result: Record<string, string> = {}
+  for (const [key, value] of query.entries()) {
+    if (GLOBAL_PARAM_KEYS.has(key)) continue
+    if (value === '') continue
+    result[key] = value
+  }
   return result
 }
diff --git a/webui/src/lib/kpi.spec.ts b/webui/src/lib/kpi.spec.ts
new file mode 100644
index 0000000..3aec1b7
--- /dev/null
+++ b/webui/src/lib/kpi.spec.ts
@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  budgetRatio,
+  budgetTier,
+  errorRateTier,
+  fleetErrorRate,
+  openBreakerCount,
+  sumGroupBudgetMicros,
+} from './kpi'
+import type { AdminGroupView, AdminProviderView } from '@/types/api'
+
+function makeGroup(overrides: Partial<AdminGroupView> = {}): AdminGroupView {
+  return { name: 'eng', memberCount: 3, ...overrides }
+}
+
+function makeProvider(overrides: Partial<AdminProviderView> = {}): AdminProviderView {
+  return {
+    name: 'openai',
+    type: 'openai',
+    baseUrl: 'https://api.openai.com',
+    lastRefresh: '0001-01-01T00:00:00Z',
+    models: [],
+    modelCount: 0,
+    modelMeta: {},
+    discoveryEnabled: false,
+    healthState: 'closed',
+    openUntil: '0001-01-01T00:00:00Z',
+    attemptsDay: 0,
+    failuresDay: 0,
+    attemptsMinute: 0,
+    failuresMinute: 0,
+    modelRates: {},
+    ...overrides,
+  }
+}
+
+describe('sumGroupBudgetMicros', () => {
+  it('sums every group\'s costPerMonthUSD limit, converted to micro-USD', () => {
+    const groups = [
+      makeGroup({ limits: { costPerMonthUSD: 10 } }),
+      makeGroup({ limits: { costPerMonthUSD: 25.5 } }),
+    ]
+    expect(sumGroupBudgetMicros(groups)).toBe(35_500_000)
+  })
+
+  it('skips a group with no costPerMonthUSD configured', () => {
+    const groups = [makeGroup({ limits: undefined }), makeGroup({ limits: { costPerMonthUSD: 0 } })]
+    expect(sumGroupBudgetMicros(groups)).toBe(0)
+  })
+
+  it('returns 0 for an empty group list', () => {
+    expect(sumGroupBudgetMicros([])).toBe(0)
+  })
+})
+
+describe('budgetRatio / budgetTier', () => {
+  it('returns null when budgetMicros is 0 ("no budget set")', () => {
+    expect(budgetRatio(5_000_000, 0)).toBeNull()
+    expect(budgetTier(null)).toBe('ok')
+  })
+
+  it('classifies below 0.8 as ok, [0.8, 1.0) as warn, >= 1.0 as critical', () => {
+    expect(budgetTier(budgetRatio(700_000, 1_000_000))).toBe('ok')
+    expect(budgetTier(budgetRatio(900_000, 1_000_000))).toBe('warn')
+    expect(budgetTier(budgetRatio(1_200_000, 1_000_000))).toBe('critical')
+  })
+})
+
+describe('openBreakerCount', () => {
+  it('counts providers whose breaker is not closed', () => {
+    const providers = [
+      makeProvider({ healthState: 'closed' }),
+      makeProvider({ healthState: 'open' }),
+      makeProvider({ healthState: 'half-open' }),
+    ]
+    expect(openBreakerCount(providers)).toBe(2)
+  })
+
+  it('returns 0 when every breaker is closed', () => {
+    expect(openBreakerCount([makeProvider(), makeProvider()])).toBe(0)
+  })
+})
+
+describe('fleetErrorRate / errorRateTier', () => {
+  it('sums attemptsMinute/failuresMinute across every provider', () => {
+    const providers = [
+      makeProvider({ attemptsMinute: 100, failuresMinute: 1 }),
+      makeProvider({ attemptsMinute: 50, failuresMinute: 4 }),
+    ]
+    const result = fleetErrorRate(providers)
+    expect(result.attempts).toBe(150)
+    expect(result.failures).toBe(5)
+    expect(result.rate).toBeCloseTo(5 / 150)
+  })
+
+  it('rate is null when there were no attempts (never a fabricated 0%)', () => {
+    const result = fleetErrorRate([makeProvider({ attemptsMinute: 0, failuresMinute: 0 })])
+    expect(result.rate).toBeNull()
+    expect(errorRateTier(result.rate)).toBe('ok')
+  })
+
+  it('classifies error rate into ok/warn/critical using the shared provider-rate thresholds', () => {
+    expect(errorRateTier(0.001)).toBe('ok') // 99.9% success
+    expect(errorRateTier(0.05)).toBe('warn') // 95% success, below the 99% amber threshold
+    expect(errorRateTier(0.2)).toBe('critical') // 80% success, below the 90% destructive threshold
+  })
+})
diff --git a/webui/src/lib/kpi.ts b/webui/src/lib/kpi.ts
new file mode 100644
index 0000000..32e1812
--- /dev/null
+++ b/webui/src/lib/kpi.ts
@@ -0,0 +1,91 @@
+// Pure math behind the Home page's KpiTile.vue tiles (redesign-plan.md
+// section 3.4) — kept out of the component/page the same way lib/
+// provider-rate.ts and lib/usage-bars.ts keep their own tier math out of
+// their components, so vitest's node-environment config exercises it
+// directly, no component mount required. Deliberately reuses those two
+// modules' existing thresholds (BAR_AMBER_THRESHOLD/BAR_RED_THRESHOLD,
+// PROVIDER_RATE_AMBER_THRESHOLD/PROVIDER_RATE_DESTRUCTIVE_THRESHOLD)
+// rather than declaring a third, independent set of budget/error-rate
+// boundaries for the same two underlying concepts (a used/limit ratio,
+// a success rate) the rest of this panel already colors consistently.
+import { providerRateStatus, providerSuccessRate } from '@/lib/provider-rate'
+import { MICROS_PER_USD, ratioTier } from '@/lib/usage-bars'
+import type { AdminGroupView, AdminProviderView } from '@/types/api'
+
+/** KpiTier is KpiTile.vue's own three-color scale — 'ok' (normal), 'warn' (approaching a limit / minor degradation), 'critical' (over a limit / severe degradation). */
+export type KpiTier = 'ok' | 'warn' | 'critical'
+
+/**
+ * sumGroupBudgetMicros sums every configured group's costPerMonthUSD
+ * limit, converted to micro-USD (Q2, redesign-plan.md DECISIONS: "Home
+ * budget baseline = sum of group costPerMonthUSD"). A group with no
+ * costPerMonthUSD configured (0 or undefined) contributes nothing — the
+ * caller reads a 0 total as "no budget set" (budgetRatio below), never a
+ * genuine zero-dollar budget.
+ */
+export function sumGroupBudgetMicros(groups: AdminGroupView[]): number {
+  let total = 0
+  for (const group of groups) {
+    const limitUsd = group.limits?.costPerMonthUSD
+    if (limitUsd && limitUsd > 0) total += Math.round(limitUsd * MICROS_PER_USD)
+  }
+  return total
+}
+
+/** budgetRatio is `spentMicros / budgetMicros`, or null when budgetMicros is 0 or negative ("no budget set" — Q2) — the fleet has nothing configured to compare month-to-date spend against. */
+export function budgetRatio(spentMicros: number, budgetMicros: number): number | null {
+  if (budgetMicros <= 0) return null
+  return spentMicros / budgetMicros
+}
+
+/** budgetTier classifies a budgetRatio result into the Home spend tile's KpiTier, reusing lib/usage-bars.ts's own ratioTier thresholds (0.8 amber, 1.0 red) so a budget tile and a per-scope UsageBar agree on what "approaching the limit" means. A null ratio (no budget set) reads as 'ok' — there is nothing to warn about. */
+export function budgetTier(ratio: number | null): KpiTier {
+  if (ratio === null) return 'ok'
+  switch (ratioTier(ratio)) {
+    case 'normal':
+      return 'ok'
+    case 'amber':
+      return 'warn'
+    case 'red':
+      return 'critical'
+  }
+}
+
+/** openBreakerCount counts providers whose discovery circuit breaker is not 'closed' (AdminProviderView.healthState) — the Home "open breakers" tile's own count, per-replica like the field it reads (see AdminProviderView.healthState's own doc comment). */
+export function openBreakerCount(providers: AdminProviderView[]): number {
+  return providers.filter((p) => p.healthState !== 'closed').length
+}
+
+/** FleetErrorRate is the Home error-rate tile's fleet-wide reading: summed minute-window attempts/failures across every provider, and the resulting rate. */
+export interface FleetErrorRate {
+  /** failures/attempts as a 0-1 fraction, or null when there were no attempts in the last minute (never a fabricated 0%). */
+  rate: number | null
+  attempts: number
+  failures: number
+}
+
+/** fleetErrorRate sums every provider's attemptsMinute/failuresMinute (AdminProviderView — the SAME per-replica, in-process minute counters ProviderRateBadge.vue's own minuteRateTitle reads) into one fleet-wide error rate. */
+export function fleetErrorRate(providers: AdminProviderView[]): FleetErrorRate {
+  let attempts = 0
+  let failures = 0
+  for (const p of providers) {
+    attempts += p.attemptsMinute
+    failures += p.failuresMinute
+  }
+  const success = providerSuccessRate(attempts, failures)
+  return { rate: success === null ? null : 1 - success, attempts, failures }
+}
+
+/** errorRateTier classifies a fleetErrorRate() result into the Home error-rate tile's KpiTier, reusing lib/provider-rate.ts's own success-rate thresholds (99% amber, 90% red) inverted for an error-rate reading — the same boundaries the Providers tab's own badges already use. */
+export function errorRateTier(rate: number | null): KpiTier {
+  if (rate === null) return 'ok'
+  switch (providerRateStatus(1 - rate)) {
+    case 'no-traffic':
+    case 'healthy':
+      return 'ok'
+    case 'degraded':
+      return 'warn'
+    case 'severe':
+      return 'critical'
+  }
+}
diff --git a/webui/src/lib/last-seen.spec.ts b/webui/src/lib/last-seen.spec.ts
new file mode 100644
index 0000000..9c20d2a
--- /dev/null
+++ b/webui/src/lib/last-seen.spec.ts
@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest'
+
+import { formatLastSeen } from './last-seen'
+
+const NOW = new Date(Date.UTC(2026, 3, 16, 12, 0, 0))
+const NOW_SECONDS = Math.floor(NOW.getTime() / 1000)
+
+describe('formatLastSeen', () => {
+  it.each([
+    [undefined, 'never'],
+    [0, 'never'],
+  ])('%s seconds -> "never" (types/api.ts: 0/omitted means never seen or the feature is off)', (seconds, expected) => {
+    expect(formatLastSeen(seconds, NOW)).toBe(expected)
+  })
+
+  it('renders "just now" for a timestamp under a minute old', () => {
+    expect(formatLastSeen(NOW_SECONDS - 30, NOW)).toBe('just now')
+  })
+
+  it('renders "just now" for a timestamp in the FUTURE (clock skew), clamping delta to 0 rather than a negative duration', () => {
+    expect(formatLastSeen(NOW_SECONDS + 500, NOW)).toBe('just now')
+  })
+
+  it('renders minutes under an hour', () => {
+    expect(formatLastSeen(NOW_SECONDS - 5 * 60, NOW)).toBe('5m ago')
+  })
+
+  it('renders hours under a day', () => {
+    expect(formatLastSeen(NOW_SECONDS - 3 * 3600, NOW)).toBe('3h ago')
+  })
+
+  it('renders days under the month threshold', () => {
+    expect(formatLastSeen(NOW_SECONDS - 10 * 86400, NOW)).toBe('10d ago')
+  })
+
+  it('renders months at/beyond the month threshold', () => {
+    expect(formatLastSeen(NOW_SECONDS - 90 * 86400, NOW)).toBe('3mo ago')
+  })
+
+  it('boundary: exactly 59 seconds is still "just now"', () => {
+    expect(formatLastSeen(NOW_SECONDS - 59, NOW)).toBe('just now')
+  })
+
+  it('boundary: exactly 60 seconds is "1m ago"', () => {
+    expect(formatLastSeen(NOW_SECONDS - 60, NOW)).toBe('1m ago')
+  })
+
+  it('boundary: exactly 23h59m is still hours, not a day', () => {
+    expect(formatLastSeen(NOW_SECONDS - (86400 - 60), NOW)).toBe('23h ago')
+  })
+
+  it('defaults `now` to the real current time when omitted', () => {
+    const nowSeconds = Math.floor(Date.now() / 1000)
+    expect(formatLastSeen(nowSeconds)).toBe('just now')
+  })
+})
diff --git a/webui/src/lib/last-seen.ts b/webui/src/lib/last-seen.ts
new file mode 100644
index 0000000..336f3bb
--- /dev/null
+++ b/webui/src/lib/last-seen.ts
@@ -0,0 +1,39 @@
+// Consumers page (redesign-plan.md section 3.4): pure relative-time
+// formatting for AdminUsageEntryView.lastSeen — a fleet-wide, throttled
+// (60s/replica/scope) unix-seconds timestamp (types/api.ts's own doc
+// comment). Kept out of usage-columns.ts/ConsumerDirectory.vue the same way
+// every other pure display helper in this panel (lib/format.ts, lib/
+// usage-bars.ts, lib/forecast.ts) is — vitest's node-environment config
+// exercises it directly, no component mount or fake timers required (every
+// function here takes `now` as an explicit argument, never reads Date.now()
+// itself, matching lib/forecast.ts's own determinism convention).
+
+const SECONDS_PER_MINUTE = 60
+const SECONDS_PER_HOUR = 3600
+const SECONDS_PER_DAY = 86400
+/** MONTH_THRESHOLD_DAYS is where formatLastSeen switches from "Nd ago" to "Nmo ago" — 2 months' worth of days, so a scope last seen 6 weeks ago still reads as a legible day count rather than rounding down to "1mo ago" (a needlessly coarse figure for something that recent). */
+const MONTH_THRESHOLD_DAYS = 60
+const DAYS_PER_MONTH_APPROX = 30
+
+/**
+ * formatLastSeen renders a scope's last-seen unix-seconds timestamp as a
+ * short relative-time label: "just now" under a minute, "Nm ago" under an
+ * hour, "Nh ago" under a day, "Nd ago" under MONTH_THRESHOLD_DAYS, "Nmo
+ * ago" beyond it. `undefined` or `0` means "never seen, or admin.stats.
+ * lastSeen is off" (types/api.ts's own doc comment: "never render 0 as an
+ * epoch date") — rendered as the literal "never", never "0s ago" or a
+ * fabricated 1970 date. A timestamp in the future (clock skew between this
+ * replica and the reader's own clock) clamps to "just now" rather than a
+ * nonsensical negative duration.
+ */
+export function formatLastSeen(seconds: number | undefined, now: Date = new Date()): string {
+  if (!seconds) return 'never'
+  const nowSeconds = Math.floor(now.getTime() / 1000)
+  const delta = Math.max(0, nowSeconds - seconds)
+  if (delta < SECONDS_PER_MINUTE) return 'just now'
+  if (delta < SECONDS_PER_HOUR) return `${Math.floor(delta / SECONDS_PER_MINUTE)}m ago`
+  if (delta < SECONDS_PER_DAY) return `${Math.floor(delta / SECONDS_PER_HOUR)}h ago`
+  const days = Math.floor(delta / SECONDS_PER_DAY)
+  if (days < MONTH_THRESHOLD_DAYS) return `${days}d ago`
+  return `${Math.floor(days / DAYS_PER_MONTH_APPROX)}mo ago`
+}
diff --git a/webui/src/lib/model-filter.spec.ts b/webui/src/lib/model-filter.spec.ts
index baa8dfb..e8e4bf6 100644
--- a/webui/src/lib/model-filter.spec.ts
+++ b/webui/src/lib/model-filter.spec.ts
@@ -1,38 +1,53 @@
 import { describe, expect, it } from 'vitest'
 
-import { filterModelsByPrefix } from './model-filter'
-import type { AdminUsageModelEntry } from '@/types/api'
+import { filterModelRows } from './model-filter'
+import type { ModelCatalogRow } from './model-table-columns'
 
-const models: AdminUsageModelEntry[] = [
-  { id: 'openai/gpt-5', value: 10 },
-  { id: 'openai/gpt-5-mini', value: 5 },
-  { id: 'anthropic/claude-opus', value: 8 },
+function row(overrides: Partial<ModelCatalogRow> = {}): ModelCatalogRow {
+  return {
+    id: 'openai/gpt-5',
+    model: 'gpt-5',
+    providerName: 'openai',
+    priceSource: 'builtin',
+    aliases: [],
+    requests: 0,
+    tokensIn: 0,
+    tokensOut: 0,
+    costMicroUsd: 0,
+    attempts: 0,
+    failures: 0,
+    ...overrides,
+  }
+}
+
+const rows: ModelCatalogRow[] = [
+  row({ id: 'openai/gpt-5' }),
+  row({ id: 'openai/gpt-5-mini' }),
+  row({ id: 'anthropic/claude-opus', aliases: ['smart', 'flagship'] }),
 ]
 
-describe('filterModelsByPrefix', () => {
-  it('returns every entry unchanged when the prefix is empty', () => {
-    expect(filterModelsByPrefix(models, '')).toBe(models)
+describe('filterModelRows', () => {
+  it('returns every row unchanged for an empty query', () => {
+    expect(filterModelRows(rows, '')).toBe(rows)
   })
 
-  it('keeps only ids starting with the given provider prefix', () => {
-    const result = filterModelsByPrefix(models, 'openai/')
-    expect(result.map((m) => m.id)).toEqual(['openai/gpt-5', 'openai/gpt-5-mini'])
+  it('returns every row unchanged for a whitespace-only query', () => {
+    expect(filterModelRows(rows, '   ')).toBe(rows)
   })
 
-  it('matches a full id exactly (a single-model prefix)', () => {
-    const result = filterModelsByPrefix(models, 'anthropic/claude-opus')
-    expect(result).toEqual([{ id: 'anthropic/claude-opus', value: 8 }])
+  it('matches a substring of the canonical id, case-insensitively', () => {
+    expect(filterModelRows(rows, 'GPT-5').map((r) => r.id)).toEqual(['openai/gpt-5', 'openai/gpt-5-mini'])
   })
 
-  it('returns an empty array when nothing matches the prefix', () => {
-    expect(filterModelsByPrefix(models, 'mistral/')).toEqual([])
+  it('matches a provider prefix', () => {
+    expect(filterModelRows(rows, 'anthropic/').map((r) => r.id)).toEqual(['anthropic/claude-opus'])
   })
 
-  it('is case-sensitive (ids are canonical, lowercase provider/model strings)', () => {
-    expect(filterModelsByPrefix(models, 'OpenAI/')).toEqual([])
+  it('matches an alias, case-insensitively', () => {
+    expect(filterModelRows(rows, 'FLAGSHIP').map((r) => r.id)).toEqual(['anthropic/claude-opus'])
   })
 
-  it('does not match a substring that is not a prefix', () => {
-    expect(filterModelsByPrefix(models, 'gpt-5')).toEqual([])
+  it('returns an empty array when nothing matches', () => {
+    expect(filterModelRows(rows, 'mistral')).toEqual([])
   })
 })
diff --git a/webui/src/lib/model-filter.ts b/webui/src/lib/model-filter.ts
index 0ffb114..9923622 100644
--- a/webui/src/lib/model-filter.ts
+++ b/webui/src/lib/model-filter.ts
@@ -1,15 +1,17 @@
-import type { AdminUsageModelEntry } from '@/types/api'
+import type { ModelCatalogRow } from '@/lib/model-table-columns'
 
 /**
- * filterModelsByPrefix narrows the Models tab's already-fetched ranking to
- * entries whose canonical "provider/model" id starts with `prefix` (F6,
- * dashboard-plan.md) — the client-side filter ChartsView.vue applies on
- * top of stores/history.ts's own `modelFilter` state, set by
- * ProvidersView.vue's provider-header link (nav.goToModels, stores/nav.ts
- * — WP-B1). An empty prefix is "no filter", returning `models` unchanged
- * — the default state before any provider link has been clicked.
+ * filterModelRows narrows the Models page's already-fetched catalog rows
+ * (lib/model-table-columns.ts's ModelCatalogRow, built from GET
+ * /admin/api/catalog + usage/models + performance) to whichever match a
+ * free-text query (redesign-plan.md section 3.1's Models page `q` param) —
+ * against the canonical id (ModelChip's own copyable text) OR any of the
+ * model's own aliases, case-insensitively. An empty/whitespace-only query
+ * is "no filter", returning `rows` unchanged (the pre-redesign
+ * filterModelsByPrefix this function replaces made the identical choice).
  */
-export function filterModelsByPrefix(models: AdminUsageModelEntry[], prefix: string): AdminUsageModelEntry[] {
-  if (!prefix) return models
-  return models.filter((m) => m.id.startsWith(prefix))
+export function filterModelRows(rows: ModelCatalogRow[], query: string): ModelCatalogRow[] {
+  const q = query.trim().toLowerCase()
+  if (!q) return rows
+  return rows.filter((r) => r.id.toLowerCase().includes(q) || r.aliases.some((a) => a.toLowerCase().includes(q)))
 }
diff --git a/webui/src/lib/model-table-columns.spec.ts b/webui/src/lib/model-table-columns.spec.ts
index e4881c3..e472d05 100644
--- a/webui/src/lib/model-table-columns.spec.ts
+++ b/webui/src/lib/model-table-columns.spec.ts
@@ -2,138 +2,257 @@ import type { VNode } from 'vue'
 import { isVNode } from 'vue'
 import { describe, expect, it } from 'vitest'
 
+import EntityLink from '@/components/EntityLink.vue'
 import ModelChip from '@/components/ModelChip.vue'
-import ScopeLink from '@/components/ScopeLink.vue'
 import { Badge } from '@/components/ui/badge'
-import { modelTableColumns } from './model-table-columns'
-import type { AdminUsageModelEntry } from '@/types/api'
+import { buildModelCatalogRows, modelCatalogColumns } from './model-table-columns'
+import type { ModelCatalogRow } from './model-table-columns'
+import type { AdminCatalogResponse, AdminPerfResponse, AdminUsageModelsResponse } from '@/types/api'
 
-function testEntry(overrides: Partial<AdminUsageModelEntry> = {}): AdminUsageModelEntry {
+function testRow(overrides: Partial<ModelCatalogRow> = {}): ModelCatalogRow {
   return {
     id: 'openai/gpt-5',
-    value: 42,
-    requests: 10,
-    tokensIn: 100,
-    tokensOut: 200,
-    costMicroUsd: 1_234_500,
-    free: false,
+    model: 'gpt-5',
+    providerName: 'openai',
+    priceSource: 'builtin',
+    aliases: [],
+    requests: 0,
+    tokensIn: 0,
+    tokensOut: 0,
+    costMicroUsd: 0,
+    attempts: 0,
+    failures: 0,
     ...overrides,
   }
 }
 
-function accessorFnOf(col: unknown): (row: AdminUsageModelEntry, index: number) => unknown {
-  return (col as { accessorFn: (row: AdminUsageModelEntry, index: number) => unknown }).accessorFn
+function accessorFnOf(col: unknown): (row: ModelCatalogRow, index: number) => unknown {
+  return (col as { accessorFn: (row: ModelCatalogRow, index: number) => unknown }).accessorFn
 }
 
-function cellOf(col: unknown): (ctx: { row: { original: AdminUsageModelEntry } }) => unknown {
-  return (col as { cell: (ctx: { row: { original: AdminUsageModelEntry } }) => unknown }).cell
+function cellOf(col: unknown): (ctx: { row: { original: ModelCatalogRow } }) => unknown {
+  return (col as { cell: (ctx: { row: { original: ModelCatalogRow } }) => unknown }).cell
 }
 
-describe('modelTableColumns: Model column', () => {
-  const columns = modelTableColumns()
-  const col = columns.find((c) => c.id === 'model')
+describe('buildModelCatalogRows', () => {
+  function catalog(): AdminCatalogResponse {
+    return {
+      providers: [
+        {
+          lastRefresh: '2026-01-01T00:00:00Z',
+          openUntil: '0001-01-01T00:00:00Z',
+          name: 'openai',
+          type: 'openai',
+          healthState: 'closed',
+          discoveryEnabled: true,
+          models: [
+            { id: 'openai/gpt-5', model: 'gpt-5', priceSource: 'builtin', inputPerMTokUsd: 1.5, outputPerMTokUsd: 6 },
+            { id: 'openai/gpt-5-mini', model: 'gpt-5-mini', priceSource: 'unpriced' },
+          ],
+        },
+      ],
+      aliases: [],
+    }
+  }
 
-  it('accessorFn reads the raw canonical id (no routableModelId join — id is already provider/model)', () => {
-    expect(accessorFnOf(col)(testEntry({ id: 'anthropic/claude' }), 0)).toBe('anthropic/claude')
+  function ranking(): AdminUsageModelsResponse {
+    return {
+      metric: 'cost',
+      window: 'day',
+      span: 7,
+      offset: 0,
+      detail: true,
+      models: [{ id: 'openai/gpt-5', value: 5, requests: 10, tokensIn: 100, tokensOut: 200, costMicroUsd: 5_000_000 }],
+    }
+  }
+
+  function perf(): AdminPerfResponse {
+    return {
+      kind: 'model',
+      window: 'day',
+      span: 7,
+      offset: 0,
+      latencyEnabled: true,
+      rows: [{ id: 'openai/gpt-5', p50Ms: 120, p95Ms: 400, count: 10, attempts: 10, failures: 1 }],
+    }
+  }
+
+  it('produces one row per CATALOG model, not per ranking/performance row', () => {
+    const rows = buildModelCatalogRows(catalog(), ranking(), perf())
+    expect(rows).toHaveLength(2)
+    expect(rows.map((r) => r.id)).toEqual(['openai/gpt-5', 'openai/gpt-5-mini'])
   })
 
-  it('cell renders a ModelChip with the id, no context/cost props (this table has no resolved metadata to pass)', () => {
-    const rendered = cellOf(col)({ row: { original: testEntry({ id: 'anthropic/claude' }) } }) as VNode
+  it('joins ranking and performance fields onto a matching catalog row', () => {
+    const rows = buildModelCatalogRows(catalog(), ranking(), perf())
+    const row = rows.find((r) => r.id === 'openai/gpt-5')
+    expect(row).toMatchObject({
+      requests: 10,
+      tokensIn: 100,
+      tokensOut: 200,
+      costMicroUsd: 5_000_000,
+      p50Ms: 120,
+      p95Ms: 400,
+      attempts: 10,
+      failures: 1,
+    })
+  })
+
+  it('defaults usage/performance fields to zero/undefined for a catalog model with no traffic', () => {
+    const rows = buildModelCatalogRows(catalog(), ranking(), perf())
+    const row = rows.find((r) => r.id === 'openai/gpt-5-mini')
+    expect(row).toMatchObject({ requests: 0, tokensIn: 0, tokensOut: 0, costMicroUsd: 0, attempts: 0, failures: 0 })
+    expect(row?.p50Ms).toBeUndefined()
+    expect(row?.p95Ms).toBeUndefined()
+  })
+
+  it('carries priceSource/displayFree/aliases straight from the catalog model', () => {
+    const c = catalog()
+    c.providers[0].models[0].displayFree = true
+    c.providers[0].models[0].aliases = ['smart']
+    const rows = buildModelCatalogRows(c, ranking(), perf())
+    const row = rows.find((r) => r.id === 'openai/gpt-5')
+    expect(row?.priceSource).toBe('builtin')
+    expect(row?.displayFree).toBe(true)
+    expect(row?.aliases).toEqual(['smart'])
+  })
+
+  it('defaults aliases to an empty array when the catalog model omits it', () => {
+    const rows = buildModelCatalogRows(catalog(), ranking(), perf())
+    expect(rows.find((r) => r.id === 'openai/gpt-5-mini')?.aliases).toEqual([])
+  })
+})
+
+describe('modelCatalogColumns: id column', () => {
+  const col = modelCatalogColumns().find((c) => c.id === 'id')
+
+  it('cell renders a ModelChip and an EntityLink pointed at kind "model"', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ id: 'anthropic/claude' }) } }) as VNode
     const children = rendered.children as VNode[]
     const chip = children.find((c) => c.type === ModelChip)
-    expect(chip).toBeDefined()
+    const link = children.find((c) => c.type === EntityLink)
     expect(chip?.props?.id).toBe('anthropic/claude')
-  })
-
-  it('cell renders a ScopeLink pointed at "model:{id}"', () => {
-    const rendered = cellOf(col)({ row: { original: testEntry({ id: 'anthropic/claude' }) } }) as VNode
-    const children = rendered.children as VNode[]
-    const link = children.find((c) => c.type === ScopeLink)
-    expect(link).toBeDefined()
-    expect(link?.props?.scope).toBe('model:anthropic/claude')
+    expect(link?.props?.kind).toBe('model')
+    expect(link?.props?.id).toBe('anthropic/claude')
     expect(link?.props?.label).toBe('anthropic/claude')
   })
 })
 
-describe('modelTableColumns: detail count columns sort on raw numbers, render CompactNumber', () => {
-  const columns = modelTableColumns()
+describe('modelCatalogColumns: price column', () => {
+  const col = modelCatalogColumns().find((c) => c.id === 'price')
 
-  it.each([
-    ['requests', (e: AdminUsageModelEntry) => e.requests],
-    ['tokensIn', (e: AdminUsageModelEntry) => e.tokensIn],
-    ['tokensOut', (e: AdminUsageModelEntry) => e.tokensOut],
-  ] as const)('%s accessorFn returns the raw detail number, not a compact string', (id, read) => {
-    const col = columns.find((c) => c.id === id)
-    const entry = testEntry({ requests: 15_000_000, tokensIn: 999, tokensOut: 12_000 })
-    expect(accessorFnOf(col)(entry, 0)).toBe(read(entry))
-  })
-
-  it.each(['requests', 'tokensIn', 'tokensOut'] as const)('%s cell renders a CompactNumber vnode', (id) => {
-    const col = columns.find((c) => c.id === id)
-    const rendered = cellOf(col)({ row: { original: testEntry() } })
-    expect(isVNode(rendered)).toBe(true)
-  })
-
-  it.each(['requests', 'tokensIn', 'tokensOut'] as const)(
-    '%s falls back to 0 (never undefined) when detail was not requested, defensively',
-    (id) => {
-      const col = columns.find((c) => c.id === id)
-      const entry = testEntry({ requests: undefined, tokensIn: undefined, tokensOut: undefined })
-      expect(accessorFnOf(col)(entry, 0)).toBe(0)
-    },
-  )
-
-  it('sorting by requests orders numerically, not lexicographically', () => {
-    const col = columns.find((c) => c.id === 'requests')
-    const accessor = accessorFnOf(col)
-    const entries = [
-      testEntry({ id: 'a', requests: 15_000_000 }),
-      testEntry({ id: 'b', requests: 999 }),
-      testEntry({ id: 'c', requests: 12_000 }),
-    ]
-    const sorted = [...entries].sort((x, y) => (accessor(x, 0) as number) - (accessor(y, 0) as number))
-    expect(sorted.map((e) => e.id)).toEqual(['b', 'c', 'a'])
-  })
-})
-
-describe('modelTableColumns: Cost column', () => {
-  const columns = modelTableColumns()
-  const col = columns.find((c) => c.id === 'cost')
-
-  it('accessorFn reads the raw micro-USD cost, even for a free model (real 0, not omitted)', () => {
-    expect(accessorFnOf(col)(testEntry({ costMicroUsd: 1_234_500, free: false }), 0)).toBe(1_234_500)
-    expect(accessorFnOf(col)(testEntry({ costMicroUsd: 0, free: true }), 0)).toBe(0)
-  })
-
-  it('renders plain formatCost text for a priced (non-free) entry', () => {
-    const rendered = cellOf(col)({ row: { original: testEntry({ costMicroUsd: 1_234_500, free: false }) } })
-    expect(isVNode(rendered)).toBe(false)
-    expect(rendered).toBe('$1.2345')
-  })
-
-  it('shows the real recorded cost, not the badge, for a model marked free after it accrued cost', () => {
-    const rendered = cellOf(col)({ row: { original: testEntry({ costMicroUsd: 1_234_500, free: true }) } })
-    expect(isVNode(rendered)).toBe(false)
-    expect(rendered).toBe('$1.2345')
-  })
-
-  it('renders a Badge with the accessible text "free" for a free entry, instead of $0', () => {
-    const rendered = cellOf(col)({ row: { original: testEntry({ costMicroUsd: 0, free: true }) } }) as VNode
+  it('renders a destructive "unpriced" Badge for priceSource "unpriced"', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ priceSource: 'unpriced' }) } }) as VNode
     expect(rendered.type).toBe(Badge)
-    expect(typeof rendered.children).toBe('object')
-    const slotDefault = (rendered.children as { default: () => unknown }).default
-    expect(slotDefault()).toBe('free')
+    expect(rendered.props?.variant).toBe('destructive')
   })
 
-  it('a free entry still sorts by its real (0) cost, not excluded or reordered by the badge', () => {
-    const entries = [testEntry({ id: 'paid', costMicroUsd: 5_000_000, free: false }), testEntry({ id: 'free', costMicroUsd: 0, free: true })]
+  it('renders a "free" Badge for priceSource "free"', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ priceSource: 'free' }) } }) as VNode
+    expect(rendered.type).toBe(Badge)
+    const slot = (rendered.children as { default: () => string }).default
+    expect(slot()).toBe('free')
+  })
+
+  it('renders the formatted price plus a source Badge for override/builtin/litellm', () => {
+    const rendered = cellOf(col)({
+      row: { original: testRow({ priceSource: 'litellm', inputPerMTokUsd: 1, outputPerMTokUsd: 2 }) },
+    }) as VNode
+    const children = rendered.children as VNode[]
+    expect((children[0] as VNode).children).toBe('in $1.00 / out $2.00 per MTok')
+    const badge = children[1] as VNode
+    expect(badge.type).toBe(Badge)
+    expect((badge.children as { default: () => string }).default()).toBe('litellm')
+  })
+
+  it('renders an em dash placeholder for a priced source with unknown per-token cost (version skew)', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ priceSource: 'override' }) } }) as VNode
+    const children = rendered.children as VNode[]
+    expect((children[0] as VNode).children).toBe('—')
+  })
+
+  it('sorts unpriced first, then ascending by input price', () => {
     const accessor = accessorFnOf(col)
-    const sorted = [...entries].sort((x, y) => (accessor(y, 0) as number) - (accessor(x, 0) as number)) // desc
-    expect(sorted.map((e) => e.id)).toEqual(['paid', 'free'])
+    const rows = [
+      testRow({ id: 'a', priceSource: 'builtin', inputPerMTokUsd: 5 }),
+      testRow({ id: 'b', priceSource: 'unpriced' }),
+      testRow({ id: 'c', priceSource: 'builtin', inputPerMTokUsd: 1 }),
+    ]
+    const sorted = [...rows].sort((x, y) => (accessor(x, 0) as number) - (accessor(y, 0) as number))
+    expect(sorted.map((r) => r.id)).toEqual(['b', 'c', 'a'])
   })
+})
 
-  it('falls back to formatCost($0) when free is false/undefined and costMicroUsd is undefined (detail not requested)', () => {
-    const rendered = cellOf(col)({ row: { original: testEntry({ costMicroUsd: undefined, free: undefined }) } })
-    expect(rendered).toBe('$0.0000')
+describe('modelCatalogColumns: free column (":free" suffix, distinct from priceSource)', () => {
+  const col = modelCatalogColumns().find((c) => c.id === 'free')
+
+  it('renders a Badge only when displayFree is true', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ displayFree: true }) } }) as VNode
+    expect(rendered.type).toBe(Badge)
+  })
+
+  it('renders an em dash when displayFree is false/undefined, even for priceSource "free"', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ priceSource: 'free' }) } })
+    expect(isVNode(rendered) && rendered.type).toBe('span')
+    expect(isVNode(rendered) && rendered.children).toBe('—')
+  })
+})
+
+describe('modelCatalogColumns: aliases column', () => {
+  const col = modelCatalogColumns().find((c) => c.id === 'aliases')
+
+  it('renders an em dash for an empty alias list', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ aliases: [] }) } })
+    expect(isVNode(rendered) && rendered.children).toBe('—')
+  })
+
+  it('renders one Badge per alias', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ aliases: ['a', 'b'] }) } }) as VNode
+    const children = rendered.children as VNode[]
+    expect(children).toHaveLength(2)
+    expect(children.every((c) => c.type === Badge)).toBe(true)
+  })
+})
+
+describe('modelCatalogColumns: cost column', () => {
+  const col = modelCatalogColumns().find((c) => c.id === 'cost')
+
+  it('renders a "free" Badge for a zero-cost free/displayFree row instead of $0.0000', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ priceSource: 'free', costMicroUsd: 0 }) } }) as VNode
+    expect(rendered.type).toBe(Badge)
+    const rendered2 = cellOf(col)({ row: { original: testRow({ displayFree: true, costMicroUsd: 0 }) } }) as VNode
+    expect(rendered2.type).toBe(Badge)
+  })
+
+  it('renders the real formatted cost when non-zero, even if free', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ priceSource: 'free', costMicroUsd: 1_234_500 }) } })
+    expect(rendered).toBe('$1.2345')
+  })
+
+  it('renders plain formatCost for a priced, non-free row', () => {
+    const rendered = cellOf(col)({ row: { original: testRow({ costMicroUsd: 2_000_000 }) } })
+    expect(rendered).toBe('$2.0000')
+  })
+})
+
+describe('modelCatalogColumns: p50/p95/error rate columns', () => {
+  it('p50/p95 render an em dash when undefined, formatted latency otherwise', () => {
+    const p50 = modelCatalogColumns().find((c) => c.id === 'p50')
+    const p95 = modelCatalogColumns().find((c) => c.id === 'p95')
+    expect(cellOf(p50)({ row: { original: testRow() } })).toMatchObject({ children: '—' })
+    expect(cellOf(p95)({ row: { original: testRow({ p95Ms: 1500 }) } })).toMatchObject({ children: '1.5s' })
+  })
+
+  it('error rate renders "no data" for zero attempts, a ceiled percent otherwise', () => {
+    const col = modelCatalogColumns().find((c) => c.id === 'errorRate')
+    expect(cellOf(col)({ row: { original: testRow({ attempts: 0, failures: 0 }) } })).toMatchObject({ children: 'no data' })
+    expect(cellOf(col)({ row: { original: testRow({ attempts: 100, failures: 1 }) } })).toMatchObject({ children: '1%' })
+  })
+
+  it('error rate sorts a no-traffic row (-1) below every real rate', () => {
+    const col = modelCatalogColumns().find((c) => c.id === 'errorRate')
+    const accessor = accessorFnOf(col)
+    expect(accessor(testRow({ attempts: 0, failures: 0 }), 0)).toBe(-1)
+    expect(accessor(testRow({ attempts: 10, failures: 0 }), 0)).toBe(0)
   })
 })
diff --git a/webui/src/lib/model-table-columns.ts b/webui/src/lib/model-table-columns.ts
index e4f088b..3a51b38 100644
--- a/webui/src/lib/model-table-columns.ts
+++ b/webui/src/lib/model-table-columns.ts
@@ -2,109 +2,266 @@ import type { ColumnDef } from '@tanstack/vue-table'
 import { h } from 'vue'
 
 import CompactNumber from '@/components/CompactNumber.vue'
+import EntityLink from '@/components/EntityLink.vue'
 import ModelChip from '@/components/ModelChip.vue'
-import ScopeLink from '@/components/ScopeLink.vue'
 import { Badge } from '@/components/ui/badge'
-import { formatCost } from '@/lib/format'
-import type { AdminUsageModelEntry } from '@/types/api'
+import { formatContextWindow, formatCost, formatLatencyMs, formatModelCostHover } from '@/lib/format'
+import { formatErrorRatePercent, providerErrorRate } from '@/lib/provider-rate'
+import type { AdminCatalogResponse, AdminPerfResponse, AdminUsageModelsResponse, PriceSource } from '@/types/api'
 
 /**
- * modelColumn renders a ranked row's id as a ModelChip (the same copyable
- * chip ProvidersView.vue's own per-model list renders) beside a ScopeLink
- * that jumps to Charts scoped to this exact model — the identical pair
- * ProvidersView.vue already builds from `routableModelId(provider, model)`,
- * reused here rather than a third hand-rolled copy (vue.md: "if you've
- * written it twice, you owe an abstraction"). No routableModelId join is
- * needed: `id` is already the canonical "provider/model" form
- * (AdminUsageModelEntry's own doc comment, types/api.ts).
+ * ModelCatalogRow (redesign-plan.md section 3.4: "join catalog + ranking +
+ * performance") is the Models page's one row shape, built by
+ * buildModelCatalogRows below from THREE independent responses: GET
+ * /admin/api/catalog (stores/catalog.ts, WP-D — every configured model,
+ * regardless of traffic), GET /admin/api/usage/models?detail=1 (the
+ * current global range's ranking — zero for a model with no traffic in
+ * range), and GET /admin/api/performance?kind=model (fleet p50/p95/
+ * attempts/failures — top 50 by req in span, server default; a model
+ * outside that top 50 simply carries zero attempts/failures here, same as
+ * one with no ranking entry).
+ *
+ * The catalog is the DRIVING list (one row per catalog model, not per
+ * ranking/performance row) — this is a catalog table first, matching
+ * AdminCatalogModel's own doc comment ("computed for EVERY catalog model,
+ * not just ones with observed traffic").
  */
-function modelColumn(): ColumnDef<AdminUsageModelEntry, unknown> {
-  return {
-    id: 'model',
-    header: 'Model',
-    accessorFn: (entry) => entry.id,
-    cell: ({ row }) =>
-      h('span', { class: 'inline-flex flex-wrap items-center gap-1.5' }, [
-        h(ModelChip, { id: row.original.id }),
-        h(ScopeLink, { label: row.original.id, scope: `model:${row.original.id}` }),
-      ]),
-  }
+export interface ModelCatalogRow {
+  /** Canonical "provider/model" — the join key across all three source responses. */
+  id: string
+  /** The bare upstream model id, without the provider prefix (AdminCatalogModel.model). */
+  model: string
+  providerName: string
+  contextTokens?: number
+  inputPerMTokUsd?: number
+  outputPerMTokUsd?: number
+  priceSource: PriceSource
+  /** True for a ':free' suffix model — display-only; priceSource carries the real billing truth regardless (types/api.ts's own AdminCatalogModel doc comment). */
+  displayFree?: boolean
+  aliases: string[]
+  requests: number
+  tokensIn: number
+  tokensOut: number
+  costMicroUsd: number
+  p50Ms?: number
+  p95Ms?: number
+  attempts: number
+  failures: number
 }
 
 /**
- * numericDetailColumn builds one right-aligned, sortable count column
- * reading a `detail=1`-only field (requests/tokensIn/tokensOut —
- * AdminUsageModelEntry's own doc comment): undefined only when the caller
- * fetched without `detail=1`, which stores/history.ts's fetchModelRanking
- * never does any more (free-models-plan.md) — `?? 0` covers that
- * theoretical case defensively, the same fallback numericColumn
- * (usage-columns.ts) applies for its own optional fields, never a silent
- * mis-sort of a genuine 0 count. Rendered via CompactNumber, mirroring
- * every other count column in this panel (usage-columns.ts,
- * target-columns.ts).
+ * buildModelCatalogRows joins the three source responses by canonical id.
+ * Pure and Vue-free — testable directly, and reusable by stores/models.ts
+ * without that store needing to know the join's own internals.
  */
-function numericDetailColumn(
-  id: string,
-  header: string,
-  read: (entry: AdminUsageModelEntry) => number | undefined,
-): ColumnDef<AdminUsageModelEntry, unknown> {
-  return {
-    id,
-    header,
-    accessorFn: (entry) => read(entry) ?? 0,
-    meta: { align: 'right' },
-    cell: ({ row }) => h(CompactNumber, { value: read(row.original) ?? 0 }),
+export function buildModelCatalogRows(
+  catalog: AdminCatalogResponse,
+  ranking: AdminUsageModelsResponse,
+  perf: AdminPerfResponse,
+): ModelCatalogRow[] {
+  const rankingById = new Map(ranking.models.map((m) => [m.id, m]))
+  const perfById = new Map((perf.rows ?? []).map((r) => [r.id, r]))
+
+  const rows: ModelCatalogRow[] = []
+  for (const provider of catalog.providers) {
+    for (const m of provider.models) {
+      const usage = rankingById.get(m.id)
+      const perfRow = perfById.get(m.id)
+      rows.push({
+        id: m.id,
+        model: m.model,
+        providerName: provider.name,
+        contextTokens: m.contextTokens,
+        inputPerMTokUsd: m.inputPerMTokUsd,
+        outputPerMTokUsd: m.outputPerMTokUsd,
+        priceSource: m.priceSource,
+        displayFree: m.displayFree,
+        aliases: m.aliases ?? [],
+        requests: usage?.requests ?? 0,
+        tokensIn: usage?.tokensIn ?? 0,
+        tokensOut: usage?.tokensOut ?? 0,
+        costMicroUsd: usage?.costMicroUsd ?? 0,
+        p50Ms: perfRow?.p50Ms,
+        p95Ms: perfRow?.p95Ms,
+        attempts: perfRow?.attempts ?? 0,
+        failures: perfRow?.failures ?? 0,
+      })
+    }
   }
+  return rows
+}
+
+/** PRICE_SOURCE_LABEL is the price-source Badge's visible text for the three "priced by a rule" sources — 'free'/'unpriced' get their own dedicated badge treatment in priceCell below, never this generic label. */
+const PRICE_SOURCE_LABEL: Record<Extract<PriceSource, 'override' | 'builtin' | 'litellm'>, string> = {
+  override: 'override',
+  builtin: 'builtin',
+  litellm: 'litellm',
+}
+
+function priceCell(row: ModelCatalogRow) {
+  if (row.priceSource === 'unpriced') {
+    return h(
+      Badge,
+      { as: 'span', variant: 'destructive', class: 'font-normal', title: 'No pricing rule matched — billed as $0.' },
+      () => 'unpriced',
+    )
+  }
+  if (row.priceSource === 'free') {
+    return h(Badge, { as: 'span', variant: 'secondary', class: 'font-normal', title: 'Configured free (modelMeta.free) — priced at $0.' }, () => 'free')
+  }
+  const known = row.inputPerMTokUsd !== undefined && row.outputPerMTokUsd !== undefined
+  // Narrowed to a local BEFORE the h() callback below — TS control-flow
+  // narrowing on `row.priceSource` (from the two early returns above)
+  // does not cross a closure boundary, so the callback itself still sees
+  // the full PriceSource union unless the already-narrowed value is
+  // captured into its own variable first.
+  const source = row.priceSource as Exclude<PriceSource, 'unpriced' | 'free'>
+  return h('span', { class: 'inline-flex flex-wrap items-center gap-1.5' }, [
+    h('span', {}, known ? formatModelCostHover(row.inputPerMTokUsd as number, row.outputPerMTokUsd as number) : '—'),
+    h(Badge, { as: 'span', variant: 'outline', class: 'font-normal' }, () => PRICE_SOURCE_LABEL[source]),
+  ])
 }
 
 /**
- * costColumn renders a "free" Badge (accessible text "free" —
- * free-models-plan.md's own explicit requirement) in place of the dollar
- * figure whenever `entry.free` is true and no cost was recorded, plain
- * formatCost otherwise.
- * Sorting is unaffected by the badge: the accessorFn always reads the raw
- * costMicroUsd number (0 for a free model, same as any other zero cost),
- * so a cost-descending sort still puts every free model at the bottom
- * exactly where a real $0 belongs — only the DISPLAYED cell changes.
+ * priceSortValue orders unpriced first (nothing to report, worth an
+ * operator's attention), then by ascending input price — accessorFn's
+ * numeric return, not the rendered text, is what DataTable actually sorts
+ * on.
  */
-function costColumn(): ColumnDef<AdminUsageModelEntry, unknown> {
-  return {
-    id: 'cost',
-    header: 'Cost',
-    accessorFn: (entry) => entry.costMicroUsd ?? 0,
-    meta: { align: 'right' },
-    cell: ({ row }) => {
-      const entry = row.original
-      // A model marked free now may still carry cost recorded before it was
-      // marked free: show the real dollars then, not the badge.
-      if (entry.free && (entry.costMicroUsd ?? 0) === 0) {
-        return h(Badge, { as: 'span', variant: 'secondary', class: 'font-normal', title: 'priced at $0 per token' }, () => 'free')
-      }
-      return formatCost(entry.costMicroUsd ?? 0)
-    },
-  }
+function priceSortValue(row: ModelCatalogRow): number {
+  if (row.priceSource === 'unpriced') return -1
+  return row.inputPerMTokUsd ?? 0
 }
 
 /**
- * modelTableColumns builds the Models tab's ranking table (free-models-
- * plan.md, UI section): Model, Requests, Tokens in, Tokens out, Cost. Every
- * numeric column reads its OWN `detail=1` field independently of whichever
- * metric the ranking is currently sorted by (stores/history.ts's
- * modelMetric) — the table always shows all four figures per row, so a
- * reader ranking by cost can still see a model's request count (and vice
- * versa) without switching the ranking metric. The server already returns
- * the ranking sorted by the ranked metric descending (ModelUsageChart.vue's
- * own doc comment), and DataTable.vue's uncontrolled sort state starts
- * empty, so that server order — "current metric desc" — is exactly what
- * renders before any header is clicked; no explicit initial `sorting` prop
- * is needed here.
+ * modelCatalogColumns builds the Models page's catalog table (redesign-
+ * plan.md section 3.4): id, context, price + source badge, free (the
+ * ':free' suffix flag — distinct from the price column's own 'free'
+ * priceSource badge, see ModelCatalogRow's own doc comment), aliases,
+ * req/tokens/cost for the current global range, p50/p95, and error rate.
+ * p50/p95 read "—" whenever undefined, regardless of WHY (no observations
+ * yet, or admin.stats.latency off entirely) — ModelCatalogTable.vue itself
+ * carries the admin.stats.latency hint at the table level (task
+ * instruction: "handle latencyEnabled=false with a hint naming
+ * admin.stats.latency"), not repeated on every row.
  */
-export function modelTableColumns(): ColumnDef<AdminUsageModelEntry, unknown>[] {
+export function modelCatalogColumns(): ColumnDef<ModelCatalogRow, unknown>[] {
   return [
-    modelColumn(),
-    numericDetailColumn('requests', 'Requests', (e) => e.requests),
-    numericDetailColumn('tokensIn', 'Tokens in', (e) => e.tokensIn),
-    numericDetailColumn('tokensOut', 'Tokens out', (e) => e.tokensOut),
-    costColumn(),
+    {
+      id: 'id',
+      header: 'Model',
+      accessorFn: (r) => r.id,
+      cell: ({ row }) =>
+        h('span', { class: 'inline-flex flex-wrap items-center gap-1.5' }, [
+          h(ModelChip, {
+            id: row.original.id,
+            contextTokens: row.original.contextTokens,
+            inputPerMTokUsd: row.original.inputPerMTokUsd,
+            outputPerMTokUsd: row.original.outputPerMTokUsd,
+          }),
+          h(EntityLink, { label: row.original.id, kind: 'model', id: row.original.id }),
+        ]),
+    },
+    {
+      id: 'context',
+      header: 'Context',
+      meta: { align: 'right' },
+      accessorFn: (r) => r.contextTokens ?? 0,
+      cell: ({ row }) =>
+        h(
+          'span',
+          { class: 'tabular-nums' },
+          row.original.contextTokens !== undefined ? formatContextWindow(row.original.contextTokens) : '—',
+        ),
+    },
+    {
+      id: 'price',
+      header: 'Price',
+      accessorFn: (r) => priceSortValue(r),
+      cell: ({ row }) => priceCell(row.original),
+    },
+    {
+      id: 'free',
+      header: 'Free',
+      accessorFn: (r) => (r.displayFree ? 1 : 0),
+      cell: ({ row }) =>
+        row.original.displayFree
+          ? h(
+              Badge,
+              { as: 'span', variant: 'secondary', class: 'font-normal', title: "':free' suffix model — display-only, billing follows the Price column's own source" },
+              () => 'free',
+            )
+          : h('span', { class: 'text-muted-foreground' }, '—'),
+    },
+    {
+      id: 'aliases',
+      header: 'Aliases',
+      enableSorting: false,
+      accessorFn: (r) => r.aliases.join(', '),
+      cell: ({ row }) => {
+        const aliases = row.original.aliases
+        if (aliases.length === 0) return h('span', { class: 'text-muted-foreground' }, '—')
+        return h(
+          'div',
+          { class: 'flex flex-wrap gap-1' },
+          aliases.map((a) => h(Badge, { key: a, as: 'span', variant: 'outline', class: 'font-mono font-normal' }, () => a)),
+        )
+      },
+    },
+    {
+      id: 'requests',
+      header: 'Requests',
+      meta: { align: 'right' },
+      accessorFn: (r) => r.requests,
+      cell: ({ row }) => h(CompactNumber, { value: row.original.requests }),
+    },
+    {
+      id: 'tokensIn',
+      header: 'Tokens in',
+      meta: { align: 'right' },
+      accessorFn: (r) => r.tokensIn,
+      cell: ({ row }) => h(CompactNumber, { value: row.original.tokensIn }),
+    },
+    {
+      id: 'tokensOut',
+      header: 'Tokens out',
+      meta: { align: 'right' },
+      accessorFn: (r) => r.tokensOut,
+      cell: ({ row }) => h(CompactNumber, { value: row.original.tokensOut }),
+    },
+    {
+      id: 'cost',
+      header: 'Cost',
+      meta: { align: 'right' },
+      accessorFn: (r) => r.costMicroUsd,
+      cell: ({ row }) => {
+        const r = row.original
+        if ((r.priceSource === 'free' || r.displayFree) && r.costMicroUsd === 0) {
+          return h(Badge, { as: 'span', variant: 'secondary', class: 'font-normal', title: 'priced at $0 per token' }, () => 'free')
+        }
+        return formatCost(r.costMicroUsd)
+      },
+    },
+    {
+      id: 'p50',
+      header: 'p50',
+      meta: { align: 'right' },
+      accessorFn: (r) => r.p50Ms ?? -1,
+      cell: ({ row }) => h('span', { class: 'tabular-nums' }, row.original.p50Ms !== undefined ? formatLatencyMs(row.original.p50Ms) : '—'),
+    },
+    {
+      id: 'p95',
+      header: 'p95',
+      meta: { align: 'right' },
+      accessorFn: (r) => r.p95Ms ?? -1,
+      cell: ({ row }) => h('span', { class: 'tabular-nums' }, row.original.p95Ms !== undefined ? formatLatencyMs(row.original.p95Ms) : '—'),
+    },
+    {
+      id: 'errorRate',
+      header: 'Error rate',
+      meta: { align: 'right' },
+      accessorFn: (r) => providerErrorRate(r.attempts, r.failures) ?? -1,
+      cell: ({ row }) => h('span', { class: 'tabular-nums' }, formatErrorRatePercent(providerErrorRate(row.original.attempts, row.original.failures))),
+    },
   ]
 }
diff --git a/webui/src/lib/pages.ts b/webui/src/lib/pages.ts
new file mode 100644
index 0000000..c2deb21
--- /dev/null
+++ b/webui/src/lib/pages.ts
@@ -0,0 +1,48 @@
+import {
+  faCoins,
+  faCubes,
+  faHeartPulse,
+  faHouse,
+  faPlug,
+  faSliders,
+  faUsers,
+} from '@fortawesome/free-solid-svg-icons'
+import type { IconDefinition } from '@fortawesome/free-solid-svg-icons'
+
+/**
+ * PAGE_IDS is the sidebar redesign's page union (redesign-plan.md section
+ * 3.1) — replaces composables/useTabHash.ts's old flat TAB_VALUES. The
+ * single source of truth for every "which page" check: SidebarNav.vue's
+ * link list, stores/nav.ts's `page` state, and lib/hash-state.ts's
+ * outer "#<page>" segment all import PAGE_IDS/PageId rather than each
+ * redeclaring their own copy.
+ */
+export const PAGE_IDS = ['home', 'spend', 'consumers', 'models', 'reliability', 'config', 'targets'] as const
+
+export type PageId = (typeof PAGE_IDS)[number]
+
+/** The landing page when the hash names nothing recognized, or is absent (first load). */
+export const DEFAULT_PAGE: PageId = 'home'
+
+/** One sidebar entry: the page it navigates to, its visible label, and its icon (redesign-plan.md section 3.1's fixed icon list). */
+export interface PageNavEntry {
+  id: PageId
+  label: string
+  icon: IconDefinition
+}
+
+/** PAGE_NAV drives SidebarNav.vue's link list, in display order. */
+export const PAGE_NAV: readonly PageNavEntry[] = [
+  { id: 'home', label: 'Home', icon: faHouse },
+  { id: 'spend', label: 'Spend', icon: faCoins },
+  { id: 'consumers', label: 'Consumers', icon: faUsers },
+  { id: 'models', label: 'Models', icon: faCubes },
+  { id: 'reliability', label: 'Reliability', icon: faHeartPulse },
+  { id: 'config', label: 'Config', icon: faSliders },
+  { id: 'targets', label: 'MCP & Agents', icon: faPlug },
+]
+
+/** isPageId is a runtime type guard against PAGE_IDS — the only place that string union is checked against untrusted input (a hash, a hand-typed URL). */
+export function isPageId(value: string): value is PageId {
+  return (PAGE_IDS as readonly string[]).includes(value)
+}
diff --git a/webui/src/lib/polling.ts b/webui/src/lib/polling.ts
index f329652..4750830 100644
--- a/webui/src/lib/polling.ts
+++ b/webui/src/lib/polling.ts
@@ -1,8 +1,10 @@
 // createVisibilityPoller is the ONE polling primitive stores/dashboard.ts,
-// stores/history.ts, and stores/events.ts each wire their own refresh
-// action into (vue.md: "if you've written it twice, you owe an
-// abstraction") — three near-identical setInterval-plus-immediate-tick
-// blocks collapsed into one tested module. Beyond the plain interval every
+// stores/spend.ts, stores/events.ts, and composables/useNow.ts each wire
+// their own refresh action into (vue.md: "if you've written it twice,
+// you owe an abstraction") — originally three near-identical
+// setInterval-plus-immediate-tick blocks (including the pre-redesign
+// stores/history.ts, since deleted) collapsed into one tested module.
+// Beyond the plain interval every
 // one of them already had, this adds visibility awareness: a background
 // browser tab has no reason to keep polling a Redis-backed admin panel
 // every 5s/30s for no reader to see, and it catches back up the instant
diff --git a/webui/src/lib/pricing-health.spec.ts b/webui/src/lib/pricing-health.spec.ts
new file mode 100644
index 0000000..15df3c6
--- /dev/null
+++ b/webui/src/lib/pricing-health.spec.ts
@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'vitest'
+
+import { joinPricingHealth, pricingHealthOrder } from './pricing-health'
+import type { AdminCatalogModel, AdminUsageModelEntry } from '@/types/api'
+
+describe('joinPricingHealth', () => {
+  const catalog = new Map<string, AdminCatalogModel>([
+    [
+      'a/priced',
+      {
+        id: 'a/priced',
+        model: 'priced',
+        priceSource: 'builtin',
+        contextTokens: 128000,
+        inputPerMTokUsd: 1,
+        outputPerMTokUsd: 2,
+        aliases: ['a/alias'],
+      },
+    ],
+    ['a/free-suffix', { id: 'a/free-suffix', model: 'free-suffix:free', priceSource: 'unpriced', displayFree: true }],
+  ])
+
+  it('joins a served model with its catalog entry by canonical id', () => {
+    const models: AdminUsageModelEntry[] = [
+      { id: 'a/priced', value: 5, requests: 5, tokensIn: 100, tokensOut: 50, costMicroUsd: 1234, free: false },
+    ]
+    expect(joinPricingHealth(models, catalog)).toEqual([
+      {
+        id: 'a/priced',
+        priceSource: 'builtin',
+        displayFree: false,
+        requests: 5,
+        tokensIn: 100,
+        tokensOut: 50,
+        costMicroUsd: 1234,
+        contextTokens: 128000,
+        inputPerMTokUsd: 1,
+        outputPerMTokUsd: 2,
+        aliases: ['a/alias'],
+      },
+    ])
+  })
+
+  it('reads displayFree from the catalog join, not the ranking free flag', () => {
+    const models: AdminUsageModelEntry[] = [{ id: 'a/free-suffix', value: 1, requests: 1, free: false }]
+    expect(joinPricingHealth(models, catalog)[0]?.displayFree).toBe(true)
+    expect(joinPricingHealth(models, catalog)[0]?.priceSource).toBe('unpriced')
+  })
+
+  it('skips a served id missing from the catalog entirely', () => {
+    const models: AdminUsageModelEntry[] = [{ id: 'a/removed', value: 1, requests: 1 }]
+    expect(joinPricingHealth(models, catalog)).toEqual([])
+  })
+
+  it('defaults every detail field to 0 when the ranking entry omits it', () => {
+    const models: AdminUsageModelEntry[] = [{ id: 'a/priced', value: 1 }]
+    const row = joinPricingHealth(models, catalog)[0]!
+    expect(row.requests).toBe(0)
+    expect(row.tokensIn).toBe(0)
+    expect(row.tokensOut).toBe(0)
+    expect(row.costMicroUsd).toBe(0)
+  })
+
+  it('returns an empty array for an empty ranking', () => {
+    expect(joinPricingHealth([], catalog)).toEqual([])
+  })
+
+  // N1 (verify-redesign-final.md): an override-priced model must join
+  // with its billed inputPerMTokUsd/outputPerMTokUsd present, not
+  // undefined — PricingHealthTable.vue's own priceCell renders "—"
+  // whenever either is undefined, which used to fire for EVERY
+  // 'override' row regardless of whether a `pricing:` override was
+  // actually configured (admin_catalog.go filled these fields from a
+  // separate display resolution that an override-only model never
+  // populated).
+  it('joins an override-priced model with its billed price present, not "—"', () => {
+    const overrideCatalog = new Map<string, AdminCatalogModel>([
+      ['a/override', { id: 'a/override', model: 'override', priceSource: 'override', inputPerMTokUsd: 5, outputPerMTokUsd: 10 }],
+    ])
+    const models: AdminUsageModelEntry[] = [{ id: 'a/override', value: 1, requests: 3, tokensIn: 10, tokensOut: 5, costMicroUsd: 100 }]
+    const row = joinPricingHealth(models, overrideCatalog)[0]!
+    expect(row.priceSource).toBe('override')
+    expect(row.inputPerMTokUsd).toBe(5)
+    expect(row.outputPerMTokUsd).toBe(10)
+  })
+})
+
+describe('pricingHealthOrder', () => {
+  it('puts unpriced rows first regardless of their requests', () => {
+    const rows = [
+      { id: 'a', priceSource: 'builtin' as const, displayFree: false, requests: 1000, tokensIn: 0, tokensOut: 0, costMicroUsd: 0 },
+      { id: 'b', priceSource: 'unpriced' as const, displayFree: false, requests: 1, tokensIn: 0, tokensOut: 0, costMicroUsd: 0 },
+    ]
+    expect(pricingHealthOrder(rows).map((r) => r.id)).toEqual(['b', 'a'])
+  })
+
+  it('orders the full priceSource priority: unpriced, override, builtin, litellm, free', () => {
+    const rows = (['free', 'litellm', 'builtin', 'override', 'unpriced'] as const).map((priceSource, i) => ({
+      id: `m${i}`,
+      priceSource,
+      displayFree: false,
+      requests: 1,
+      tokensIn: 0,
+      tokensOut: 0,
+      costMicroUsd: 0,
+    }))
+    expect(pricingHealthOrder(rows).map((r) => r.priceSource)).toEqual(['unpriced', 'override', 'builtin', 'litellm', 'free'])
+  })
+
+  it('breaks ties within the same priceSource by descending requests', () => {
+    const rows = [
+      { id: 'low', priceSource: 'unpriced' as const, displayFree: false, requests: 5, tokensIn: 0, tokensOut: 0, costMicroUsd: 0 },
+      { id: 'high', priceSource: 'unpriced' as const, displayFree: false, requests: 50, tokensIn: 0, tokensOut: 0, costMicroUsd: 0 },
+    ]
+    expect(pricingHealthOrder(rows).map((r) => r.id)).toEqual(['high', 'low'])
+  })
+
+  it('does not mutate the input array', () => {
+    const rows = [
+      { id: 'a', priceSource: 'free' as const, displayFree: false, requests: 1, tokensIn: 0, tokensOut: 0, costMicroUsd: 0 },
+      { id: 'b', priceSource: 'unpriced' as const, displayFree: false, requests: 1, tokensIn: 0, tokensOut: 0, costMicroUsd: 0 },
+    ]
+    const copy = [...rows]
+    pricingHealthOrder(rows)
+    expect(rows).toEqual(copy)
+  })
+})
diff --git a/webui/src/lib/pricing-health.ts b/webui/src/lib/pricing-health.ts
new file mode 100644
index 0000000..33848cf
--- /dev/null
+++ b/webui/src/lib/pricing-health.ts
@@ -0,0 +1,94 @@
+// Pure join/ordering behind PricingHealthTable.vue (redesign-plan.md
+// section 3.4): "served models in range joined with catalog; unpriced
+// first with destructive badge". Kept out of the component the same way
+// every other lib/*.ts module in this feature keeps its own math/ordering
+// out of its component.
+import type { AdminCatalogModel, AdminUsageModelEntry, PriceSource } from '@/types/api'
+
+/**
+ * PricingHealthRow is one PricingHealthTable.vue row: a model actually
+ * served in the current range (GET /admin/api/usage/models, detail=1),
+ * joined with its catalog entry (GET /admin/api/catalog) for the pricing
+ * fields the ranking alone does not carry. `priceSource`/`displayFree`
+ * come from the catalog join — the BILLING truth (types/api.ts's
+ * PriceSource doc comment) — never re-derived from the ranking's own
+ * `free` flag, which reflects display-only relabeling for a ':free'
+ * suffix, not necessarily the same thing.
+ */
+export interface PricingHealthRow {
+  id: string
+  priceSource: PriceSource
+  displayFree: boolean
+  requests: number
+  tokensIn: number
+  tokensOut: number
+  costMicroUsd: number
+  contextTokens?: number
+  inputPerMTokUsd?: number
+  outputPerMTokUsd?: number
+  aliases?: string[]
+}
+
+/**
+ * joinPricingHealth joins every served model (`models`, a detail=1 ranking
+ * — only entries the server already knows had non-zero usage in range) against
+ * its catalog entry by canonical id. A served id absent from `catalog`
+ * entirely (a model removed from configuration since it was last used, or
+ * the catalog simply has not loaded yet) is SKIPPED — there is no pricing
+ * fact to report for it, and fabricating an "unpriced" row for a model
+ * that may no longer even exist would be misleading rather than merely
+ * incomplete.
+ */
+export function joinPricingHealth(models: AdminUsageModelEntry[], catalog: Map<string, AdminCatalogModel>): PricingHealthRow[] {
+  const rows: PricingHealthRow[] = []
+  for (const m of models) {
+    const cat = catalog.get(m.id)
+    if (!cat) continue
+    rows.push({
+      id: m.id,
+      priceSource: cat.priceSource,
+      displayFree: cat.displayFree ?? false,
+      requests: m.requests ?? 0,
+      tokensIn: m.tokensIn ?? 0,
+      tokensOut: m.tokensOut ?? 0,
+      costMicroUsd: m.costMicroUsd ?? 0,
+      contextTokens: cat.contextTokens,
+      inputPerMTokUsd: cat.inputPerMTokUsd,
+      outputPerMTokUsd: cat.outputPerMTokUsd,
+      aliases: cat.aliases,
+    })
+  }
+  return rows
+}
+
+/**
+ * PRICING_HEALTH_SOURCE_RANK orders pricingHealthOrder's primary sort key
+ * — 'unpriced' first (redesign-plan.md section 3.4: "unpriced first with
+ * destructive badge", the row that most needs an operator's attention),
+ * then the two explicit/deliberate sources (override, builtin — an
+ * operator or the built-in table already priced these correctly), then
+ * litellm (a live, less-pinned lookup), then 'free' last (a deliberately
+ * zero-cost model — nothing to flag at all).
+ */
+const PRICING_HEALTH_SOURCE_RANK: Record<PriceSource, number> = {
+  unpriced: 0,
+  override: 1,
+  builtin: 2,
+  litellm: 3,
+  free: 4,
+}
+
+/**
+ * pricingHealthOrder sorts joined rows: unpriced-first by priceSource
+ * (PRICING_HEALTH_SOURCE_RANK), then by descending requests within each
+ * source group — the biggest-traffic unpriced model surfaces first, since
+ * that is the one costing the operator the most in unbilled requests.
+ * Returns a NEW array; never mutates `rows`.
+ */
+export function pricingHealthOrder(rows: PricingHealthRow[]): PricingHealthRow[] {
+  return [...rows].sort((a, b) => {
+    const bySource = PRICING_HEALTH_SOURCE_RANK[a.priceSource] - PRICING_HEALTH_SOURCE_RANK[b.priceSource]
+    if (bySource !== 0) return bySource
+    return b.requests - a.requests
+  })
+}
diff --git a/webui/src/lib/provider-rate.spec.ts b/webui/src/lib/provider-rate.spec.ts
index bb639fe..8d0139c 100644
--- a/webui/src/lib/provider-rate.spec.ts
+++ b/webui/src/lib/provider-rate.spec.ts
@@ -2,11 +2,13 @@ import { describe, expect, it } from 'vitest'
 
 import {
   dayRateTitle,
+  formatErrorRatePercent,
   formatRatePercent,
   isModelDegraded,
   minuteRateTitle,
   PROVIDER_RATE_AMBER_THRESHOLD,
   PROVIDER_RATE_DESTRUCTIVE_THRESHOLD,
+  providerErrorRate,
   providerRateStatus,
   providerSuccessRate,
 } from './provider-rate'
@@ -143,3 +145,36 @@ describe('dayRateTitle', () => {
     expect(dayRateTitle(5, 0)).toBe('5 attempts, 0 failures today (100%)')
   })
 })
+
+describe('providerErrorRate', () => {
+  it('is 1 minus the success rate', () => {
+    expect(providerErrorRate(100, 1)).toBeCloseTo(0.01)
+  })
+
+  it('is null for zero attempts (no traffic), never a fabricated 0', () => {
+    expect(providerErrorRate(0, 0)).toBeNull()
+  })
+
+  it('is 1 when every attempt failed', () => {
+    expect(providerErrorRate(10, 10)).toBe(1)
+  })
+})
+
+describe('formatErrorRatePercent', () => {
+  it('ceils rather than floors, so a genuinely non-zero rate never rounds down to "0%"', () => {
+    expect(formatErrorRatePercent(0.001)).toBe('1%')
+    expect(formatErrorRatePercent(0.011)).toBe('2%')
+  })
+
+  it('renders exactly 0 as "0%"', () => {
+    expect(formatErrorRatePercent(0)).toBe('0%')
+  })
+
+  it('renders null as "no data", never "0%"', () => {
+    expect(formatErrorRatePercent(null)).toBe('no data')
+  })
+
+  it('does not clamp a rate above 1 (should not occur with real counters, but is not silently capped)', () => {
+    expect(formatErrorRatePercent(1.8)).toBe('180%')
+  })
+})
diff --git a/webui/src/lib/provider-rate.ts b/webui/src/lib/provider-rate.ts
index 01f6c66..cea287e 100644
--- a/webui/src/lib/provider-rate.ts
+++ b/webui/src/lib/provider-rate.ts
@@ -90,6 +90,45 @@ export function formatRatePercent(rate: number): string {
   return `${Math.floor(rate * 100)}%`
 }
 
+/**
+ * providerErrorRate is failures/attempts directly — conceptually
+ * providerSuccessRate's complement, but computed as its OWN division
+ * rather than `1 - providerSuccessRate(...)`: chaining a subtraction onto
+ * an already-divided value compounds binary floating-point error (e.g.
+ * 1 - (99/100) computes a hair above 0.01, which then ceils to "2%"
+ * instead of "1%" once formatErrorRatePercent multiplies by 100 — a
+ * caught review bug, not a hypothetical one). Returns null (never a
+ * fabricated 0%) when there is no traffic to compute a rate from at all.
+ * Shared by the Models page's per-model error-rate column
+ * (lib/model-table-columns.ts) and the Reliability page's own bucket-by-
+ * bucket series (which instead derives its ratio via lib/series.ts's
+ * ratioSeries, but formats it through formatErrorRatePercent below) — the
+ * ONE place "attempts/failures -> error rate" is computed for a single
+ * snapshot value, as opposed to a time series.
+ */
+export function providerErrorRate(attempts: number, failures: number): number | null {
+  if (!Number.isFinite(attempts) || attempts <= 0) return null
+  const safeFailures = Number.isFinite(failures) ? failures : 0
+  return safeFailures / attempts
+}
+
+/**
+ * formatErrorRatePercent renders a 0-1(+) error-rate fraction CEILING
+ * rather than floored — the opposite honesty direction from
+ * formatRatePercent above (a SUCCESS rate must never overstate itself as
+ * 100%; an ERROR rate must never round down to a misleadingly clean 0%).
+ * `null` (no traffic to compute a rate from — providerErrorRate's own
+ * "nothing to report" case) renders as "no data", never "0%". Not clamped
+ * to 100%: a rate above 1 should not occur with real counters, but this
+ * function reports whatever the caller computed rather than silently
+ * capping it (lib/series.ts's own ratioSeries makes the identical choice).
+ */
+export function formatErrorRatePercent(rate: number | null): string {
+  if (rate === null) return 'no data'
+  if (rate <= 0) return '0%'
+  return `${Math.ceil(rate * 100)}%`
+}
+
 /** countWord returns singular when n is exactly 1, plural otherwise — shared by minuteRateTitle and dayRateTitle so their wording never drifts apart. */
 function countWord(n: number, singular: string, plural: string): string {
   return n === 1 ? singular : plural
diff --git a/webui/src/lib/range.spec.ts b/webui/src/lib/range.spec.ts
new file mode 100644
index 0000000..db4a9db
--- /dev/null
+++ b/webui/src/lib/range.spec.ts
@@ -0,0 +1,140 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  comparison,
+  dayOrMonthClampNotice,
+  dayOrMonthWindow,
+  DEFAULT_CMP,
+  DEFAULT_RANGE,
+  isCmpMode,
+  isRangeKey,
+  RANGE_KEYS,
+  RANGE_PRESETS,
+  seriesUrl,
+  totalsUrl,
+} from './range'
+
+describe('RANGE_PRESETS', () => {
+  it('resolves every preset to the documented (window, span) pair', () => {
+    expect(RANGE_PRESETS['24h']).toEqual({ window: 'hour', span: 24 })
+    expect(RANGE_PRESETS['48h']).toEqual({ window: 'hour', span: 48 })
+    expect(RANGE_PRESETS['7d']).toEqual({ window: 'day', span: 7 })
+    expect(RANGE_PRESETS['14d']).toEqual({ window: 'day', span: 14 })
+    expect(RANGE_PRESETS['30d']).toEqual({ window: 'day', span: 30 })
+    expect(RANGE_PRESETS['3mo']).toEqual({ window: 'month', span: 3 })
+    expect(RANGE_PRESETS['6mo']).toEqual({ window: 'month', span: 6 })
+    expect(RANGE_PRESETS['12mo']).toEqual({ window: 'month', span: 12 })
+  })
+
+  it('covers every RangeKey with no gaps', () => {
+    for (const key of RANGE_KEYS) expect(RANGE_PRESETS[key]).toBeDefined()
+  })
+})
+
+describe('DEFAULT_RANGE / DEFAULT_CMP', () => {
+  it('defaults to 7d / none', () => {
+    expect(DEFAULT_RANGE).toBe('7d')
+    expect(DEFAULT_CMP).toBe('none')
+  })
+})
+
+describe('comparison', () => {
+  it.each([
+    ['24h', true, 24],
+    ['7d', true, 7],
+    ['14d', true, 14],
+    ['3mo', true, 3],
+    ['6mo', true, 6],
+  ] as const)('%s is available with offset %i', (range, available, offset) => {
+    const result = comparison(range)
+    expect(result.available).toBe(available)
+    expect(result.offset).toBe(offset)
+    expect(result.reason).toBeUndefined()
+  })
+
+  it.each(['48h', '30d', '12mo'] as const)('%s is unavailable (2*span exceeds retention max)', (range) => {
+    const result = comparison(range)
+    expect(result.available).toBe(false)
+    expect(result.reason).toBe('retention limit')
+  })
+})
+
+describe('isRangeKey / isCmpMode', () => {
+  it('accepts every real value and rejects bogus ones', () => {
+    for (const key of RANGE_KEYS) expect(isRangeKey(key)).toBe(true)
+    expect(isRangeKey('bogus')).toBe(false)
+    expect(isCmpMode('none')).toBe(true)
+    expect(isCmpMode('prev')).toBe(true)
+    expect(isCmpMode('bogus')).toBe(false)
+  })
+})
+
+// dayOrMonthWindow (P2 item 2): the shared clamp GET /admin/api/usage/
+// totals?kind=usermodel|modeluser|targetcaller needs — moved here from
+// lib/target-columns.ts so stores/consumers.ts (usermodel) and
+// stores/spend.ts (usermodel drilldown) share the identical clamp
+// TargetCallers.vue already used, rather than each re-deriving it (or,
+// before this fix, not clamping at all and 400ing on an hour-window
+// range).
+describe('dayOrMonthWindow', () => {
+  it('passes a day window through unchanged, with its own span', () => {
+    expect(dayOrMonthWindow('day', 14)).toEqual({ window: 'day', span: 14 })
+  })
+
+  it('passes a month window through unchanged, with its own span', () => {
+    expect(dayOrMonthWindow('month', 6)).toEqual({ window: 'month', span: 6 })
+  })
+
+  it('clamps an hour window (no day/month equivalent span) to a fixed one-week day window', () => {
+    expect(dayOrMonthWindow('hour', 48)).toEqual({ window: 'day', span: 7 })
+    expect(dayOrMonthWindow('hour', 24)).toEqual({ window: 'day', span: 7 })
+  })
+})
+
+// dayOrMonthClampNotice (N3, verify-redesign-final.md): the shared
+// "this view silently clamped your range" note text for every reader of
+// dayOrMonthWindow above that surfaces the clamp to a screen.
+describe('dayOrMonthClampNotice', () => {
+  it('is null for a day window — dayOrMonthWindow passes it through unchanged', () => {
+    expect(dayOrMonthClampNotice('day', 14)).toBeNull()
+  })
+
+  it('is null for a month window — dayOrMonthWindow passes it through unchanged', () => {
+    expect(dayOrMonthClampNotice('month', 6)).toBeNull()
+  })
+
+  it('names the exact substituted range for an hour window, regardless of the requested span', () => {
+    expect(dayOrMonthClampNotice('hour', 24)).toBe('Showing last 7 days — per-hour data is not kept for this view.')
+    expect(dayOrMonthClampNotice('hour', 48)).toBe('Showing last 7 days — per-hour data is not kept for this view.')
+  })
+})
+
+describe('seriesUrl', () => {
+  it('repeats scope as separate params and omits offset when 0', () => {
+    const url = seriesUrl({ scope: ['user:alice', 'group:eng'], metric: 'cost', window: 'day', span: 7 })
+    expect(url).toBe('/admin/api/usage/series?scope=user%3Aalice&scope=group%3Aeng&metric=cost&window=day&span=7')
+  })
+
+  it('includes offset when non-zero', () => {
+    const url = seriesUrl({ scope: ['total'], metric: 'req', window: 'hour', span: 24, offset: 24 })
+    expect(url).toContain('offset=24')
+  })
+})
+
+describe('totalsUrl', () => {
+  it('builds the minimal query for kind alone', () => {
+    expect(totalsUrl({ kind: 'user' })).toBe('/admin/api/usage/totals?kind=user')
+  })
+
+  it('joins metrics with commas and includes every optional param provided', () => {
+    const url = totalsUrl({
+      kind: 'usermodel',
+      window: 'month',
+      span: 1,
+      metrics: ['req', 'cost'],
+      limit: 5,
+      user: 'alice',
+    })
+    expect(url).toBe('/admin/api/usage/totals?kind=usermodel&window=month&span=1&metrics=req%2Ccost&limit=5&user=alice')
+  })
+})
diff --git a/webui/src/lib/range.ts b/webui/src/lib/range.ts
new file mode 100644
index 0000000..7d13f01
--- /dev/null
+++ b/webui/src/lib/range.ts
@@ -0,0 +1,184 @@
+import type { HistoryWindow, TotalsKind } from '@/types/api'
+
+/**
+ * RANGE_KEYS is the global filter bar's fixed set of time-range presets
+ * (redesign-plan.md section 3.2). Each maps to a bucket window and a
+ * bucket count (`span`) — the same (window, span) pair GET /admin/api/
+ * usage/series and /usage/models already accept.
+ */
+export const RANGE_KEYS = ['24h', '48h', '7d', '14d', '30d', '3mo', '6mo', '12mo'] as const
+
+export type RangeKey = (typeof RANGE_KEYS)[number]
+
+export const DEFAULT_RANGE: RangeKey = '7d'
+
+/** One range preset's resolved (window, span) pair. */
+export interface RangePreset {
+  window: HistoryWindow
+  span: number
+}
+
+export const RANGE_PRESETS: Record<RangeKey, RangePreset> = {
+  '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 },
+}
+
+/**
+ * HISTORY_MAX_SPAN mirrors the server's own retention ceiling per window
+ * (limits.go: historyMaxSpan — hour 48, day 35, month 13). The frontend
+ * keeps its own copy rather than reading it from an endpoint: it never
+ * changes without a server redeploy, and comparison() below needs it
+ * synchronously to decide whether a comparison request would even be
+ * valid before firing it.
+ */
+export const HISTORY_MAX_SPAN: Record<HistoryWindow, number> = {
+  hour: 48,
+  day: 35,
+  month: 13,
+}
+
+/** The comparison toggle's two states (redesign-plan.md section 3.1's `cmp` hash param). */
+export const CMP_MODES = ['none', 'prev'] as const
+
+export type CmpMode = (typeof CMP_MODES)[number]
+
+export const DEFAULT_CMP: CmpMode = 'none'
+
+export interface ComparisonResult {
+  /** Whether "vs previous period" can be requested for this range at all. */
+  available: boolean
+  /** How many buckets back the comparison window starts (span+offset stays within HISTORY_MAX_SPAN when available). */
+  offset: number
+  /** Set only when `available` is false — the reason a GlobalFilterBar cmp toggle disables itself, e.g. as a disabled control's title. */
+  reason?: string
+}
+
+/**
+ * comparison reports whether `range` can be paired with a "vs previous
+ * period" comparison request, and what `offset` that comparison would
+ * use (Q5, redesign-plan.md DECISIONS). A comparison covers the SAME
+ * span twice — the current period and the one immediately before it — so
+ * it needs `2 * span` buckets total; it is disabled whenever that would
+ * exceed the window's own retention ceiling (HISTORY_MAX_SPAN), which is
+ * exactly 48h, 30d, and 12mo among the eight presets above.
+ */
+export function comparison(range: RangeKey): ComparisonResult {
+  const { window, span } = RANGE_PRESETS[range]
+  const max = HISTORY_MAX_SPAN[window]
+  if (2 * span > max) return { available: false, offset: span, reason: 'retention limit' }
+  return { available: true, offset: span }
+}
+
+/**
+ * dayOrMonthWindow clamps an arbitrary HistoryWindow/span pair (usually the
+ * global filters store's current range) down to the day/month-only window
+ * GET /admin/api/usage/totals accepts for its usermodel/modeluser/
+ * targetcaller kinds (redesign-plan.md section 1.3.v: "usermodel/modeluser/
+ * targetcaller: day/month only"). 'month' passes through unchanged; 'hour'
+ * (the 24h/48h global ranges, which have no day/month equivalent span at
+ * all) falls back to a fixed one-week day window rather than an arbitrary
+ * guess at what span the reader meant; 'day' passes its own span through
+ * unchanged. The single shared clamp for every one of those three kinds —
+ * stores/consumers.ts (usermodel), stores/spend.ts (usermodel drilldown),
+ * lib/target-columns.ts/TargetCallers.vue (targetcaller) all import this
+ * rather than each re-deriving their own.
+ */
+export function dayOrMonthWindow(window: HistoryWindow, span: number): { window: 'day' | 'month'; span: number } {
+  if (window === 'month') return { window: 'month', span }
+  if (window === 'day') return { window: 'day', span }
+  return { window: 'day', span: 7 }
+}
+
+/**
+ * dayOrMonthClampNotice (N3 fix, verify-redesign-final.md) is
+ * dayOrMonthWindow's own "worth telling the reader" half: dayOrMonthWindow
+ * silently substitutes a fixed day-window whenever `window` is 'hour'
+ * (24h/48h has no day/month equivalent span at all) — this reports the
+ * exact substituted range as a one-line note when that happened, and
+ * null when it did not ('day'/'month' pass through dayOrMonthWindow
+ * unchanged, so there is nothing to disclose).
+ *
+ * Every reader of dayOrMonthWindow that surfaces its result to a screen
+ * — UserDetail's "Models used", the Spend drilldown's usermodel level,
+ * TargetCallers — shares this one function via ClampedRangeNotice.vue,
+ * so the wording never drifts between them. ReliabilityPage.vue's own
+ * month-clamp note is a SEPARATE, unrelated clamp (hour/day -> a fixed
+ * 30-day window, stores/reliability.ts's hourOrDayWindow) and stays its
+ * own inline Alert, not this one.
+ */
+export function dayOrMonthClampNotice(window: HistoryWindow, span: number): string | null {
+  if (window !== 'hour') return null
+  const clamped = dayOrMonthWindow(window, span)
+  return `Showing last ${clamped.span} days — per-hour data is not kept for this view.`
+}
+
+/** isRangeKey is a runtime type guard against RANGE_KEYS — the only place that string union is checked against untrusted input (a hash, a hand-typed URL). */
+export function isRangeKey(value: string): value is RangeKey {
+  return (RANGE_KEYS as readonly string[]).includes(value)
+}
+
+/** isCmpMode is CMP_MODES' own runtime type guard, mirroring isRangeKey above. */
+export function isCmpMode(value: string): value is CmpMode {
+  return (CMP_MODES as readonly string[]).includes(value)
+}
+
+export interface SeriesUrlParams {
+  /** One or more scope ids — repeated as separate `scope` query params, matching admin.go's `scope` (1..100, repeated). */
+  scope: string[]
+  metric: string
+  window: HistoryWindow
+  span: number
+  /** Buckets back from "now" the window starts — omitted (server default 0) when 0. */
+  offset?: number
+}
+
+/** seriesUrl builds the query string for GET /admin/api/usage/series (redesign-plan.md section 1.3.iv) — the one place every store that reads it (spend/consumers/models/reliability, phase 2) builds that URL, rather than each hand-rolling its own URLSearchParams. */
+export function seriesUrl(params: SeriesUrlParams): string {
+  const q = new URLSearchParams()
+  for (const scope of params.scope) q.append('scope', scope)
+  q.set('metric', params.metric)
+  q.set('window', params.window)
+  q.set('span', String(params.span))
+  if (params.offset) q.set('offset', String(params.offset))
+  return `/admin/api/usage/series?${q.toString()}`
+}
+
+export interface TotalsUrlParams {
+  kind: TotalsKind
+  window?: HistoryWindow
+  span?: number
+  offset?: number
+  /** Comma-joined server-side (admin.go's `metrics` query param) — omitted entirely (server default: every metric that kind allows) when empty/absent. */
+  metrics?: string[]
+  limit?: number
+  /** kind 'user' only — narrows to one group's members. */
+  group?: string
+  /** kind 'usermodel' only — required by the server. */
+  user?: string
+  /** kind 'modeluser' only — required by the server. */
+  model?: string
+  /** kind 'targetcaller' only — "mcp/{name}" or "agent/{name}". */
+  target?: string
+}
+
+/** totalsUrl builds the query string for GET /admin/api/usage/totals (redesign-plan.md section 1.3.v), mirroring seriesUrl above. */
+export function totalsUrl(params: TotalsUrlParams): string {
+  const q = new URLSearchParams()
+  q.set('kind', params.kind)
+  if (params.window) q.set('window', params.window)
+  if (params.span !== undefined) q.set('span', String(params.span))
+  if (params.offset) q.set('offset', String(params.offset))
+  if (params.metrics && params.metrics.length > 0) q.set('metrics', params.metrics.join(','))
+  if (params.limit !== undefined) q.set('limit', String(params.limit))
+  if (params.group) q.set('group', params.group)
+  if (params.user) q.set('user', params.user)
+  if (params.model) q.set('model', params.model)
+  if (params.target) q.set('target', params.target)
+  return `/admin/api/usage/totals?${q.toString()}`
+}
diff --git a/webui/src/lib/search-expand.spec.ts b/webui/src/lib/search-expand.spec.ts
index fdcb44a..7dd2265 100644
--- a/webui/src/lib/search-expand.spec.ts
+++ b/webui/src/lib/search-expand.spec.ts
@@ -118,11 +118,11 @@ describe('an item manually opened before search, still matches, clicked closed d
 })
 
 // This module is domain-agnostic on what an "id" represents — it started as
-// ProvidersView.vue's provider names, but UsageView.vue now feeds it group
-// ids too (see that view's own doc comment: matchingIds there is every
-// group that matches ONLY via a member, never via its own name). These two
-// cases exist to pin that the module behaves identically for that second
-// domain, not because anything here differs by id shape.
+// ProviderHealthPanel.vue's provider names, but ConsumerDirectory.vue also
+// feeds it group ids (see that component's own doc comment: matchingIds
+// there is every group that matches ONLY via a member, never via its own
+// name). These two cases exist to pin that the module behaves identically
+// for that second domain, not because anything here differs by id shape.
 describe('generic ids (Usage group ids, not just Providers provider names)', () => {
   it('auto-expands and can be collapsed/overridden identically for a group id', () => {
     const state = newState()
diff --git a/webui/src/lib/search-expand.ts b/webui/src/lib/search-expand.ts
index cbc0f36..3dd4bc4 100644
--- a/webui/src/lib/search-expand.ts
+++ b/webui/src/lib/search-expand.ts
@@ -1,18 +1,18 @@
 /**
  * Pure expand/collapse state for a search-filterable shadcn-vue Accordion —
- * shared by ProvidersView.vue (providers) and UsageView.vue (groups), and
- * generalized (originally provider-expand.ts) so both consume ONE tested
- * implementation instead of two copies of the same logic (vue.md: "if
- * you've written it twice, you owe an abstraction"). Extracted out of the
- * component so the exact toggle sequence a review flagged (see
- * toggleItemExpand's own comment) is tested in isolation, without mounting
- * Vue — see search-expand.spec.ts (vitest), which exercises this module
- * directly, including the full flagged sequence.
+ * shared by ProviderHealthPanel.vue (providers) and ConsumerDirectory.vue
+ * (groups), and generalized (originally provider-expand.ts) so both
+ * consume ONE tested implementation instead of two copies of the same
+ * logic (vue.md: "if you've written it twice, you owe an abstraction").
+ * Extracted out of the component so the exact toggle sequence a review
+ * flagged (see toggleItemExpand's own comment) is tested in isolation,
+ * without mounting Vue — see search-expand.spec.ts (vitest), which
+ * exercises this module directly, including the full flagged sequence.
  *
  * Two sets track state, keyed on each accordion item's own string id (a
- * provider name in Providers, a group id in Usage — this module has no
- * opinion on what the id means or on what counts as a "match"; callers
- * decide that and pass the resulting id list in):
+ * provider name on the Models page, a group id on the Consumers page —
+ * this module has no opinion on what the id means or on what counts as a
+ * "match"; callers decide that and pass the resulting id list in):
  * - manuallyExpanded: items the user explicitly opened, independent of any
  *   search query. This is the state a cleared search returns to.
  * - manuallyCollapsed: items the user explicitly closed WHILE a search
@@ -34,12 +34,13 @@ export interface ExpandState {
  * manuallyExpanded plus every id in matchingIds that is not in
  * manuallyCollapsed (auto-expand every match, unless the user explicitly
  * closed that one). The caller decides what "matching" means for its own
- * view, and this module has no opinion on it either way — ProvidersView.vue
- * passes every provider that itself matched at all (every match there
- * implies at least one matching model, so every match auto-expands);
- * UsageView.vue instead passes only the subset of its own matches that
- * matched via a member rather than via the group's own name (see that
- * view's own doc comment for why it draws that narrower distinction).
+ * view, and this module has no opinion on it either way —
+ * ProviderHealthPanel.vue passes every provider that itself matched at
+ * all (every match there implies at least one matching model, so every
+ * match auto-expands); ConsumerDirectory.vue instead passes only the
+ * subset of its own matches that matched via a member rather than via
+ * the group's own name (see that component's own doc comment for why it
+ * draws that narrower distinction).
  */
 export function computeExpandedItems(state: ExpandState, hasQuery: boolean, matchingIds: string[]): Set<string> {
   if (!hasQuery) return new Set(state.manuallyExpanded)
diff --git a/webui/src/lib/series.spec.ts b/webui/src/lib/series.spec.ts
new file mode 100644
index 0000000..0ddd091
--- /dev/null
+++ b/webui/src/lib/series.spec.ts
@@ -0,0 +1,131 @@
+import { describe, expect, it } from 'vitest'
+
+import { other, ratioSeries, stackTopN, sumByProvider } from './series'
+
+describe('stackTopN', () => {
+  it('returns the n series with the largest total, descending', () => {
+    const series = [
+      { scope: 'model:a', points: [1, 1] }, // total 2
+      { scope: 'model:b', points: [10, 10] }, // total 20
+      { scope: 'model:c', points: [5, 5] }, // total 10
+    ]
+    expect(stackTopN(series, 2)).toEqual([
+      { scope: 'model:b', points: [10, 10] },
+      { scope: 'model:c', points: [5, 5] },
+    ])
+  })
+
+  it('returns every series, sorted, when n exceeds the array length', () => {
+    const series = [
+      { scope: 'model:a', points: [1] },
+      { scope: 'model:b', points: [2] },
+    ]
+    expect(stackTopN(series, 10)).toHaveLength(2)
+  })
+
+  it('returns an empty array for n <= 0', () => {
+    const series = [{ scope: 'model:a', points: [1] }]
+    expect(stackTopN(series, 0)).toEqual([])
+    expect(stackTopN(series, -1)).toEqual([])
+  })
+
+  it('breaks ties on original array order (stable sort)', () => {
+    const series = [
+      { scope: 'model:a', points: [5] },
+      { scope: 'model:b', points: [5] },
+    ]
+    expect(stackTopN(series, 2).map((s) => s.scope)).toEqual(['model:a', 'model:b'])
+  })
+
+  it('does not mutate the input array', () => {
+    const series = [
+      { scope: 'model:a', points: [1] },
+      { scope: 'model:b', points: [2] },
+    ]
+    const copy = [...series]
+    stackTopN(series, 1)
+    expect(series).toEqual(copy)
+  })
+})
+
+describe('other', () => {
+  it('subtracts the sum of charted series from the total, per bucket', () => {
+    const total = [100, 200]
+    const charted = [
+      { scope: 'model:a', points: [30, 50] },
+      { scope: 'model:b', points: [20, 40] },
+    ]
+    expect(other(total, charted)).toEqual([50, 110])
+  })
+
+  it('returns the total verbatim when charted is empty', () => {
+    expect(other([1, 2, 3], [])).toEqual([1, 2, 3])
+  })
+
+  it('floors a bucket at 0 rather than going negative', () => {
+    const total = [10]
+    const charted = [{ scope: 'model:a', points: [15] }]
+    expect(other(total, charted)).toEqual([0])
+  })
+
+  it('treats a missing point in a shorter charted series as 0', () => {
+    const total = [10, 10]
+    const charted = [{ scope: 'model:a', points: [4] }]
+    expect(other(total, charted)).toEqual([6, 10])
+  })
+})
+
+describe('sumByProvider', () => {
+  it('groups model-scoped series by their provider prefix and sums per bucket', () => {
+    const series = [
+      { scope: 'model:openai/gpt-5', points: [10, 20] },
+      { scope: 'model:openai/gpt-5-mini', points: [5, 5] },
+      { scope: 'model:anthropic/claude', points: [1, 1] },
+    ]
+    const result = sumByProvider(series)
+    expect(result).toEqual([
+      { scope: 'openai', points: [15, 25] },
+      { scope: 'anthropic', points: [1, 1] },
+    ])
+  })
+
+  it('handles a bare (unprefixed) scope without a "model:" prefix', () => {
+    const series = [{ scope: 'openai/gpt-5', points: [3] }]
+    expect(sumByProvider(series)).toEqual([{ scope: 'openai', points: [3] }])
+  })
+
+  it('handles a discovered id with an extra internal slash — only the first segment is the provider', () => {
+    const series = [{ scope: 'model:real/uni/deepseek-v4-flash-0731', points: [7] }]
+    expect(sumByProvider(series)).toEqual([{ scope: 'real', points: [7] }])
+  })
+
+  it('sorts the grouped result by descending total', () => {
+    const series = [
+      { scope: 'model:small/x', points: [1] },
+      { scope: 'model:big/y', points: [100] },
+    ]
+    expect(sumByProvider(series).map((s) => s.scope)).toEqual(['big', 'small'])
+  })
+
+  it('returns an empty array for an empty input', () => {
+    expect(sumByProvider([])).toEqual([])
+  })
+})
+
+describe('ratioSeries', () => {
+  it('divides numerator by denominator per bucket', () => {
+    expect(ratioSeries([1, 5, 10], [10, 10, 10])).toEqual([0.1, 0.5, 1])
+  })
+
+  it('returns null for a bucket with 0 attempts rather than NaN or a fabricated 0', () => {
+    expect(ratioSeries([0, 3], [0, 10])).toEqual([null, 0.3])
+  })
+
+  it('treats a missing numerator point as 0', () => {
+    expect(ratioSeries([], [5])).toEqual([0])
+  })
+
+  it('returns an empty array for empty input', () => {
+    expect(ratioSeries([], [])).toEqual([])
+  })
+})
diff --git a/webui/src/lib/series.ts b/webui/src/lib/series.ts
new file mode 100644
index 0000000..a094ccd
--- /dev/null
+++ b/webui/src/lib/series.ts
@@ -0,0 +1,112 @@
+// Pure series math shared by every page that renders a GET
+// /admin/api/usage/series response through TimeSeriesChart.vue: Spend's
+// cost breakdown (by=model/provider/group, redesign-plan.md section 3.4)
+// and, per that same section, WP-F's Reliability page ("TimeSeriesChart
+// for error rate per provider (lib/series.ts ratioSeries fail/attempt per
+// bucket)"). Owned by WP-D (section 4) precisely because Spend needs it
+// first, but kept generic — no metric/scope-kind-specific logic — so a
+// second page building its own breakdown never grows a duplicate copy
+// (vue.md: "if you've written it twice, you owe an abstraction"). Kept out
+// of any component/store the same way lib/forecast.ts and lib/usage-bars.ts
+// keep their own math out of theirs — vitest's node-environment config
+// exercises every function here directly, no component mount required.
+
+/** One AdminSeriesResponse series entry: a scope id and its bucket-aligned points (types/api.ts: AdminSeriesResponse['series'][number]). */
+export interface Series {
+  scope: string
+  points: number[]
+}
+
+/**
+ * sumSeries totals one series' own points — the ranking key stackTopN
+ * sorts by, and the per-bucket contribution `other` subtracts. A missing
+ * point (an index beyond `points.length`, which should not happen for a
+ * well-formed AdminSeriesResponse where every series is exactly
+ * `buckets.length` long) reads as 0 rather than throwing.
+ */
+function sumSeries(points: number[]): number {
+  let total = 0
+  for (const p of points) total += p
+  return total
+}
+
+/**
+ * stackTopN returns the N series with the largest total value (sumSeries,
+ * descending), for stacking individually in a breakdown chart — Spend's
+ * by=model view fetches series for every model the ranking endpoint
+ * already reported as non-idle, then charts only the biggest N of them,
+ * folding the rest into an "other" bucket via `other` below. Ties break on
+ * the ORIGINAL array order (Array.prototype.sort is stable), so two
+ * series with an identical total never reorder from one call to the next.
+ * `n` beyond `series.length` simply returns every series, sorted; `n <= 0`
+ * returns an empty array.
+ */
+export function stackTopN(series: Series[], n: number): Series[] {
+  if (n <= 0) return []
+  return [...series].sort((a, b) => sumSeries(b.points) - sumSeries(a.points)).slice(0, n)
+}
+
+/**
+ * other computes the per-bucket remainder of `totalPoints` once every
+ * series in `charted` (Spend's top-N breakdown) is subtracted — the
+ * "other" bucket redesign-plan.md section 3.3 describes ("other = total -
+ * sum(top)"). Floored at 0 per bucket: a genuine remainder is never
+ * negative (every charted series is a strict subset of the total), so a
+ * small negative reading can only be a rounding/timing artifact between
+ * the two separate HTTP requests that produced `totalPoints` and
+ * `charted` — the same "never render a fabricated crossed boundary"
+ * discipline lib/format.ts's formatCompactCount already documents for an
+ * unrelated flooring case. `charted` may be empty (no breakdown at all —
+ * `other` then equals `totalPoints` verbatim, floored).
+ */
+export function other(totalPoints: number[], charted: Series[]): number[] {
+  return totalPoints.map((total, i) => {
+    let chartedSum = 0
+    for (const s of charted) chartedSum += s.points[i] ?? 0
+    return Math.max(0, total - chartedSum)
+  })
+}
+
+/**
+ * sumByProvider groups a set of `model:{canonical}` (or bare canonical)
+ * scoped series by their provider prefix (routableModelId's own inverse:
+ * the FIRST path segment before the first "/", lib/format.ts's own doc
+ * comment on routableModelId spells out why only the first segment counts
+ * even when a discovered model id itself contains further slashes) and
+ * sums their points per bucket — Spend's by=provider view (redesign-
+ * plan.md section 3.3): the /usage/series endpoint has no cost/req/tokin/
+ * tokout metric for a `provider:{name}` scope directly (section 1.3.iv's
+ * own metric x kind table — provider scope only carries attempt/fail/
+ * timeout/fover), so a provider-level cost breakdown can only be DERIVED
+ * by summing its own models' series client-side. Returned in descending
+ * total order (stackTopN's own convention) — the biggest provider first,
+ * both for a stable, useful stacking order and so a caller never has to
+ * re-sort.
+ */
+export function sumByProvider(series: Series[]): Series[] {
+  const byProvider = new Map<string, number[]>()
+  for (const s of series) {
+    const id = s.scope.startsWith('model:') ? s.scope.slice('model:'.length) : s.scope
+    const slash = id.indexOf('/')
+    const provider = slash === -1 ? id : id.slice(0, slash)
+    const acc = byProvider.get(provider) ?? new Array<number>(s.points.length).fill(0)
+    for (let i = 0; i < s.points.length; i++) acc[i] = (acc[i] ?? 0) + (s.points[i] ?? 0)
+    byProvider.set(provider, acc)
+  }
+  const grouped = Array.from(byProvider.entries()).map(([scope, points]) => ({ scope, points }))
+  return grouped.sort((a, b) => sumSeries(b.points) - sumSeries(a.points))
+}
+
+/**
+ * ratioSeries divides `numerator` by `denominator` bucket-for-bucket
+ * (Reliability's per-provider error rate, lib/provider-rate.ts's own
+ * fleet-wide equivalent for a single snapshot) — null for any bucket
+ * where `denominator` is 0 (no attempts that bucket), never a fabricated
+ * 0% or a NaN from dividing by zero. Both arrays must already be aligned
+ * to the SAME buckets (the caller's responsibility, matching
+ * AdminSeriesResponse's own "every series is buckets.length long, index-
+ * for-index" contract).
+ */
+export function ratioSeries(numerator: number[], denominator: number[]): (number | null)[] {
+  return denominator.map((d, i) => (d > 0 ? (numerator[i] ?? 0) / d : null))
+}
diff --git a/webui/src/lib/snippets.spec.ts b/webui/src/lib/snippets.spec.ts
new file mode 100644
index 0000000..32c472b
--- /dev/null
+++ b/webui/src/lib/snippets.spec.ts
@@ -0,0 +1,321 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import {
+  API_KEY_PLACEHOLDER,
+  generateApiKey,
+  groupGrantSnippet,
+  groupLimitsSnippet,
+  isValidName,
+  isValidNonNegative,
+  isValidNonNegativeInt,
+  isValidUserName,
+  modelMetaSnippet,
+  pricingSnippet,
+  userGrantJsonFragment,
+  userJsonLine,
+  userLimitsJsonFragment,
+  validatePersonalGrant,
+} from './snippets'
+
+// Golden strings below are checked against the REAL production shapes in
+// home-cluster/kubernetes/namespaces/traefik/base/llmgateway/middleware.yaml
+// and users-configmap.yaml (read this session) — structure and field order
+// only. Every value used here is fabricated/public (model ids, provider
+// names, group names are not secrets); no api key or password literal from
+// either production file appears anywhere in this file.
+
+describe('groupLimitsSnippet: golden YAML, spec.plugin.llmgateway.groups.<name>.limits', () => {
+  it('renders one configured field', () => {
+    expect(groupLimitsSnippet('friends', { requestsPerDay: 1000 })).toBe(
+      ['spec:', '  plugin:', '    llmgateway:', '      groups:', '        friends:', '          limits:', '            requestsPerDay: 1000'].join(
+        '\n',
+      ),
+    )
+  })
+
+  it('renders every configured field in LimitsConfig field order, regardless of input key order', () => {
+    const snippet = groupLimitsSnippet('eng', {
+      costPerMonthUSD: 50,
+      requestsPerMinute: 10,
+      tokensPerDay: 500000,
+    })
+    expect(snippet).toBe(
+      [
+        'spec:',
+        '  plugin:',
+        '    llmgateway:',
+        '      groups:',
+        '        eng:',
+        '          limits:',
+        '            requestsPerMinute: 10',
+        '            tokensPerDay: 500000',
+        '            costPerMonthUSD: 50',
+      ].join('\n'),
+    )
+  })
+
+  it('omits an unset (0/undefined) field entirely, never emitting a fabricated 0', () => {
+    const snippet = groupLimitsSnippet('friends', { requestsPerDay: 0, costPerDayUSD: 5 })
+    expect(snippet).not.toContain('requestsPerDay')
+    expect(snippet).toContain('costPerDayUSD: 5')
+  })
+})
+
+describe('groupGrantSnippet: golden YAML, matches middleware.yaml groups.friends/groups.home shape', () => {
+  it('emits every one of the four access lists explicitly, even when empty — "friends" shape (providers set, rest empty)', () => {
+    const snippet = groupGrantSnippet('friends', { providers: ['minimax', 'uni'], models: [], mcpServers: [], agents: [] })
+    expect(snippet).toBe(
+      [
+        'spec:',
+        '  plugin:',
+        '    llmgateway:',
+        '      groups:',
+        '        friends:',
+        '          providers: [minimax, uni]',
+        '          models: []',
+        '          mcpServers: []',
+        '          agents: []',
+      ].join('\n'),
+    )
+  })
+
+  it('renders "home" shape — every list empty (unrestricted)', () => {
+    const snippet = groupGrantSnippet('home', { providers: [], models: [], mcpServers: [], agents: [] })
+    expect(snippet).toBe(
+      [
+        'spec:',
+        '  plugin:',
+        '    llmgateway:',
+        '      groups:',
+        '        home:',
+        '          providers: []',
+        '          models: []',
+        '          mcpServers: []',
+        '          agents: []',
+      ].join('\n'),
+    )
+  })
+})
+
+describe('modelMetaSnippet: golden YAML flow map, matches middleware.yaml modelMeta entries exactly', () => {
+  it('matches the gx10-embed entry shape: "{ contextTokens: 16384, free: true }"', () => {
+    const snippet = modelMetaSnippet('gx10-embed/text-embedding-qwen3-0.6b', { contextTokens: 16384, free: true })
+    expect(snippet).toBe(
+      ['spec:', '  plugin:', '    llmgateway:', '      modelMeta:', '        "gx10-embed/text-embedding-qwen3-0.6b": { contextTokens: 16384, free: true }'].join(
+        '\n',
+      ),
+    )
+  })
+
+  it('matches the "gx10/current" entry shape: "{ free: true }"', () => {
+    const snippet = modelMetaSnippet('gx10/current', { free: true })
+    expect(snippet.split('\n').at(-1)).toBe('        "gx10/current": { free: true }')
+  })
+
+  // P2 item 11: modelMeta keys are ALWAYS quoted in production, even a
+  // bare id with no "/" — unlike pricingSnippet below, whose own golden
+  // test (examples/kubernetes.yaml, read this session) shows an
+  // unquoted bare id in that DIFFERENT config section.
+  it('a bare model id with no "/" or ":" is still quoted — modelMeta always quotes, unlike pricing', () => {
+    const snippet = modelMetaSnippet('ornith-397b', { contextTokens: 262144, free: true })
+    expect(snippet.split('\n').at(-1)).toBe('        "ornith-397b": { contextTokens: 262144, free: true }')
+  })
+
+  it('field order is always contextTokens, free — contextTokens alone', () => {
+    const snippet = modelMetaSnippet('openai/gpt-4', { contextTokens: 128000 })
+    expect(snippet.split('\n').at(-1)).toBe('        "openai/gpt-4": { contextTokens: 128000 }')
+  })
+
+  it('omits every field the caller did not set — an empty ModelMeta renders "{}"', () => {
+    const snippet = modelMetaSnippet('openai/gpt-4', {})
+    expect(snippet.split('\n').at(-1)).toBe('        "openai/gpt-4": {}')
+  })
+})
+
+describe('pricingSnippet: golden YAML flow map, matches examples/kubernetes.yaml pricing entry exactly', () => {
+  it('matches the "gpt-5-mini" entry shape: "pricing:\\n  gpt-5-mini: {inputPerM: 0.25, outputPerM: 2.0}"', () => {
+    const snippet = pricingSnippet('gpt-5-mini', { inputPerM: 0.25, outputPerM: 2.0 })
+    expect(snippet).toBe(
+      ['spec:', '  plugin:', '    llmgateway:', '      pricing:', '        gpt-5-mini: { inputPerM: 0.25, outputPerM: 2 }'].join('\n'),
+    )
+  })
+
+  it('nests under spec.plugin.llmgateway.pricing, NOT modelMeta — a different config section from ModelMetaForm', () => {
+    const snippet = pricingSnippet('openai/gpt-4', { inputPerM: 0.5, outputPerM: 1.5 })
+    expect(snippet).toContain('      pricing:')
+    expect(snippet).not.toContain('modelMeta')
+  })
+
+  it('quotes a "provider/model" canonical id (contains "/")', () => {
+    const snippet = pricingSnippet('openai/gpt-4', { inputPerM: 0.5, outputPerM: 1.5 })
+    expect(snippet.split('\n').at(-1)).toBe('        "openai/gpt-4": { inputPerM: 0.5, outputPerM: 1.5 }')
+  })
+
+  it('field order is always inputPerM then outputPerM', () => {
+    const snippet = pricingSnippet('bare-model', { inputPerM: 1, outputPerM: 2 })
+    expect(snippet.split('\n').at(-1)).toBe('        bare-model: { inputPerM: 1, outputPerM: 2 }')
+  })
+})
+
+describe('userLimitsJsonFragment / userGrantJsonFragment: bare JSON fields for an EXISTING users.json entry', () => {
+  it('renders the limits fragment in LimitsConfig field order', () => {
+    expect(userLimitsJsonFragment({ costPerMonthUSD: 5, requestsPerDay: 100 })).toBe('"limits": {"requestsPerDay": 100, "costPerMonthUSD": 5}')
+  })
+
+  it('renders the grant fragment — providers then models, both present', () => {
+    expect(userGrantJsonFragment({ providers: ['gx10'], models: ['gx10/current'] })).toBe('"providers": ["gx10"], "models": ["gx10/current"]')
+  })
+
+  it('renders only providers when models is empty — matches barteq\'s real shape ("providers": ["gx10"]) structurally', () => {
+    expect(userGrantJsonFragment({ providers: ['gx10'], models: [] })).toBe('"providers": ["gx10"]')
+  })
+})
+
+describe('userJsonLine: golden JSON, matches users-configmap.yaml entry shape exactly (fabricated apiKey, never a real one)', () => {
+  it('matches the "barteq" entry shape: name, apiKey, group, providers', () => {
+    const line = userJsonLine({ name: 'barteq', apiKey: 'sk-test-FAKEKEY0000000000000000000000000000', group: 'friends', providers: ['gx10'] })
+    expect(line).toBe('{"name": "barteq", "apiKey": "sk-test-FAKEKEY0000000000000000000000000000", "group": "friends", "providers": ["gx10"]}')
+  })
+
+  it('matches the "admin" entry shape: name, apiKey, group, admin', () => {
+    const line = userJsonLine({ name: 'admin', apiKey: 'sk-test-FAKEKEY0000000000000000000000000000', group: 'home', admin: true })
+    expect(line).toBe('{"name": "admin", "apiKey": "sk-test-FAKEKEY0000000000000000000000000000", "group": "home", "admin": true}')
+  })
+
+  it('matches a minimal entry shape: name, apiKey, group only (no providers/admin)', () => {
+    const line = userJsonLine({ name: 'yalso', apiKey: 'sk-test-FAKEKEY0000000000000000000000000000', group: 'home' })
+    expect(line).toBe('{"name": "yalso", "apiKey": "sk-test-FAKEKEY0000000000000000000000000000", "group": "home"}')
+  })
+
+  it('emits "groups" (plural) instead of "group" when multiple groups are set', () => {
+    const line = userJsonLine({ name: 'multi', apiKey: 'sk-test-x', groups: ['home', 'friends'] })
+    expect(line).toBe('{"name": "multi", "apiKey": "sk-test-x", "groups": ["home", "friends"]}')
+  })
+
+  it('includes a nested limits object and admin, in key order name/apiKey/group/groups/providers/models/limits/admin', () => {
+    const line = userJsonLine({
+      name: 'full',
+      apiKey: 'sk-test-x',
+      group: 'friends',
+      providers: ['gx10'],
+      models: ['gx10/current'],
+      limits: { requestsPerDay: 10 },
+      admin: true,
+    })
+    expect(line).toBe(
+      '{"name": "full", "apiKey": "sk-test-x", "group": "friends", "providers": ["gx10"], "models": ["gx10/current"], "limits": {"requestsPerDay": 10}, "admin": true}',
+    )
+  })
+
+  it('omits admin entirely when false (never emits "admin": false, matching every non-admin production entry)', () => {
+    const line = userJsonLine({ name: 'plain', apiKey: 'sk-test-x', group: 'home', admin: false })
+    expect(line).not.toContain('admin')
+  })
+})
+
+describe('validatePersonalGrant: mirrors auth.go\'s models-without-providers rejection', () => {
+  it('rejects models with no providers', () => {
+    expect(validatePersonalGrant([], ['gx10/current'])).not.toBeNull()
+  })
+
+  it('accepts models with at least one provider', () => {
+    expect(validatePersonalGrant(['gx10'], ['gx10/current'])).toBeNull()
+  })
+
+  it('accepts providers with no models (providers-only grant)', () => {
+    expect(validatePersonalGrant(['gx10'], [])).toBeNull()
+  })
+
+  it('accepts an entirely empty grant', () => {
+    expect(validatePersonalGrant([], [])).toBeNull()
+  })
+})
+
+describe('isValidName', () => {
+  it.each([
+    ['gx10-embed', true],
+    ['friends_2', true],
+    ['eng.team', true],
+    ['has space', false],
+    ['', false],
+    ['slash/here', false],
+    ['wild*card', false],
+  ])('%s -> %s', (name, expected) => {
+    expect(isValidName(name)).toBe(expected)
+  })
+})
+
+describe('isValidNonNegative', () => {
+  it.each([
+    [0, true],
+    [1, true],
+    [0.5, true],
+    [-1, false],
+    [NaN, false],
+    [Infinity, false],
+  ])('%s -> %s', (n, expected) => {
+    expect(isValidNonNegative(n)).toBe(expected)
+  })
+})
+
+// P2 item 12: LimitsConfig.requestsPerMinute/requestsPerDay/tokensPerDay/
+// tokensPerMonth and ModelMetaConfig.ContextTokens are Go int64/int —
+// isValidNonNegative alone (fractions allowed) lets a value through that
+// json.Unmarshal rejects server-side.
+describe('isValidNonNegativeInt', () => {
+  it.each([
+    [0, true],
+    [1, true],
+    [1000, true],
+    [0.5, false],
+    [-1, false],
+    [NaN, false],
+    [Infinity, false],
+  ])('%s -> %s', (n, expected) => {
+    expect(isValidNonNegativeInt(n)).toBe(expected)
+  })
+})
+
+// P3 item 27: auth.go's buildEntry only requires a non-empty user name —
+// no configNamePattern character restriction (that pattern exists only
+// because provider/mcpServers/agents names are embedded as URL path
+// segments; a user name never is).
+describe('isValidUserName', () => {
+  it.each([
+    ['alice', true],
+    ['jan@x', true],
+    ["O'Brien", true],
+    ['has space', true],
+    ['', false],
+    ['   ', false],
+  ])('%s -> %s', (name, expected) => {
+    expect(isValidUserName(name)).toBe(expected)
+  })
+})
+
+describe('generateApiKey / API_KEY_PLACEHOLDER', () => {
+  it('the placeholder is visibly not a real key', () => {
+    expect(API_KEY_PLACEHOLDER).toBe('sk-llmgw-REPLACE_ME')
+  })
+
+  it('generates a "sk-llmgw-" prefixed base64url token from 32 random bytes', () => {
+    const spy = vi.spyOn(crypto, 'getRandomValues').mockImplementation(((arr: Uint8Array) => {
+      arr.fill(7)
+      return arr
+    }) as typeof crypto.getRandomValues)
+    try {
+      const key = generateApiKey()
+      expect(key.startsWith('sk-llmgw-')).toBe(true)
+      expect(key).not.toContain('+')
+      expect(key).not.toContain('/')
+      expect(key).not.toContain('=')
+      expect(key.length).toBeGreaterThan('sk-llmgw-'.length)
+    } finally {
+      spy.mockRestore()
+    }
+  })
+
+  it('two calls produce different keys (real CSPRNG, not mocked)', () => {
+    expect(generateApiKey()).not.toBe(generateApiKey())
+  })
+})
diff --git a/webui/src/lib/snippets.ts b/webui/src/lib/snippets.ts
new file mode 100644
index 0000000..9d1a2cb
--- /dev/null
+++ b/webui/src/lib/snippets.ts
@@ -0,0 +1,293 @@
+// Config page's ChangeHelper (redesign-plan.md section 3.4): every form
+// (LimitsForm, GrantForm, PricingForm, ModelMetaForm, UserForm) funnels
+// through this module to build the actual paste-ready text — the ONE place
+// that knows the production file's exact shapes (home-cluster namespaces/
+// traefik/base/llmgateway/middleware.yaml, users-configmap.yaml), so every
+// form's snippet output is provably identical in format, not five
+// independent guesses. Group/provider/admin snippets are YAML (lib/
+// yaml-emit.ts, nested at spec.plugin.llmgateway.<section>); a user's own
+// entry lives in users.json instead, so USER-targeted output is a
+// single-line JSON object (new user) or a bare JSON field fragment (adding
+// limits/a personal grant to an EXISTING user's line) — never YAML.
+//
+// Validation lives here too, not in each form component, for the same
+// "one place, not five copies" reason: NAME_PATTERN/isValidName (provider
+// and group names), isValidNonNegative (every limit/price field), and
+// validatePersonalGrant (auth.go's own "models without providers" rejection
+// — auth.go ~1006, a user/group with a `models` glob but an EMPTY
+// `providers` list can never actually reach any of those models, since
+// authorizedProviders is computed first and gates model resolution).
+import { emitConfigSnippet, emitYamlFlowMap, emitYamlKey, emitYamlScalar } from '@/lib/yaml-emit'
+import type { YamlValue } from '@/lib/yaml-emit'
+import type { LimitsConfig } from '@/types/api'
+
+/** NAME_PATTERN is the operator-facing name rule every provider/group id must satisfy — letters, digits, dot, underscore, hyphen, matching every real name in middleware.yaml (anthropic, gx10-embed, macstudio-rerank, friends, ...) and mirroring the plugin's own path.Match glob-safe charset. */
+export const NAME_PATTERN = /^[a-zA-Z0-9._-]+$/
+
+/** isValidName reports whether a provider/group name satisfies NAME_PATTERN — GrantForm/LimitsForm's own `targetKind === 'group'` path, and PricingForm/ModelMetaForm's provider-prefixed model ids indirectly (via NAME_PATTERN-shaped provider segments). NOT for a user name — see isValidUserName below. */
+export function isValidName(name: string): boolean {
+  return NAME_PATTERN.test(name)
+}
+
+/**
+ * isValidUserName mirrors auth.go's own buildEntry check (~955-975,
+ * ground truth): a user name only needs to be non-empty. Go deliberately
+ * does NOT apply configNamePattern's provider/mcpServers/agents character
+ * restriction (providers.go ~497-502, `^[a-zA-Z0-9._-]+$`) to user names
+ * — that pattern exists ONLY because those three kinds get embedded
+ * verbatim as a URL path segment (passthroughRoute, targetRoute); a user
+ * name is never used as a route path segment anywhere, only as a
+ * counter-key component and a JSON field (auth.go's own doc comment,
+ * word for word: "Restricting the character set beyond 'non-empty' would
+ * risk rejecting a real, currently-working operator-chosen name"). P3
+ * item 27: GrantForm.vue/LimitsForm.vue/UserForm.vue used to apply
+ * isValidName (NAME_PATTERN) to a user name too, so a real user such as
+ * "jan@x" could never get a snippet. userJsonLine/userGrantJsonFragment/
+ * userLimitsJsonFragment all go through JSON.stringify for every string
+ * field, so relaxing this check to match Go carries no injection risk.
+ */
+export function isValidUserName(name: string): boolean {
+  return name.trim() !== ''
+}
+
+/** isValidNonNegative reports whether a limit/price field is a finite, non-negative number — every LimitsConfig/pricing field's own domain (a negative or NaN limit/price is meaningless). Fractions ARE valid here: costPerDayUSD/costPerMonthUSD (LimitsConfig) and inputPerM/outputPerM (ModelPricing) are all Go float64 fields. */
+export function isValidNonNegative(n: number): boolean {
+  return Number.isFinite(n) && n >= 0
+}
+
+/**
+ * isValidNonNegativeInt reports whether a count/limit field is a finite,
+ * non-negative WHOLE number — the domain LimitsForm.vue's
+ * requestsPerMinute/requestsPerDay/tokensPerDay/tokensPerMonth
+ * (LimitsConfig, all Go `int64`) and ModelMetaForm.vue's contextTokens
+ * (ModelMetaConfig.ContextTokens, Go `int`) actually decode into (P2 item
+ * 12): `json.Unmarshal` rejects a fractional value like `1.5` against an
+ * int64/int target outright, so a snippet built from an unchecked
+ * fraction would fail to apply, not just round unexpectedly.
+ */
+export function isValidNonNegativeInt(n: number): boolean {
+  return Number.isInteger(n) && n >= 0
+}
+
+/**
+ * validatePersonalGrant mirrors auth.go's own buildEntry rejection
+ * (~line 1005-1007, ground truth: redesign-plan.md section 0): a USER's
+ * personal `models` glob list with an EMPTY `providers` list is rejected
+ * outright — `llmgateway: user %q: personal "models" requires personal
+ * "providers"`. This is a USER-ONLY rule (GrantForm.vue must call this
+ * only when targetKind === 'user'): a GROUP's own `providers: []` means
+ * "every configured provider" (matchesGlob's own empty-means-all
+ * contract, auth.go ~487-490) and is applied directly with no such check
+ * at group-construction time (auth.go ~763) — a group with `providers: []`
+ * and a `models` list is valid config today. For a user's PERSONAL grant
+ * specifically, that same empty-means-all reading is the problem, not the
+ * fix: it would silently widen the grant to reach every configured
+ * provider, including ones no member group of that user covers at all
+ * (auth.go's own comment, ~995-1000) — so Go rejects it rather than
+ * silently granting more than the operator meant to type. Returns an
+ * error string when invalid, null when the grant is acceptable.
+ */
+export function validatePersonalGrant(providers: string[], models: string[]): string | null {
+  if (models.length > 0 && providers.length === 0) {
+    return '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).'
+  }
+  return null
+}
+
+/** LIMITS_FIELD_ORDER is LimitsConfig's own field order (types/api.ts) — the single source of truth every limits snippet (YAML block or JSON fragment) below renders in, so the two never drift relative to each other. */
+const LIMITS_FIELD_ORDER: (keyof LimitsConfig)[] = [
+  'requestsPerMinute',
+  'requestsPerDay',
+  'tokensPerDay',
+  'tokensPerMonth',
+  'costPerDayUSD',
+  'costPerMonthUSD',
+]
+
+/** limitsEntries reads only the CONFIGURED (truthy) fields off a LimitsConfig, in canonical order — mirrors lib/format.ts's formatLimits/lib/usage-bars.ts's budgetRatios own "0/omitted means unlimited" convention: an unset limit is never emitted as `0`. */
+function limitsEntries(limits: LimitsConfig): [string, number][] {
+  const out: [string, number][] = []
+  for (const key of LIMITS_FIELD_ORDER) {
+    const value = limits[key]
+    if (value) out.push([key, value])
+  }
+  return out
+}
+
+/** groupLimitsSnippet builds a group's YAML limits block, nested at spec.plugin.llmgateway.groups.<name>.limits — LimitsForm's group-target output. */
+export function groupLimitsSnippet(groupName: string, limits: LimitsConfig): string {
+  const body: { [key: string]: YamlValue | undefined } = {}
+  for (const [key, value] of limitsEntries(limits)) body[key] = value
+  return emitConfigSnippet(['groups', groupName], { limits: body })
+}
+
+function jsonString(s: string): string {
+  return JSON.stringify(s)
+}
+
+function jsonStringArray(values: string[]): string {
+  return `[${values.map(jsonString).join(', ')}]`
+}
+
+/** jsonLimitsObject renders a LimitsConfig as a JSON object literal (no surrounding key) — "{\"requestsPerDay\": 1000}" — the SAME field order/omit-when-unset convention limitsEntries applies for the YAML path, just JSON syntax instead. */
+function jsonLimitsObject(limits: LimitsConfig): string {
+  const parts = limitsEntries(limits).map(([key, value]) => `${jsonString(key)}: ${value}`)
+  return `{${parts.join(', ')}}`
+}
+
+/** userLimitsJsonFragment builds the bare `"limits": {...}` field to paste into an EXISTING user's users.json line — LimitsForm's user-target output (a user's own limits live inside their JSON object, not a separate YAML block). */
+export function userLimitsJsonFragment(limits: LimitsConfig): string {
+  return `"limits": ${jsonLimitsObject(limits)}`
+}
+
+/** GroupGrant is the four access lists GroupConfig carries (llmgateway.go) — GrantForm's group-target input. Every field is always emitted, even empty (middleware.yaml's own "every field explicit and empty, not a bare {}" convention, groups.home). */
+export interface GroupGrant {
+  providers: string[]
+  models: string[]
+  mcpServers: string[]
+  agents: string[]
+}
+
+/** groupGrantSnippet builds a group's YAML access-list block, nested at spec.plugin.llmgateway.groups.<name> — GrantForm's group-target output. */
+export function groupGrantSnippet(groupName: string, grant: GroupGrant): string {
+  return emitConfigSnippet(['groups', groupName], {
+    providers: grant.providers,
+    models: grant.models,
+    mcpServers: grant.mcpServers,
+    agents: grant.agents,
+  })
+}
+
+/** userGrantJsonFragment builds the bare `"providers": [...], "models": [...]` fields to paste into an EXISTING user's users.json line — GrantForm's user-target (personal grant) output. Only non-empty lists are emitted (an omitted personal-grant field means "nothing extra beyond the user's group", the same "0/omitted means unset" convention every other optional field in this file follows) — callers MUST reject the grant first via validatePersonalGrant. */
+export function userGrantJsonFragment(grant: { providers: string[]; models: string[] }): string {
+  const parts: string[] = []
+  if (grant.providers.length > 0) parts.push(`"providers": ${jsonStringArray(grant.providers)}`)
+  if (grant.models.length > 0) parts.push(`"models": ${jsonStringArray(grant.models)}`)
+  return parts.join(', ')
+}
+
+/**
+ * ModelMeta is a model's modelMeta entry — every field independently
+ * optional (ModelMetaConfig, llmgateway.go: `contextTokens`,
+ * `inputCostPerMTokMicroUsd`, `outputCostPerMTokMicroUsd`, `free`), mirroring
+ * AdminModelMetaView/AdminCatalogModel's own "undefined means unset"
+ * convention. ModelMetaForm sets only contextTokens/free — the two fields
+ * this webui exposes an editor for (its own doc comment). PricingForm
+ * does NOT go through this type or modelMetaSnippet below: per-token
+ * price overrides that drive BILLING live in the top-level Config.Pricing
+ * map (`spec.plugin.llmgateway.pricing`, ModelPricing{InputPerM,
+ * OutputPerM} — see pricingSnippet), a config section entirely distinct
+ * from modelMeta's own cost fields, which only drive metadata EXPOSURE
+ * (GET /v1/models, Config's own ModelMeta doc comment: "distinct from
+ * Pricing above, which drives request cost ACCOUNTING").
+ */
+export interface ModelMeta {
+  contextTokens?: number
+  free?: boolean
+}
+
+/**
+ * modelMetaSnippet builds a model's modelMeta YAML entry as a single-line
+ * flow map, matching middleware.yaml's own convention EXACTLY (golden
+ * strings, e.g. `"gx10-embed/text-embedding-qwen3-0.6b": { contextTokens:
+ * 16384, free: true }`): field order contextTokens, free — only the
+ * fields the caller actually set, in that fixed order, every other field
+ * entirely absent from the flow map (never a fabricated 0/false). modelId
+ * is ALWAYS quoted (JSON.stringify, not lib/yaml-emit.ts's conditional
+ * emitYamlKey — production quotes every modelMeta id, P2 item 11), and
+ * the flow map itself via emitYamlFlowMap — placed at modelMeta's own
+ * fixed 4-level indent by hand rather than through the generic recursive
+ * block renderer, since a flow map is a single line, not a further nested
+ * block.
+ */
+export function modelMetaSnippet(modelId: string, meta: ModelMeta): string {
+  const entries: [string, boolean | number][] = []
+  if (meta.contextTokens !== undefined) entries.push(['contextTokens', meta.contextTokens])
+  if (meta.free !== undefined) entries.push(['free', meta.free])
+  const flow = emitYamlFlowMap(entries)
+  // Always quoted (JSON.stringify, not the conditional emitYamlKey) — the
+  // production file quotes every modelMeta id regardless of whether
+  // emitYamlKey's own general rule would require it (P2 item 11),
+  // matching pricingSnippet's identical convention below.
+  return ['spec:', '  plugin:', '    llmgateway:', '      modelMeta:', `        ${JSON.stringify(modelId)}: ${flow}`].join('\n')
+}
+
+/** ModelPricingOverride mirrors ModelPricing exactly (llmgateway.go: `InputPerM float64 json:"inputPerM"`, `OutputPerM float64 json:"outputPerM"`) — the billing-authoritative per-token price override, keyed by canonical model id under the top-level Config.Pricing map. Both fields are required together (PricingForm.vue's own validation): a one-sided override has no billing meaning. */
+export interface ModelPricingOverride {
+  inputPerM: number
+  outputPerM: number
+}
+
+/**
+ * pricingSnippet builds one model's entry in the top-level `pricing` map
+ * (`spec.plugin.llmgateway.pricing.<id>`, Config.Pricing/ModelPricing,
+ * llmgateway.go) as a single-line flow map — matching examples/
+ * kubernetes.yaml's own real shape exactly: `gpt-5-mini: {inputPerM: 0.25,
+ * outputPerM: 2.0}`. Hand-built at `pricing`'s own fixed depth, the same
+ * convention modelMetaSnippet above follows for its own sibling top-level
+ * map — a flow map is a single line, not a further nested block, so it is
+ * not routed through emitConfigSnippet's generic recursive block
+ * renderer.
+ */
+export function pricingSnippet(modelId: string, pricing: ModelPricingOverride): string {
+  const flow = emitYamlFlowMap([
+    ['inputPerM', pricing.inputPerM],
+    ['outputPerM', pricing.outputPerM],
+  ])
+  // Conditional (yaml-emit.ts's own emitYamlKey), NOT always-quoted —
+  // unlike modelMetaSnippet's own convention above: examples/
+  // kubernetes.yaml's real "pricing:" entry (line 146, read this session)
+  // is `gpt-5-mini: {inputPerM: 0.25, outputPerM: 2.0}`, a bare id with
+  // no quotes, so pricing does NOT share modelMeta's "always quote"
+  // production convention — it follows the general rule instead.
+  return ['spec:', '  plugin:', '    llmgateway:', '      pricing:', `        ${emitYamlKey(modelId)}: ${flow}`].join('\n')
+}
+
+/** API_KEY_PLACEHOLDER is UserForm's default apiKey field value before the operator clicks "Generate" — visibly a placeholder, never mistaken for a real key (Q10, redesign-plan.md DECISIONS: "browser key generation offered, placeholder by default"). */
+export const API_KEY_PLACEHOLDER = 'sk-llmgw-REPLACE_ME'
+
+/** generateApiKey produces a real random bearer token client-side: 32 bytes from the Web Crypto CSPRNG, base64url-encoded — the same byte length and character set as the production tokens in users-configmap.yaml (openssl rand -hex 24 there is 24 bytes/48 hex chars; 32 raw bytes here is a comparable-or-stronger entropy budget, base64url rather than hex purely for a shorter pasted string). Never sent anywhere — ChangeHelper only ever displays it for the operator to copy into their own users.json edit. */
+export function generateApiKey(): string {
+  const bytes = crypto.getRandomValues(new Uint8Array(32))
+  let binary = ''
+  for (const b of bytes) binary += String.fromCharCode(b)
+  const base64 = btoa(binary)
+  return `sk-llmgw-${base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')}`
+}
+
+/** UserSnippetInput is UserForm's full input shape — mirrors AdminConsumerUser (types/api.ts) plus the two config-only fields (groups plural, limits) that view never carries but users.json itself supports. */
+export interface UserSnippetInput {
+  name: string
+  apiKey: string
+  /** Single primary group — production's own convention (users-configmap.yaml: every existing user sets exactly this field). Mutually exclusive with `groups` in practice (userJsonLine emits whichever is set; a caller offering both is a UserForm UI bug, not something this function arbitrates). */
+  group?: string
+  /** Multi-group membership (newer plugin support, mirrors AdminUsageEntryView.groups' own multi-group doc comment) — used instead of `group` when the operator selects more than one. */
+  groups?: string[]
+  providers?: string[]
+  models?: string[]
+  limits?: LimitsConfig
+  admin?: boolean
+}
+
+/**
+ * userJsonLine builds one users.json array entry as a single-line JSON
+ * object — GOLDEN-STRING matched against users-configmap.yaml's own real
+ * entries, e.g. `{"name": "barteq", "apiKey": "sk-friend-...", "group":
+ * "friends", "providers": ["gx10"]}`: key order name, apiKey, group,
+ * groups, providers, models, limits, admin (redesign-plan.md section 3.4),
+ * `": "` after every key and `", "` between fields (NOT JSON.stringify's
+ * own no-space-after-colon default — production's own file has the space),
+ * only present/truthy fields emitted, `admin` only ever appears as the
+ * literal `true` (an admin:false entry is simply omitted, matching every
+ * non-admin user in the production file).
+ */
+export function userJsonLine(user: UserSnippetInput): string {
+  const parts: string[] = [`"name": ${jsonString(user.name)}`, `"apiKey": ${jsonString(user.apiKey)}`]
+  if (user.group) parts.push(`"group": ${jsonString(user.group)}`)
+  if (user.groups && user.groups.length > 0) parts.push(`"groups": ${jsonStringArray(user.groups)}`)
+  if (user.providers && user.providers.length > 0) parts.push(`"providers": ${jsonStringArray(user.providers)}`)
+  if (user.models && user.models.length > 0) parts.push(`"models": ${jsonStringArray(user.models)}`)
+  if (user.limits && limitsEntries(user.limits).length > 0) parts.push(`"limits": ${jsonLimitsObject(user.limits)}`)
+  if (user.admin) parts.push(`"admin": ${emitYamlScalar(true)}`)
+  return `{${parts.join(', ')}}`
+}
diff --git a/webui/src/lib/target-columns.spec.ts b/webui/src/lib/target-columns.spec.ts
index 0264b92..ea83ec5 100644
--- a/webui/src/lib/target-columns.spec.ts
+++ b/webui/src/lib/target-columns.spec.ts
@@ -1,9 +1,10 @@
 import { isVNode } from 'vue'
 import { describe, expect, it } from 'vitest'
 
+import CompactNumber from '@/components/CompactNumber.vue'
 import { Badge } from '@/components/ui/badge'
-import { targetColumns } from './target-columns'
-import type { AdminTargetHealthView, AdminTargetView } from '@/types/api'
+import { composeTargetId, parseTargetCallerId, targetCallerColumns, targetColumns } from './target-columns'
+import type { AdminTargetHealthView, AdminTargetView, AdminTotalsResponse } from '@/types/api'
 
 /**
  * Target health rendering (feat/target-health): mirrors usage-columns.
@@ -184,3 +185,94 @@ describe('targetColumns: access column', () => {
     expect(children.every((c) => isVNode(c) && c.type === Badge)).toBe(true)
   })
 })
+
+describe('targetColumns: name column selection', () => {
+  it('renders plain text with no onSelect (default, backward-compatible)', () => {
+    const col = targetColumns().find((c) => c.id === 'name')
+    const cell = col?.cell as (ctx: { row: { original: AdminTargetView } }) => unknown
+    const rendered = cell({ row: { original: testTarget({ state: 'unknown', consecutiveFailures: 0 }) } })
+    expect(isVNode(rendered) && rendered.type).toBe('span')
+  })
+
+  it('renders a clickable button that invokes onSelect with the row when given', () => {
+    const selected: AdminTargetView[] = []
+    const col = targetColumns((t) => selected.push(t)).find((c) => c.id === 'name')
+    const cell = col?.cell as (ctx: { row: { original: AdminTargetView } }) => unknown
+    const target = testTarget({ state: 'unknown', consecutiveFailures: 0 })
+    const rendered = cell({ row: { original: target } })
+    expect(isVNode(rendered) && rendered.type).toBe('button')
+
+    const onClick = (rendered as { props?: Record<string, unknown> }).props?.onClick as (e: MouseEvent) => void
+    onClick({ stopPropagation: () => {} } as MouseEvent)
+    expect(selected).toEqual([target])
+  })
+})
+
+describe('composeTargetId', () => {
+  it('joins kind and name with a slash', () => {
+    expect(composeTargetId('mcp', 'fetch')).toBe('mcp/fetch')
+    expect(composeTargetId('agent', 'researcher')).toBe('agent/researcher')
+  })
+})
+
+describe('parseTargetCallerId', () => {
+  it('splits a well-formed "kind/target/caller" id into its three parts', () => {
+    expect(parseTargetCallerId('mcp/fetch/alice')).toEqual({ kind: 'mcp', target: 'fetch', caller: 'alice' })
+  })
+
+  it('handles a caller name that itself contains a slash by keeping it in `caller` verbatim', () => {
+    expect(parseTargetCallerId('agent/researcher/team/bob')).toEqual({ kind: 'agent', target: 'researcher', caller: 'team/bob' })
+  })
+
+  it('falls back to an empty target/caller for an id with no slash at all, without throwing', () => {
+    expect(parseTargetCallerId('malformed')).toEqual({ kind: '', target: '', caller: 'malformed' })
+  })
+
+  it('falls back to an empty caller for an id with only one slash', () => {
+    expect(parseTargetCallerId('mcp/fetch')).toEqual({ kind: 'mcp', target: 'fetch', caller: '' })
+  })
+})
+
+// dayOrMonthWindow moved to lib/range.ts (P2 item 2: a SHARED clamp used
+// by stores/consumers.ts, stores/spend.ts, AND this module's own
+// TargetCallers.vue — see range.spec.ts's own describe('dayOrMonthWindow').
+
+describe('targetCallerColumns', () => {
+  function row(id: string, req: number): AdminTotalsResponse['rows'][number] {
+    return { id, values: { req } }
+  }
+
+  it('omits the Target column when showTarget is false', () => {
+    const columns = targetCallerColumns(false)
+    expect(columns.find((c) => c.id === 'target')).toBeUndefined()
+    expect(columns.map((c) => c.id)).toEqual(['caller', 'requests'])
+  })
+
+  it('includes the Target column, rendering "kind/target", when showTarget is true', () => {
+    const columns = targetCallerColumns(true)
+    const col = columns.find((c) => c.id === 'target')
+    expect(col).toBeDefined()
+    const cell = col?.cell as (ctx: { row: { original: AdminTotalsResponse['rows'][number] } }) => unknown
+    const rendered = cell({ row: { original: row('mcp/fetch/alice', 3) } })
+    expect(isVNode(rendered) && rendered.children).toBe('mcp/fetch')
+  })
+
+  it('caller column reads the parsed caller name, falling back to the raw id', () => {
+    const columns = targetCallerColumns(false)
+    const col = columns.find((c) => c.id === 'caller') as unknown as {
+      accessorFn: (r: AdminTotalsResponse['rows'][number], i: number) => unknown
+    }
+    const accessor = col.accessorFn
+    expect(accessor(row('mcp/fetch/alice', 3), 0)).toBe('alice')
+    expect(accessor(row('malformed', 3), 0)).toBe('malformed')
+  })
+
+  it('requests column renders a CompactNumber reading values.req, defaulting to 0', () => {
+    const columns = targetCallerColumns(false)
+    const col = columns.find((c) => c.id === 'requests')
+    const cell = col?.cell as (ctx: { row: { original: AdminTotalsResponse['rows'][number] } }) => unknown
+    const rendered = cell({ row: { original: { id: 'mcp/fetch/alice', values: {} } } })
+    expect(isVNode(rendered) && rendered.type).toBe(CompactNumber)
+    expect(isVNode(rendered) && rendered.props?.value).toBe(0)
+  })
+})
diff --git a/webui/src/lib/target-columns.ts b/webui/src/lib/target-columns.ts
index cfa41ac..ec7ec61 100644
--- a/webui/src/lib/target-columns.ts
+++ b/webui/src/lib/target-columns.ts
@@ -4,7 +4,7 @@ import { h } from 'vue'
 import CompactNumber from '@/components/CompactNumber.vue'
 import { Badge } from '@/components/ui/badge'
 import { formatElapsedAgo, formatLatencyMs } from '@/lib/format'
-import type { AdminTargetHealthView, AdminTargetView } from '@/types/api'
+import type { AdminTargetHealthView, AdminTargetView, AdminTotalsResponse } from '@/types/api'
 
 /**
  * numericColumn builds one right-aligned, sortable request-counter
@@ -30,7 +30,7 @@ function numericColumn(id: string, header: string, read: (t: AdminTargetView) =>
 
 // --- target health (feat/target-health) ---
 //
-// Mirrors ProvidersView.vue's own healthBadgeVariant/healthBadgeLabel
+// Mirrors ProviderHealthPanel.vue's own healthBadgeVariant/healthBadgeLabel
 // convention for the discovery circuit breaker: a Badge only for the two
 // states worth flagging (unhealthy, unknown); the common healthy case
 // renders no badge at all, just muted inline text — the same "nothing to
@@ -107,20 +107,40 @@ function healthCell(health: AdminTargetHealthView) {
  * servers and the Agents DataTable in TargetsView.vue use (admin.go:
  * adminTargetView — the two tables share one identical row shape). name is
  * plain text (not the ModelChip copy treatment — a target name is not a
- * routable model id); url is muted and truncated with a title attribute
- * for the full value; health is the Badge/muted-text pair healthCell above
- * builds (feat/target-health); access renders as a Badge per allowed
- * group, or a muted "All groups" when unrestricted — the exact idiom
- * UsageView.vue's own group Access block already established (Providers/
- * Models/MCP servers/Agents dt/dd pairs there).
+ * routable model id) UNLESS `onSelect` is given, in which case it renders
+ * as a real `<button>` (same structural convention as EntityLink.vue: a
+ * click opens that target's own caller breakdown, TargetCallers.vue,
+ * rather than navigating away — redesign-plan.md section 3.4's
+ * "TargetCallers.vue expander"). url is muted and truncated with a title
+ * attribute for the full value; health is the Badge/muted-text pair
+ * healthCell above builds (feat/target-health); access renders as a
+ * Badge per allowed group, or a muted "All groups" when unrestricted —
+ * the exact idiom ConsumerDirectory.vue's own group Access block already
+ * established (Providers/Models/MCP servers/Agents dt/dd pairs there).
  */
-export function targetColumns(): ColumnDef<AdminTargetView, unknown>[] {
+export function targetColumns(onSelect?: (target: AdminTargetView) => void): ColumnDef<AdminTargetView, unknown>[] {
   return [
     {
       id: 'name',
       header: 'Name',
       accessorFn: (t) => t.name,
-      cell: ({ row }) => h('span', { class: 'font-medium' }, row.original.name),
+      cell: ({ row }) => {
+        if (!onSelect) return h('span', { class: 'font-medium' }, row.original.name)
+        return h(
+          '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 ${row.original.name}'s callers`,
+            onClick: (event: MouseEvent) => {
+              event.stopPropagation()
+              onSelect(row.original)
+            },
+          },
+          row.original.name,
+        )
+      },
     },
     {
       id: 'url',
@@ -166,3 +186,100 @@ export function targetColumns(): ColumnDef<AdminTargetView, unknown>[] {
     numericColumn('reqMonth', 'req/month', (t) => t.counters.requestsPerMonth),
   ]
 }
+
+// --- target x caller (redesign-plan.md section 3.4's "TargetCallers.vue
+// expander" + "top callers" card) ---
+//
+// GET /admin/api/usage/totals?kind=targetcaller (redesign-plan.md section
+// 1.3.v) has no dedicated row type in types/api.ts — AdminTotalsResponse
+// inlines its row shape rather than naming it, so `TargetCallerRow` is
+// derived from that response's own `rows` element type here (single source
+// of truth: a future field added to the inline shape needs no second edit
+// in this file).
+type TargetCallerRow = AdminTotalsResponse['rows'][number]
+
+export type TargetKind = 'mcp' | 'agent'
+
+/**
+ * composeTargetId builds the "mcp/{name}" / "agent/{name}" composite id
+ * GET /admin/api/usage/totals?kind=targetcaller&target= expects (admin.go)
+ * — the SAME prefix a targetcaller row's own `id` starts with
+ * (parseTargetCallerId below splits it back apart).
+ */
+export function composeTargetId(kind: TargetKind, name: string): string {
+  return `${kind}/${name}`
+}
+
+/**
+ * ParsedTargetCallerId is one targetcaller row's `id`
+ * ("mcp/fetch/alice" — AdminTotalsResponse's own doc comment) split into
+ * its three parts.
+ */
+export interface ParsedTargetCallerId {
+  kind: string
+  target: string
+  caller: string
+}
+
+/**
+ * parseTargetCallerId never throws: an id missing either slash (a
+ * version-skewed server, or a caller name that happens to contain no
+ * slash of its own — the only way this format is ambiguous) degrades
+ * gracefully rather than dropping the row — `target`/`caller` fall back to
+ * "" so a caller can still detect the shortfall (empty string, not
+ * undefined) and choose to render the raw id verbatim.
+ */
+export function parseTargetCallerId(id: string): ParsedTargetCallerId {
+  const first = id.indexOf('/')
+  if (first === -1) return { kind: '', target: '', caller: id }
+  const kind = id.slice(0, first)
+  const rest = id.slice(first + 1)
+  const second = rest.indexOf('/')
+  if (second === -1) return { kind, target: rest, caller: '' }
+  return { kind, target: rest.slice(0, second), caller: rest.slice(second + 1) }
+}
+
+/**
+ * targetCallerColumns builds the shared TanStack `ColumnDef` set
+ * TargetCallers.vue's DataTable uses for both its modes: a single
+ * target's own caller breakdown (`showTarget: false` — the panel's own
+ * heading already names the target) and the fleet-wide "top callers" card
+ * (`showTarget: true` — each row's own target is not implied by anything
+ * else on screen). `requests` is the only metric the server returns for
+ * this kind (contract: "targetcaller req only"), so there is no metric
+ * picker here, unlike model-table-columns.ts's multi-metric table.
+ */
+export function targetCallerColumns(showTarget: boolean): ColumnDef<TargetCallerRow, unknown>[] {
+  const columns: ColumnDef<TargetCallerRow, unknown>[] = []
+  if (showTarget) {
+    columns.push({
+      id: 'target',
+      header: 'Target',
+      accessorFn: (row) => {
+        const p = parseTargetCallerId(row.id)
+        return `${p.kind}/${p.target}`
+      },
+      cell: ({ row }) => {
+        const p = parseTargetCallerId(row.original.id)
+        return h('span', { class: 'font-mono text-xs text-muted-foreground' }, `${p.kind}/${p.target}`)
+      },
+    })
+  }
+  columns.push({
+    id: 'caller',
+    header: 'Caller',
+    accessorFn: (row) => parseTargetCallerId(row.id).caller || row.id,
+    cell: ({ row }) => {
+      const caller = parseTargetCallerId(row.original.id).caller
+      return h('span', { class: 'font-medium' }, caller || row.original.id)
+    },
+  })
+  columns.push({
+    id: 'requests',
+    header: 'Requests',
+    meta: { align: 'right' },
+    accessorFn: (row) => row.values.req ?? 0,
+    cell: ({ row }) => h(CompactNumber, { value: row.original.values.req ?? 0 }),
+  })
+  return columns
+}
diff --git a/webui/src/lib/usage-bars.spec.ts b/webui/src/lib/usage-bars.spec.ts
index 520aa54..c377f05 100644
--- a/webui/src/lib/usage-bars.spec.ts
+++ b/webui/src/lib/usage-bars.spec.ts
@@ -120,3 +120,9 @@ describe('budgetRatios', () => {
     expect(ratios.map((r) => r.id)).toEqual(['reqMin', 'reqDay', 'tokDay', 'tokMonth', 'costDay', 'costMonth'])
   })
 })
+
+// estimatedRunOutDate was removed (P2 item 14 — it disagreed with
+// lib/burndown.ts's runOutDate on an already-exceeded budget and on day 1
+// of the month; UserDetail.vue and BurnDownChart.vue now both call the
+// one function in lib/burndown.ts, which owns this coverage —
+// lib/burndown.spec.ts's own `describe('runOutDate', ...)`).
diff --git a/webui/src/lib/usage-bars.ts b/webui/src/lib/usage-bars.ts
index b9b9211..2303372 100644
--- a/webui/src/lib/usage-bars.ts
+++ b/webui/src/lib/usage-bars.ts
@@ -1,8 +1,9 @@
-// F1 (usage-vs-limit bars): pure ratio math for the Usage tab's per-scope
-// budget bars (UsageBar.vue), kept out of the component the same way
-// lib/provider-rate.ts keeps the Providers tab's success-rate math out of
-// ProvidersView.vue — vitest's node-environment config (vite.config.ts's
-// `test` block) exercises it directly, no component mount required.
+// F1 (usage-vs-limit bars): pure ratio math for the Consumers page's
+// per-scope budget bars (UsageBar.vue), kept out of the component the
+// same way lib/provider-rate.ts keeps ProviderHealthPanel.vue's own
+// success-rate math out of it — vitest's node-environment config
+// (vite.config.ts's `test` block) exercises it directly, no component
+// mount required.
 import type { AdminUsageEntryView } from '@/types/api'
 
 /** BAR_AMBER_THRESHOLD is the used/limit ratio at and above which a bar reads amber ("approaching the limit") — below it, a bar reads its normal (healthy) tier. */
@@ -53,9 +54,10 @@ export const MICROS_PER_USD = 1_000_000
 
 /**
  * BUDGET_RATIO_LABEL (P10) names each BudgetRatio id in accurate,
- * accessible text — shared by UsageView.vue's group-detail-grid bars and
- * usage-columns.ts's own per-column bars (UsageBar's `label` prop, its
- * aria-label). tokDay/tokMonth spell out "(in+out)" explicitly: the
+ * accessible text — shared by ConsumerDirectory.vue's group-detail-grid
+ * bars, usage-columns.ts's own per-column bars, and UserDetail.vue's
+ * headroom bars (UsageBar's `label` prop, its aria-label). tokDay/
+ * tokMonth spell out "(in+out)" explicitly: the
  * underlying ratio combines both directions (see budgetRatios' own doc
  * comment below), and unlike a sighted reader — who sees the separate
  * tokIn/tokOut columns beside it for context — a screen-reader user
@@ -129,3 +131,9 @@ export function budgetRatios(entry: AdminUsageEntryView): BudgetRatio[] {
   }
   return out
 }
+
+// estimatedRunOutDate was removed (P2 item 14, DRY): UserDetail.vue and
+// BurnDownChart.vue now both call lib/burndown.ts's own runOutDate, the
+// ONE run-out projection in this codebase — it used to disagree with this
+// one on an already-exceeded budget (null here vs `now` there) and on day
+// 1 of the month (clamped/overstated here vs null there).
diff --git a/webui/src/lib/usage-columns.spec.ts b/webui/src/lib/usage-columns.spec.ts
index b2880ae..d96d6b6 100644
--- a/webui/src/lib/usage-columns.spec.ts
+++ b/webui/src/lib/usage-columns.spec.ts
@@ -2,7 +2,7 @@ import type { VNode } from 'vue'
 import { isVNode } from 'vue'
 import { describe, expect, it } from 'vitest'
 
-import ScopeLink from '@/components/ScopeLink.vue'
+import EntityLink from '@/components/EntityLink.vue'
 import { usageColumns } from './usage-columns'
 import type { AdminUsageEntryView } from '@/types/api'
 
@@ -182,39 +182,87 @@ describe('usageColumns: F1 usage-vs-limit bars', () => {
   })
 })
 
-// F6 (ScopeLink id cell): the id column renders a ScopeLink pointed at
-// this row's own "kind:id" Charts scope, never a plain span — the click-
-// through-to-Charts affordance every Users/Groups/Members row gets.
-describe('usageColumns: F6 id cell is a ScopeLink', () => {
+// F6 (EntityLink id cell): the id column renders an EntityLink pointed at
+// Consumers?user={id}, never a plain span — the click-through-to-detail
+// affordance every Users/Members row gets.
+describe('usageColumns: F6 id cell is an EntityLink', () => {
   const columns = usageColumns('Name', 'Group', () => 'g')
   const col = columns.find((c) => c.id === 'id')
 
-  it('renders a ScopeLink vnode, not a plain span', () => {
+  it('renders an EntityLink vnode, not a plain span', () => {
     const rendered = cellOf(col)({ row: { original: testEntry({ id: 'alice', kind: 'user' }) } }) as VNode
-    expect(rendered.type).toBe(ScopeLink)
+    expect(rendered.type).toBe(EntityLink)
   })
 
-  it('builds the scope as "user:{id}" for a user row', () => {
+  it('builds kind "user" and the row id, with the label matching', () => {
     const rendered = cellOf(col)({ row: { original: testEntry({ id: 'alice', kind: 'user' }) } }) as VNode
-    expect(rendered.props?.scope).toBe('user:alice')
+    expect(rendered.props?.kind).toBe('user')
+    expect(rendered.props?.id).toBe('alice')
     expect(rendered.props?.label).toBe('alice')
   })
 
-  it('builds the scope as "group:{id}" for a group row', () => {
-    const rendered = cellOf(col)({ row: { original: testEntry({ id: 'eng', kind: 'group' }) } }) as VNode
-    expect(rendered.props?.scope).toBe('group:eng')
+  it('is not masked by storeDown — the link stays clickable even for a row with stale/unknown counters', () => {
+    const rendered = cellOf(col)({ row: { original: testEntry({ id: 'alice', kind: 'user', storeDown: true }) } }) as VNode
+    expect(rendered.type).toBe(EntityLink)
+  })
+})
+
+describe('usageColumns: last seen column', () => {
+  const now = new Date(Date.UTC(2026, 3, 16, 12, 0, 0))
+  const columns = usageColumns('Name', 'Group', () => 'g', now)
+  const col = columns.find((c) => c.id === 'lastSeen')
+
+  it('accessorFn reads the raw unix-seconds value, defaulting to 0 when unset', () => {
+    expect(accessorFnOf(col)(testEntry(), 0)).toBe(0)
+    expect(accessorFnOf(col)(testEntry({ lastSeen: 123 }), 0)).toBe(123)
   })
 
-  it('is not masked by storeDown — a scope link stays clickable even for a row with stale/unknown counters', () => {
-    const rendered = cellOf(col)({ row: { original: testEntry({ id: 'alice', kind: 'user', storeDown: true }) } }) as VNode
-    expect(rendered.type).toBe(ScopeLink)
+  it('cell renders "never" when unset', () => {
+    expect(cellOf(col)({ row: { original: testEntry() } })).toBe('never')
+  })
+
+  it('cell renders a relative-time label when set', () => {
+    const seconds = Math.floor(now.getTime() / 1000) - 300
+    expect(cellOf(col)({ row: { original: testEntry({ lastSeen: seconds }) } })).toBe('5m ago')
+  })
+
+  it('is NOT masked by storeDown — lastSeen is its own counter family, independent of the usage counters storeDown guards', () => {
+    const seconds = Math.floor(now.getTime() / 1000) - 300
+    expect(cellOf(col)({ row: { original: testEntry({ lastSeen: seconds, storeDown: true }) } })).toBe('5m ago')
+  })
+})
+
+describe('usageColumns: optional source column', () => {
+  it('is absent when no sourceValue is passed', () => {
+    const columns = usageColumns('Name', 'Group', () => 'g')
+    expect(columns.find((c) => c.id === 'source')).toBeUndefined()
+  })
+
+  it('is inserted right after the secondary column when sourceValue is passed', () => {
+    const columns = usageColumns('Name', 'Group', () => 'g', new Date(), (e) => (e.id === 'alice' ? 'inline' : undefined))
+    const ids = columns.map((c) => c.id)
+    expect(ids.indexOf('source')).toBe(ids.indexOf('secondary') + 1)
+  })
+
+  it('renders the resolved source text', () => {
+    const columns = usageColumns('Name', 'Group', () => 'g', new Date(), (e) => (e.id === 'alice' ? 'inline' : undefined))
+    const col = columns.find((c) => c.id === 'source')
+    const rendered = cellOf(col)({ row: { original: testEntry({ id: 'alice' }) } }) as VNode
+    expect(rendered.children).toBe('inline')
+  })
+
+  it('renders an em dash when the lookup returns undefined (no matching /consumers entry)', () => {
+    const columns = usageColumns('Name', 'Group', () => 'g', new Date(), () => undefined)
+    const col = columns.find((c) => c.id === 'source')
+    const rendered = cellOf(col)({ row: { original: testEntry({ id: 'bob' }) } }) as VNode
+    expect(rendered.children).toBe('—')
   })
 })
 
 // F4 (rejected/day column): destructive tint applies only once the count
 // is actually positive — a healthy scope (0 rejections) renders plain,
 // matching every other "nothing to show reads as no flag" indicator in
-// this panel (ProvidersView.vue's badges).
+// this panel (ProviderHealthPanel.vue's badges).
 describe('usageColumns: F4 rejected/day column', () => {
   const columns = usageColumns('Name', 'Group', () => 'g')
   const col = columns.find((c) => c.id === 'rejDay')
diff --git a/webui/src/lib/usage-columns.ts b/webui/src/lib/usage-columns.ts
index 6db9958..623e97c 100644
--- a/webui/src/lib/usage-columns.ts
+++ b/webui/src/lib/usage-columns.ts
@@ -2,10 +2,11 @@ import type { ColumnDef } from '@tanstack/vue-table'
 import { h } from 'vue'
 
 import CompactNumber from '@/components/CompactNumber.vue'
-import ScopeLink from '@/components/ScopeLink.vue'
+import EntityLink from '@/components/EntityLink.vue'
 import UsageBar from '@/components/UsageBar.vue'
 import { headroom, monthProgress, projectMonthEnd } from '@/lib/forecast'
 import { formatCost, formatExactInt, formatLimits } from '@/lib/format'
+import { formatLastSeen } from '@/lib/last-seen'
 import { BUDGET_RATIO_LABEL, budgetRatios } from '@/lib/usage-bars'
 import type { AdminUsageEntryView } from '@/types/api'
 
@@ -150,38 +151,84 @@ function costMonthProjColumn(elapsedFraction: number): ColumnDef<AdminUsageEntry
   }
 }
 
+/**
+ * sourceColumn (Consumers redesign, redesign-plan.md section 3.4) renders
+ * a user's directory source — 'inline' (defined directly in the plugin
+ * config) or 'file' (loaded from users.file, admin.go: adminConsumerUser.
+ * Source) — via the caller-supplied `sourceValue` lookup (ConsumerDirectory.
+ * vue joins this row's id against the /admin/api/consumers response, which
+ * this module has no fetch access to itself). Only ever added when a
+ * caller passes `sourceValue` to usageColumns (see its own doc comment) —
+ * a group row (no such concept) and the headless Groups sort toolbar never
+ * get this column at all. `sourceValue` returning undefined (a group's
+ * nested member row whose name has no matching /consumers entry yet, e.g.
+ * mid-fetch) renders an em dash rather than blank, so the column never
+ * looks like a rendering bug.
+ */
+function sourceColumn(sourceValue: (entry: AdminUsageEntryView) => string | undefined): ColumnDef<AdminUsageEntryView, unknown> {
+  return {
+    id: 'source',
+    header: 'Source',
+    accessorFn: (entry) => sourceValue(entry) ?? '',
+    cell: ({ row }) => h('span', { class: 'text-muted-foreground' }, sourceValue(row.original) ?? '—'),
+  }
+}
+
+/**
+ * lastSeenColumn (Consumers redesign) renders AdminUsageEntryView.lastSeen
+ * via lib/last-seen.ts's formatLastSeen — added unconditionally (unlike
+ * sourceColumn above): lastSeen is a fleet-wide counter written for BOTH
+ * user and group scopes (redesign-plan.md section 1.2's last-seen family:
+ * "user + every group scope"), so it is meaningful in every context
+ * usageColumns() is used in, not just the flat Users table. A storeDown
+ * row is NOT masked as "?" here (unlike every numericColumn) — lastSeen is
+ * its own separate counter family (a SET, not the same INCRBY scope
+ * counters storeDown actually guards), so a down usage store does not
+ * make this value stale/unknown the way it does for req/tok/cost.
+ */
+function lastSeenColumn(now: Date): ColumnDef<AdminUsageEntryView, unknown> {
+  return {
+    id: 'lastSeen',
+    header: 'Last seen',
+    accessorFn: (entry) => entry.lastSeen ?? 0,
+    cell: ({ row }) => formatLastSeen(row.original.lastSeen, now),
+  }
+}
+
 /**
  * usageColumns builds the shared TanStack `ColumnDef` set for one
  * AdminUsageEntryView table. Used by UsageTable.vue (the flat Users list,
- * and — reused unmodified — a group's nested member-user list inside the
- * Usage view's Groups accordion) and, headlessly (no `<Table>` render, see
- * that view's own doc comment for why), by UsageView.vue's Groups sort
- * bar, so both surfaces sort by the exact same column semantics.
+ * and — reused unmodified — a group's nested member-user list inside
+ * ConsumerDirectory.vue's Groups accordion) and, headlessly (no `<Table>`
+ * render, see that component's own doc comment for why), by its Groups
+ * sort bar, so both surfaces sort by the exact same column semantics.
  * idLabel/secondaryColumnLabel name the first two columns; secondaryValue
  * reads the second column's per-row value (a user's group name, or a
  * group's member count). `now` (F7) defaults to the real current time —
  * see costMonthProjColumn's own doc comment for why a caller can override
- * it.
+ * it. `sourceValue`, when supplied, inserts sourceColumn right after the
+ * secondary column — ConsumerDirectory.vue's flat Users table is the only
+ * caller that passes it (see sourceColumn's own doc comment).
  */
 export function usageColumns(
   idLabel: string,
   secondaryColumnLabel: string,
   secondaryValue: (entry: AdminUsageEntryView) => string,
   now: Date = new Date(),
+  sourceValue?: (entry: AdminUsageEntryView) => string | undefined,
 ): ColumnDef<AdminUsageEntryView, unknown>[] {
   const elapsedFraction = monthProgress(now)
-  return [
+  const columns: ColumnDef<AdminUsageEntryView, unknown>[] = [
     {
       id: 'id',
       header: idLabel,
       accessorFn: (entry) => entry.id,
-      // F6: ScopeLink jumps to this row's own Charts scope — "user:{id}"
-      // or "group:{id}", matching entry.kind exactly (admin.go only ever
-      // sets kind to "user"/"group"/"total"; a table row is always the
-      // first two, the "total" entry renders separately in the Total
-      // card, never as a table row — see UsageView.vue).
-      cell: ({ row }) =>
-        h(ScopeLink, { class: 'font-medium', label: row.original.id, scope: `${row.original.kind}:${row.original.id}` }),
+      // EntityLink (redesign-plan.md section 3.5, replacing ScopeLink):
+      // this column only ever renders 'user' kind entries in practice —
+      // UsageTable.vue's own doc comment ("users, or a group's member
+      // users") — so it links straight to Consumers?user={id}, opening
+      // that row's own UserDetail, rather than a Charts scope jump.
+      cell: ({ row }) => h(EntityLink, { class: 'font-medium', label: row.original.id, kind: 'user', id: row.original.id }),
     },
     {
       id: 'secondary',
@@ -189,18 +236,21 @@ export function usageColumns(
       accessorFn: secondaryValue,
       // 'alphanumeric' (not the default auto-detected sortingFn): this
       // column's value is a plain string everywhere EXCEPT the Groups
-      // toolbar, where UsageView.vue passes memberCountOf — a numeric count
-      // rendered as a string. TanStack's getAutoSortingFn only inspects
-      // rows 11+ (flatRows.slice(10)) to decide numeric vs basic, so a
-      // groups table with 10 or fewer rows silently fell back to `basic`
-      // (plain a > b string comparison), sorting "10" before "9".
-      // 'alphanumeric' handles both cases correctly regardless of row
+      // toolbar, where ConsumerDirectory.vue passes memberCountOf — a
+      // numeric count rendered as a string. TanStack's getAutoSortingFn
+      // only inspects rows 11+ (flatRows.slice(10)) to decide numeric vs
+      // basic, so a groups table with 10 or fewer rows silently fell back
+      // to `basic` (plain a > b string comparison), sorting "10" before
+      // "9". 'alphanumeric' handles both cases correctly regardless of row
       // count: numeric substrings compare numerically, and it degrades
       // gracefully for the plain-text group-name case (secondaryValue on
       // the Users table).
       sortingFn: 'alphanumeric',
       cell: ({ row }) => h('span', { class: 'text-muted-foreground' }, secondaryValue(row.original)),
     },
+  ]
+  if (sourceValue) columns.push(sourceColumn(sourceValue))
+  columns.push(
     {
       id: 'limits',
       header: 'Limits',
@@ -217,5 +267,7 @@ export function usageColumns(
     numericColumn('costDay', 'cost/day', (e) => e.costPerDayMicroUsd, formatCost, false, 'costDay'),
     numericColumn('costMonth', 'cost/month', (e) => e.costPerMonthMicroUsd, formatCost, false, 'costMonth'),
     costMonthProjColumn(elapsedFraction),
-  ]
+    lastSeenColumn(now),
+  )
+  return columns
 }
diff --git a/webui/src/lib/usage-csv.spec.ts b/webui/src/lib/usage-csv.spec.ts
index 4a282d1..0ed90c3 100644
--- a/webui/src/lib/usage-csv.spec.ts
+++ b/webui/src/lib/usage-csv.spec.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 
-import { modelDetailCsv, modelRankingCsv, usageCsv } from './usage-csv'
-import type { AdminUsageEntryView, AdminUsageModelEntry } from '@/types/api'
+import { usageCsv } from './usage-csv'
+import type { AdminUsageEntryView } from '@/types/api'
 
 function testEntry(overrides: Partial<AdminUsageEntryView> = {}): AdminUsageEntryView {
   return {
@@ -28,7 +28,7 @@ const NOW = new Date(Date.UTC(2026, 3, 16, 0, 0, 0))
 
 describe('usageCsv', () => {
   const HEADER =
-    'Name,Group,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)"'
+    'Name,Group,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)'
 
   it('renders the Users header row with "Group" as the secondary column', () => {
     const csv = usageCsv([], 'users', () => '', NOW)
@@ -43,21 +43,26 @@ describe('usageCsv', () => {
   // P6 review fix: every numeric cell is now a PLAIN machine-readable
   // number — no thousands separators (formatExactInt) and no "$" prefix
   // (formatCost) — and the trailing cost/month (proj.) column is present.
-  it('renders one data row per entry, as plain numbers (no locale grouping, no currency symbol), including the projected month-end cost', () => {
-    const entries = [testEntry({ id: 'alice' }), testEntry({ id: 'bob' })]
+  it('renders one data row per entry, as plain numbers (no locale grouping, no currency symbol), including the projected month-end cost and last-seen unix seconds', () => {
+    const entries = [testEntry({ id: 'alice', lastSeen: 1_700_000_000 }), testEntry({ id: 'bob' })]
     const csv = usageCsv(entries, 'users', (e) => `group-of-${e.id}`, NOW)
     const lines = csv.split('\r\n')
     // costPerDayMicroUsd 1_234_500 -> 1.234500 USD; costPerMonthMicroUsd
     // 12_345_000 -> 12.345000 USD; projected = 12_345_000 / 0.5 = 24_690_000
-    // micro-USD -> 24.690000 USD.
-    expect(lines[1]).toBe('alice,group-of-alice,none,1,2,7,3,4,5,6,1.234500,12.345000,24.690000')
-    expect(lines[2]).toBe('bob,group-of-bob,none,1,2,7,3,4,5,6,1.234500,12.345000,24.690000')
+    // micro-USD -> 24.690000 USD. bob has no lastSeen -> 0.
+    expect(lines[1]).toBe('alice,group-of-alice,none,1,2,7,3,4,5,6,1.234500,12.345000,24.690000,1700000000')
+    expect(lines[2]).toBe('bob,group-of-bob,none,1,2,7,3,4,5,6,1.234500,12.345000,24.690000,0')
   })
 
   it('renders "not enough data yet" for the proj. column when too little of the month has elapsed', () => {
     const earlyInMonth = new Date(Date.UTC(2026, 3, 1, 0, 5, 0))
     const csv = usageCsv([testEntry()], 'users', () => 'g', earlyInMonth)
-    expect(csv.split('\r\n')[1]).toBe('alice,g,none,1,2,7,3,4,5,6,1.234500,12.345000,not enough data yet')
+    expect(csv.split('\r\n')[1]).toBe('alice,g,none,1,2,7,3,4,5,6,1.234500,12.345000,not enough data yet,0')
+  })
+
+  it('never masks last-seen as "?" for a storeDown entry — it is its own counter family, independent of the counters storeDown guards', () => {
+    const csv = usageCsv([testEntry({ storeDown: true, lastSeen: 1_700_000_000 })], 'users', () => 'g', NOW)
+    expect(csv.split('\r\n')[1]).toBe('alice,g,none,?,?,?,?,?,?,?,?,?,?,1700000000')
   })
 
   it('formats Limits via formatLimits, matching the on-screen table', () => {
@@ -68,7 +73,7 @@ describe('usageCsv', () => {
   it('masks every counter as "?" for a storeDown entry, never a stale number', () => {
     const csv = usageCsv([testEntry({ storeDown: true })], 'users', () => 'g', NOW)
     const dataLine = csv.split('\r\n')[1]
-    expect(dataLine).toBe('alice,g,none,?,?,?,?,?,?,?,?,?,?')
+    expect(dataLine).toBe('alice,g,none,?,?,?,?,?,?,?,?,?,?,0')
   })
 
   it('quotes a field that needs it (e.g. a secondaryValue containing a comma)', () => {
@@ -81,77 +86,10 @@ describe('usageCsv', () => {
     // exact projected value depends on the real clock, covered precisely
     // by the explicit-`now` tests above.
     const csv = usageCsv([testEntry()], 'users', () => 'g')
-    expect(csv.split('\r\n')[1].split(',')).toHaveLength(13)
+    expect(csv.split('\r\n')[1].split(',')).toHaveLength(14)
   })
 })
 
-describe('modelRankingCsv', () => {
-  const models: AdminUsageModelEntry[] = [
-    { id: 'openai/gpt-4', value: 100 },
-    { id: 'anthropic/claude', value: 50 },
-  ]
-
-  it('renders a header naming the ranked metric, window, and span (quoted — the label itself contains a comma)', () => {
-    const csv = modelRankingCsv(models, 'Cost', '24h', 24)
-    expect(csv.split('\r\n')[0]).toBe('Model,"Cost (24h, span 24)"')
-  })
-
-  it('renders one row per model with its raw value when isCostMetric is omitted/false', () => {
-    const csv = modelRankingCsv(models, 'Requests', '30d', 30)
-    const lines = csv.split('\r\n')
-    expect(lines[1]).toBe('openai/gpt-4,100')
-    expect(lines[2]).toBe('anthropic/claude,50')
-  })
-
-  it('renders just the header for an empty ranking', () => {
-    expect(modelRankingCsv([], 'Cost', '24h', 24)).toBe('Model,"Cost (24h, span 24)"\r\n')
-  })
-
-  // P6 review fix: a cost-metric ranking's `value` is raw micro-USD with no
-  // unit stated anywhere — isCostMetric:true states the unit in the header
-  // and converts each value to a plain decimal USD number.
-  it('states the USD unit in the header and converts raw micro-USD values to plain decimal USD when isCostMetric is true', () => {
-    const costModels: AdminUsageModelEntry[] = [{ id: 'openai/gpt-4', value: 1_234_500 }]
-    const csv = modelRankingCsv(costModels, 'Cost', '24h', 24, true)
-    const lines = csv.split('\r\n')
-    expect(lines[0]).toBe('Model,"Cost (USD) (24h, span 24)"')
-    expect(lines[1]).toBe('openai/gpt-4,1.234500')
-  })
-})
-
-// free-models-plan.md: the Models tab's CSV export now includes every
-// detail=1 figure per row (Requests/Tokens in/Tokens out/Cost), plus a
-// separate Free flag column — not just the single ranked metric
-// modelRankingCsv above exports.
-describe('modelDetailCsv', () => {
-  it('renders a header naming every detail column, with window/span folded into Requests only', () => {
-    const csv = modelDetailCsv([], '24h', 24)
-    expect(csv).toBe('Model,"Requests (24h, span 24)",Tokens in,Tokens out,Cost (USD),Free\r\n')
-  })
-
-  it('renders one row per model with every detail figure as a plain machine-readable number', () => {
-    const models: AdminUsageModelEntry[] = [
-      { id: 'openai/gpt-4', value: 100, requests: 10, tokensIn: 1000, tokensOut: 2000, costMicroUsd: 1_234_500, free: false },
-    ]
-    const csv = modelDetailCsv(models, '24h', 24)
-    expect(csv.split('\r\n')[1]).toBe('openai/gpt-4,10,1000,2000,1.234500,false')
-  })
-
-  it('exports the real 0 cost (never the string "free") in the Cost column, with Free as its own "true" column', () => {
-    const models: AdminUsageModelEntry[] = [
-      { id: 'uni/free-model', value: 0, requests: 5, tokensIn: 50, tokensOut: 75, costMicroUsd: 0, free: true },
-    ]
-    const csv = modelDetailCsv(models, '24h', 24)
-    expect(csv.split('\r\n')[1]).toBe('uni/free-model,5,50,75,0.000000,true')
-  })
-
-  it('falls back every missing detail field to 0/false when detail was not actually requested (defensive)', () => {
-    const models: AdminUsageModelEntry[] = [{ id: 'openai/gpt-4', value: 100 }]
-    const csv = modelDetailCsv(models, '24h', 24)
-    expect(csv.split('\r\n')[1]).toBe('openai/gpt-4,0,0,0,0.000000,false')
-  })
-
-  it('renders just the header for an empty ranking', () => {
-    expect(modelDetailCsv([], '30d', 30)).toBe('Model,"Requests (30d, span 30)",Tokens in,Tokens out,Cost (USD),Free\r\n')
-  })
-})
+// modelRankingCsv/modelDetailCsv (and their own describe blocks here)
+// were removed with the functions themselves (P3 item 25, dead code) —
+// see usage-csv.ts's own doc comment.
diff --git a/webui/src/lib/usage-csv.ts b/webui/src/lib/usage-csv.ts
index ef334c8..02fc459 100644
--- a/webui/src/lib/usage-csv.ts
+++ b/webui/src/lib/usage-csv.ts
@@ -1,9 +1,5 @@
-// F8 (CSV export): builds the actual CSV text for the Usage tab's Users/
-// Groups exports (usageCsv) and the Models tab's ranking export. The
-// Models tab's own ChartsView.vue calls modelDetailCsv (free-models-
-// plan.md's per-row requests/tokens/cost/free breakdown) — modelRankingCsv
-// stays exported and tested as a general single-metric exporter, kept for
-// any future caller that only wants the ranked value column. Every export
+// F8 (CSV export): builds the actual CSV text for ConsumerDirectory.vue's
+// Users/Groups exports (usageCsv, CsvExportButton.vue). Every export
 // funnels through lib/csv.ts's toCsv, so quoting/line-ending (and CSV-
 // formula-injection neutralisation) behavior is defined in exactly one
 // place (that module's own doc comment).
@@ -11,9 +7,9 @@ import { toCsv } from '@/lib/csv'
 import { monthProgress, projectMonthEnd } from '@/lib/forecast'
 import { formatLimits } from '@/lib/format'
 import { MICROS_PER_USD } from '@/lib/usage-bars'
-import type { AdminUsageEntryView, AdminUsageModelEntry } from '@/types/api'
+import type { AdminUsageEntryView } from '@/types/api'
 
-/** UsageCsvKind picks the second column's label — "Group" for a Users export (each row's own group membership), "Members" for a Groups export (each row's member count) — mirroring usage-columns.ts's own usageColumns(idLabel, secondaryColumnLabel, ...) call sites in UsageTable.vue/UsageView.vue exactly. */
+/** UsageCsvKind picks the second column's label — "Group" for a Users export (each row's own group membership), "Members" for a Groups export (each row's member count) — mirroring usage-columns.ts's own usageColumns(idLabel, secondaryColumnLabel, ...) call sites in UsageTable.vue/ConsumerDirectory.vue exactly. */
 export type UsageCsvKind = 'users' | 'groups'
 
 const USAGE_CSV_SECONDARY_LABEL: Record<UsageCsvKind, string> = {
@@ -49,8 +45,9 @@ function csvCostUsd(micros: number): string {
  *
  * `secondaryValue` is the same per-row accessor usageColumns() itself
  * takes (groupNameOf for Users, memberCountOf for Groups, both
- * UsageView.vue-local) — this module has no opinion on what a group's
- * member count is, only how to render the column once given the value.
+ * ConsumerDirectory.vue-local) — this module has no opinion on what a
+ * group's member count is, only how to render the column once given the
+ * value.
  *
  * Every numeric cell is a PLAIN machine-readable number (csvCostUsd above
  * for the three cost columns, the raw integer — no formatExactInt
@@ -89,6 +86,7 @@ export function usageCsv(
     'cost/day (USD)',
     'cost/month (USD)',
     'cost/month (proj., USD)',
+    'last seen (unix seconds)',
   ]
   const rows = entries.map((entry) => {
     const masked = entry.storeDown
@@ -107,83 +105,20 @@ export function usageCsv(
       masked ? '?' : csvCostUsd(entry.costPerDayMicroUsd),
       masked ? '?' : csvCostUsd(entry.costPerMonthMicroUsd),
       masked ? '?' : projected === null ? 'not enough data yet' : csvCostUsd(projected),
+      // Never masked — lastSeen is its own SET-based counter family
+      // (redesign-plan.md section 1.2), independent of the INCRBY usage
+      // counters `storeDown` actually guards (see usage-columns.ts's
+      // lastSeenColumn's own doc comment). 0 means never seen, matching
+      // AdminUsageEntryView.lastSeen's own "0/omitted" convention.
+      entry.lastSeen ?? 0,
     ]
   })
   return toCsv(headers, rows)
 }
 
-/**
- * modelRankingCsv renders the Models tab's current ranking (WP-B2,
- * ChartsView.vue) as CSV text: one row per ranked model, `id` (the
- * canonical "provider/model" that served the traffic — AdminUsageModelEntry's
- * own doc comment, types/api.ts) and its `value` for the ranked metric.
- * `metricLabel`/`windowLabel`/`span` are the caller's own already-resolved
- * DISPLAY strings/number (e.g. MODEL_METRIC_LABEL[modelMetric],
- * WINDOW_LABEL[window], WINDOW_SPAN[window] — stores/history.ts, WP-B2),
- * not re-derived here: this module stays independent of WP-B2's store, and
- * the second header column names exactly what was ranked and over what
- * span, so the exported file is self-describing without a caller needing
- * to cross-reference the filename.
- *
- * `isCostMetric` (P6 review fix): the cost-metric ranking's `value` is raw
- * micro-USD — the on-screen chart/CSV both used to export it as-is, with
- * no unit stated anywhere in the header. The caller states whether the
- * CURRENTLY ranked metric is cost (`history.modelMetric === 'cost'`); when
- * true, the header gains an explicit " (USD)" unit suffix and every value
- * converts to a plain decimal USD number via the same csvCostUsd
- * convention usageCsv uses above. Every OTHER metric (requests, tokens in/
- * out) is already a plain raw integer with no unit ambiguity, so this
- * defaults to false and changes nothing for them.
- */
-export function modelRankingCsv(
-  models: AdminUsageModelEntry[],
-  metricLabel: string,
-  windowLabel: string,
-  span: number,
-  isCostMetric = false,
-): string {
-  const unit = isCostMetric ? ' (USD)' : ''
-  const headers = ['Model', `${metricLabel}${unit} (${windowLabel}, span ${span})`]
-  const rows = models.map((m) => [m.id, isCostMetric ? csvCostUsd(m.value) : m.value])
-  return toCsv(headers, rows)
-}
-
-/**
- * modelDetailCsv renders the Models tab's current ranking with every
- * `detail=1` figure per row (free-models-plan.md, UI section), not just
- * the single ranked metric modelRankingCsv above exports: Model, Requests,
- * Tokens in, Tokens out, Cost (USD), Free. stores/history.ts's
- * fetchModelRanking always requests detail=1 now, so every entry passed
- * here is expected to carry every detail field; `?? 0` covers the same
- * theoretical-undefined case lib/model-table-columns.ts's
- * numericDetailColumn already guards against, never a silent mis-export of
- * a genuine 0.
- *
- * Cost is the SAME plain, machine-readable decimal-USD convention
- * usageCsv/modelRankingCsv above already use (csvCostUsd) — a free model's
- * own costMicroUsd is a real 0, exported as "0.000000" like any other zero
- * cost, never overwritten by the text "free"; `free` is its own separate
- * boolean column instead ("true"/"false"), so a spreadsheet reader can
- * filter/sum the numeric Cost column without a stray non-numeric value
- * breaking that — mirrors the on-screen table's own "the badge only
- * changes what's displayed, never the sort key" rule
- * (model-table-columns.ts's costColumn doc comment).
- *
- * `windowLabel`/`span` are the caller's own already-resolved DISPLAY
- * strings/number (mirroring modelRankingCsv's identical parameters),
- * folded into the Requests column's header only — every detail figure
- * shares the identical span, so naming it once keeps the file
- * self-describing without repeating it four times.
- */
-export function modelDetailCsv(models: AdminUsageModelEntry[], windowLabel: string, span: number): string {
-  const headers = ['Model', `Requests (${windowLabel}, span ${span})`, 'Tokens in', 'Tokens out', 'Cost (USD)', 'Free']
-  const rows = models.map((m) => [
-    m.id,
-    m.requests ?? 0,
-    m.tokensIn ?? 0,
-    m.tokensOut ?? 0,
-    csvCostUsd(m.costMicroUsd ?? 0),
-    m.free ? 'true' : 'false',
-  ])
-  return toCsv(headers, rows)
-}
+// modelRankingCsv/modelDetailCsv were removed (P3 item 25, dead code):
+// both were the pre-redesign Models tab's own CSV export (ChartsView.vue,
+// stores/history.ts), and neither has a caller anywhere in the
+// redesigned shell — grep confirms only this file and its own now-deleted
+// spec section ever referenced them. The redesigned Models page
+// (ModelCatalogTable.vue) has no CSV export of its own.
diff --git a/webui/src/lib/usage-search.ts b/webui/src/lib/usage-search.ts
index c1c0b4d..a5aee2b 100644
--- a/webui/src/lib/usage-search.ts
+++ b/webui/src/lib/usage-search.ts
@@ -2,11 +2,14 @@ import type { AdminUsageEntryView } from '@/types/api'
 
 /**
  * Shared matching helpers for the "Filter users or groups" search
- * UsageView.vue and ChartsView.vue both offer (operator directive:
- * identical semantics, ONE implementation — no second copy of this logic).
+ * ConsumerDirectory.vue offers (operator directive: identical semantics,
+ * ONE implementation — no second copy of this logic; extracted here
+ * rather than left inline specifically because the pre-redesign Usage
+ * AND Charts tabs both needed the identical matching rules before this
+ * module existed).
  *
  * Every `query` parameter here is expected to already be trimmed and
- * lowercased by the caller, mirroring ProvidersView.vue's own
+ * lowercased by the caller, mirroring ProviderHealthPanel.vue's own
  * normalizedQuery convention (modelMatches/aliasMatches there never
  * re-normalize either) — these functions stay pure string/array
  * operations, with the caller owning the single source of truth for "is a
@@ -32,11 +35,11 @@ export function groupNameMatches(group: Pick<AdminUsageEntryView, 'id'>, query:
  * `groupName` alone: a multi-group user would otherwise silently drop out
  * of every group but their first. This is a plain client-side join against
  * the already-polled GET /admin/api/usage response, no extra fetch.
- * UsageView.vue calls this directly (replacing its own former local
- * membersOf helper); matchingMembersOfGroup below builds on it too, which
- * is how ChartsView.vue's groupMatches call ends up depending on this same
- * join — indirectly, through matchingMembersOfGroup — without calling
- * membersOfGroup itself.
+ * ConsumerDirectory.vue calls this directly (replacing the pre-redesign
+ * Usage tab's own former local membersOf helper); matchingMembersOfGroup
+ * below builds on it too, which is how ConsumerDirectory.vue's own
+ * groupMatches call ends up depending on this same join — indirectly,
+ * through matchingMembersOfGroup — without calling membersOfGroup itself.
  */
 export function membersOfGroup(group: Pick<AdminUsageEntryView, 'id'>, users: AdminUsageEntryView[]): AdminUsageEntryView[] {
   return users.filter((u) => (u.groups ?? [u.groupName]).includes(group.id))
@@ -57,7 +60,8 @@ export function matchingMembersOfGroup(
  * need to distinguish WHICH of the two reasons a group matched — to decide
  * whether to show all of its members or only the matching ones — use
  * groupNameMatches and matchingMembersOfGroup directly instead (see
- * UsageView.vue's own doc comment for that distinction).
+ * ConsumerDirectory.vue's own memberOnlyMatchIds doc comment for that
+ * distinction).
  */
 export function groupMatches(group: Pick<AdminUsageEntryView, 'id'>, users: AdminUsageEntryView[], query: string): boolean {
   return groupNameMatches(group, query) || matchingMembersOfGroup(group, users, query).length > 0
diff --git a/webui/src/lib/yaml-emit.spec.ts b/webui/src/lib/yaml-emit.spec.ts
new file mode 100644
index 0000000..7ec0658
--- /dev/null
+++ b/webui/src/lib/yaml-emit.spec.ts
@@ -0,0 +1,287 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  emitConfigSnippet,
+  emitYamlDocument,
+  emitYamlFlowList,
+  emitYamlFlowMap,
+  emitYamlKey,
+  emitYamlScalar,
+  toYamlValue,
+  yamlKeyNeedsQuoting,
+} from './yaml-emit'
+
+describe('yamlKeyNeedsQuoting / emitYamlKey', () => {
+  it.each([
+    ['gx10/current', true],
+    ['a:b', true],
+    ['plain', false],
+    ['eng-team', false],
+    ['friends_2', false],
+  ])('key %s needs quoting: %s', (key, expected) => {
+    expect(yamlKeyNeedsQuoting(key)).toBe(expected)
+  })
+
+  it('quotes a key containing "/" — modelMeta\'s own routable-id convention', () => {
+    expect(emitYamlKey('gx10/current')).toBe('"gx10/current"')
+  })
+
+  it('leaves a plain key unquoted', () => {
+    expect(emitYamlKey('friends')).toBe('friends')
+  })
+})
+
+/**
+ * P2 item 11 — a table of tricky scalars a naive quoting rule gets wrong,
+ * checked against BOTH emitYamlKey and emitYamlScalar (one shared rule,
+ * needsQuoting — the fix instruction's own "apply the same rule to
+ * keys"). Every "needs quoting: true" row here was independently
+ * sanity-checked with PyYAML's own safe_load round trip during the
+ * verify pass this fixes (no network access needed to reason about it:
+ * PyYAML, like every YAML 1.1-lineage parser, resolves a flow-indicator
+ * character anywhere in a plain scalar, a leading special/digit
+ * character, a "key: value"-shaped substring, or a case-insensitive
+ * boolean/null spelling, the same way regardless of position — this
+ * table exercises each category at least once).
+ */
+describe('needsQuoting (P2 item 11): tricky inputs table', () => {
+  it.each([
+    // Flow indicators ANYWHERE, not just leading (auth.go:492 path.Match
+    // globs are legitimate config — `gpt-[45]*` used to break a flow
+    // list because only a LEADING `[`/`]` was quoted).
+    ['gpt-[45]*', 'glob bracket mid-string', true],
+    ['a]b', 'closing bracket mid-string', true],
+    ['a}b', 'closing brace mid-string', true],
+    ['a,b', 'comma mid-string', true],
+    ['*m', 'leading flow/alias indicator', true],
+    ['{m}', 'leading brace', true],
+    ['- x', 'leading "- " (block sequence indicator)', true],
+    // Leading/trailing space, and a comment start that used to be
+    // truncated mid-scalar rather than quoted away entirely.
+    [' leading-space', 'leading space', true],
+    ['trailing-space ', 'trailing space', true],
+    ['x #y', 'space then "#" (comment start)', true],
+    // "key: value"-shaped substrings.
+    ['a: b', 'colon-space (nested-mapping shape)', true],
+    ['a:', 'trailing colon', true],
+    ['12:30', 'time-of-day shaped', true],
+    // YAML 1.1 type-changers: numbers, dates, booleans, null, "infinity".
+    ['0x10', 'hex-looking number', true],
+    ['1e3', 'exponent-looking number', true],
+    ['2026-01-01', 'date-shaped', true],
+    ['.inf', 'YAML 1.1 infinity literal', true],
+    ['~', 'YAML null shorthand', true],
+    ['on', 'YAML 1.1 boolean (lowercase)', true],
+    ['Off', 'YAML 1.1 boolean (mixed case)', true],
+    ['yes', 'YAML 1.1 boolean', true],
+    ['NO', 'YAML 1.1 boolean (uppercase)', true],
+    ['true', 'YAML 1.2 boolean', true],
+    ['null', 'YAML null literal', true],
+    ['y', 'YAML 1.1 single-letter boolean', true],
+    // Safe: this module's real values (group/provider names, canonical
+    // model ids) must stay unquoted for readability.
+    ['plain', 'ordinary bare word', false],
+    ['gx10-embed', 'hyphenated name', false],
+    ['friends_2', 'underscored name', false],
+    ['eng.team', 'dotted name', false],
+  ])('%s (%s) needs quoting: %s', (input, _label, expected) => {
+    expect(yamlKeyNeedsQuoting(input)).toBe(expected)
+    const scalarRendered = emitYamlScalar(input)
+    expect(scalarRendered === `"${input}"` || scalarRendered === input).toBe(true)
+    expect(scalarRendered.startsWith('"')).toBe(expected)
+  })
+
+  it('a group named "on"/"yes"/"true"/"null" (all allowed by GrantForm/LimitsForm\'s NAME_PATTERN) renders as a quoted, still-a-string YAML key', () => {
+    for (const name of ['on', 'yes', 'true', 'null']) {
+      expect(emitYamlKey(name)).toBe(JSON.stringify(name))
+    }
+  })
+})
+
+describe('emitYamlScalar', () => {
+  it.each([
+    [null, 'null'],
+    [true, 'true'],
+    [false, 'false'],
+    [0, '0'],
+    [5, '5'],
+    [0.5, '0.5'],
+    ['anthropic', 'anthropic'],
+  ])('renders %p as %s', (value, expected) => {
+    expect(emitYamlScalar(value as never)).toBe(expected)
+  })
+
+  it('quotes an empty string', () => {
+    expect(emitYamlScalar('')).toBe('""')
+  })
+
+  it('quotes a string that would otherwise parse as a boolean literal', () => {
+    expect(emitYamlScalar('true')).toBe('"true"')
+  })
+
+  it('quotes a string that would otherwise parse as a number', () => {
+    expect(emitYamlScalar('123')).toBe('"123"')
+  })
+
+  it('quotes a string containing ": " (would misparse as a nested mapping)', () => {
+    expect(emitYamlScalar('a: b')).toBe('"a: b"')
+  })
+
+  // N6 (verify-redesign-final.md): JSON.stringify leaves these four code
+  // points as literal bytes/code units — valid JSON, but a YAML 1.1
+  // scanner (PyYAML, go-yaml v3) treats U+0085/U+2028/U+2029 as line
+  // breaks (folded into whitespace, or a scanner error on a key) and
+  // rejects U+007F outright as non-printable. Each must come back
+  // escaped, never as a raw character.
+  it.each([
+    ['NEL (U+0085)', '\u0085', '\\x85'],
+    ['a C1 control (U+009F)', '\u009f', '\\x9f'],
+    ['LINE SEPARATOR (U+2028)', '\u2028', '\\u2028'],
+    ['PARAGRAPH SEPARATOR (U+2029)', '\u2029', '\\u2029'],
+    ['DEL (U+007F)', '\u007f', '\\x7f'],
+  ])('escapes %s inside a quoted scalar', (_label, char, escape) => {
+    const rendered = emitYamlScalar(`a${char}b`)
+    expect(rendered).toBe(`"a${escape}b"`)
+    expect(rendered).not.toContain(char)
+  })
+
+  it('escapes the same control characters inside a quoted key', () => {
+    const rendered = emitYamlKey('a\u0085b')
+    expect(rendered).toBe('"a\\x85b"')
+    expect(rendered).not.toContain('\u0085')
+  })
+
+  it('round-trips a string that is ONLY the unsafe character, still quoted and escaped', () => {
+    expect(emitYamlScalar('\u2028')).toBe('"\\u2028"')
+  })
+})
+
+describe('emitYamlFlowList', () => {
+  it('renders an empty list as "[]" — the production file\'s own "allow everything" convention', () => {
+    expect(emitYamlFlowList([])).toBe('[]')
+  })
+
+  it('renders a short string list inline, matching middleware.yaml\'s alibaba/xiaomi provider entries', () => {
+    expect(emitYamlFlowList(['qwen3.8-max', 'qwen3.8-flash'])).toBe('[qwen3.8-max, qwen3.8-flash]')
+  })
+
+  it('renders numbers unquoted inside a flow list', () => {
+    expect(emitYamlFlowList([1, 2, 3])).toBe('[1, 2, 3]')
+  })
+})
+
+describe('emitYamlFlowMap', () => {
+  it('renders an empty map as "{}"', () => {
+    expect(emitYamlFlowMap([])).toBe('{}')
+  })
+
+  // Golden strings: middleware.yaml's own modelMeta entries, verbatim.
+  it('matches "{ free: true }" (middleware.yaml modelMeta, e.g. gx10/current)', () => {
+    expect(emitYamlFlowMap([['free', true]])).toBe('{ free: true }')
+  })
+
+  it('matches "{ contextTokens: 16384, free: true }" (middleware.yaml, gx10-embed model)', () => {
+    expect(
+      emitYamlFlowMap([
+        ['contextTokens', 16384],
+        ['free', true],
+      ]),
+    ).toBe('{ contextTokens: 16384, free: true }')
+  })
+})
+
+describe('emitYamlDocument', () => {
+  it('renders nested maps at 2-space-per-level indent, matching middleware.yaml exactly', () => {
+    const doc = emitYamlDocument({
+      spec: {
+        plugin: {
+          llmgateway: {
+            admin: { enabled: true },
+          },
+        },
+      },
+    })
+    expect(doc).toBe(['spec:', '  plugin:', '    llmgateway:', '      admin:', '        enabled: true'].join('\n'))
+  })
+
+  it('drops undefined keys entirely (omitempty parity), never emitting them as null', () => {
+    const doc = emitYamlDocument({ a: 1, b: undefined, c: 'x' })
+    expect(doc).toBe('a: 1\nc: x')
+  })
+
+  it('renders an explicitly-empty nested map as "key: {}", not omitted', () => {
+    const doc = emitYamlDocument({ cache: {} })
+    expect(doc).toBe('cache: {}')
+  })
+
+  it('renders an empty string-array field as "[]" inline, matching middleware.yaml\'s groups.home block (every field explicit and empty, not a bare "{}")', () => {
+    const doc = emitYamlDocument({
+      home: { providers: [], models: [], mcpServers: [], agents: [] },
+    })
+    expect(doc).toBe(['home:', '  providers: []', '  models: []', '  mcpServers: []', '  agents: []'].join('\n'))
+  })
+
+  // Defensive-only path: this schema never actually produces an array of
+  // objects, but a generic render of an unforeseen server shape must not
+  // throw.
+  it('falls back to block "-" items with JSON.stringify per element for an array containing a non-primitive (defensive, never hit by this schema)', () => {
+    const doc = emitYamlDocument({ weird: [{ a: 1 }] })
+    expect(doc).toBe('weird:\n  - {"a":1}')
+  })
+})
+
+describe('emitConfigSnippet: matches middleware.yaml\'s own indent depth exactly', () => {
+  it('wraps a group\'s access-list body under spec.plugin.llmgateway.groups.<name> (middleware.yaml groups.home shape)', () => {
+    const snippet = emitConfigSnippet(['groups', 'home'], {
+      providers: [],
+      models: [],
+      mcpServers: [],
+      agents: [],
+    })
+    expect(snippet).toBe(
+      [
+        'spec:',
+        '  plugin:',
+        '    llmgateway:',
+        '      groups:',
+        '        home:',
+        '          providers: []',
+        '          models: []',
+        '          mcpServers: []',
+        '          agents: []',
+      ].join('\n'),
+    )
+  })
+
+  it('wraps a group\'s limits at one further nesting level', () => {
+    const snippet = emitConfigSnippet(['groups', 'friends'], { limits: { requestsPerDay: 1000 } })
+    expect(snippet).toBe(
+      ['spec:', '  plugin:', '    llmgateway:', '      groups:', '        friends:', '          limits:', '            requestsPerDay: 1000'].join(
+        '\n',
+      ),
+    )
+  })
+
+  it('wraps a top-level, non-nested section (e.g. admin) with no extra name level', () => {
+    const snippet = emitConfigSnippet(['admin'], { enabled: true })
+    expect(snippet).toBe(['spec:', '  plugin:', '    llmgateway:', '      admin:', '        enabled: true'].join('\n'))
+  })
+})
+
+describe('toYamlValue', () => {
+  it('passes primitives through unchanged', () => {
+    expect(toYamlValue('x')).toBe('x')
+    expect(toYamlValue(5)).toBe(5)
+    expect(toYamlValue(true)).toBe(true)
+    expect(toYamlValue(null)).toBe(null)
+  })
+
+  it('recurses through nested arrays and objects', () => {
+    expect(toYamlValue({ a: [1, { b: 'c' }] })).toEqual({ a: [1, { b: 'c' }] })
+  })
+
+  it('never throws on an unexpected type, falling back to String()', () => {
+    const weird = (() => 1) as unknown
+    expect(toYamlValue(weird)).toBe(String(weird))
+  })
+})
diff --git a/webui/src/lib/yaml-emit.ts b/webui/src/lib/yaml-emit.ts
new file mode 100644
index 0000000..c439bd7
--- /dev/null
+++ b/webui/src/lib/yaml-emit.ts
@@ -0,0 +1,260 @@
+// Config page (redesign-plan.md section 3.4): a deterministic, dependency-
+// free YAML emitter. Two jobs share it:
+//   1. ConfigTree.vue renders the FULL redacted config (GET /admin/api/
+//      config's arbitrary Record<string, unknown>) as read-only YAML —
+//      emitYamlDocument, via toYamlValue's defensive unknown->YamlValue cast.
+//   2. lib/snippets.ts builds small, targeted "paste this into middleware.
+//      yaml" fragments (emitConfigSnippet) for the ChangeHelper forms —
+//      GOLDEN-STRING tested against the real production file (home-cluster
+//      namespaces/traefik/base/llmgateway/middleware.yaml), never guessed.
+//
+// Kept intentionally narrow: this schema's own config never nests an array
+// of objects (every ProviderConfig/GroupConfig/LimitsConfig/RedisConfig/
+// RetryConfig/CacheConfig/AdminConfig field that is a list is a list of
+// strings — providers/models/mcpServers/agents/passthroughPaths), so this
+// module does not attempt general-purpose YAML (anchors, multiline scalars,
+// comments) — only what this one config shape, and its own redacted mirror,
+// ever produce.
+
+/** YamlPrimitive is one leaf value — a plain scalar, matching every non-container field this config's Go structs carry (strings, numbers, bools, or Go's untyped nil for an omitted pointer). */
+export type YamlPrimitive = string | number | boolean | null
+
+/** YamlValue is any value this emitter can render: a primitive, a list of primitives, or a nested map. `undefined` on a map's own value is the one non-YAML sentinel this module recognizes — it drops that key entirely (mirrors Go's `omitempty`), never emitted as `null`. */
+export type YamlValue = YamlPrimitive | YamlValue[] | { [key: string]: YamlValue | undefined }
+
+const INDENT_UNIT = '  '
+
+/**
+ * SAFE_UNQUOTED_PATTERN is the whitelist every plain (unquoted) YAML
+ * scalar this module emits — key OR value, block OR flow context — must
+ * satisfy: a leading letter or underscore, then any run of letters,
+ * digits, `.`, `_`, or `-`. This is deliberately far narrower than what
+ * YAML 1.2 actually permits unquoted (this module's own top-of-file doc
+ * comment: "only what this one config shape ... ever produces"), so every
+ * structurally significant character this schema's real values could
+ * ever contain — a space, `:`, `,`, `[`, `]`, `{`, `}`, `#`, a quote, a
+ * leading digit, or a leading special character — falls OUTSIDE it and
+ * gets quoted, unconditionally, in BOTH the two places this module
+ * renders a scalar: a block "key: value" line (renderMapLines) and a
+ * flow list/map element (emitYamlFlowList/emitYamlFlowMap) — the same
+ * needsQuoting call backs both emitYamlKey and emitYamlScalar below, so
+ * neither can drift from the other's rule (P2 item 11's own fix
+ * instruction: "apply the same rule to keys").
+ *
+ * `/` is deliberately NOT in the allowed charset either, even though it
+ * is not YAML-structurally significant on its own: this codebase's own
+ * pre-existing golden tests (yamlKeyNeedsQuoting('gx10/current') === true,
+ * checked against the real production file) already establish that a
+ * routable "provider/model" id is quoted by this GENERAL rule, not by a
+ * one-off special case — modelMetaSnippet's own "always quoted" note
+ * (P2 item 11: "Always quote modelMeta keys") is then true by
+ * CONSTRUCTION for every real model id (they all contain "/"), not a
+ * separate mechanism fighting this whitelist.
+ *
+ * P2 item 11 (PyYAML-checked): a flow-list glob like `gpt-[45]*`
+ * (path.Match globs are legitimate config, auth.go:492) previously broke
+ * parsing because `[`/`]` were only checked as the FIRST character, not
+ * anywhere in the string — the old scalar rule quoted a LEADING `[` but
+ * not one in the middle. A comma or `}`/`{` anywhere has the identical
+ * problem inside this module's own flow-style output. This whitelist
+ * quotes the whole string whenever ANY of those characters appear, at
+ * any position — always correct, since a flow-context character is
+ * unsafe everywhere in a flow scalar, and quoting it in a block context
+ * too costs nothing (`"literal"` is valid wherever `literal` was).
+ */
+const SAFE_UNQUOTED_PATTERN = /^[A-Za-z_][A-Za-z0-9._-]*$/
+
+/**
+ * RESERVED_WORDS is every bare word SAFE_UNQUOTED_PATTERN would otherwise
+ * let through unquoted (it is made entirely of letters, so the pattern's
+ * charset alone cannot exclude it) but that a YAML parser resolves to a
+ * non-string type instead of the literal string it looks like. This
+ * config is consumed as a Kubernetes CRD spec field (YAML -> JSON via the
+ * API machinery's own converter, which follows YAML 1.1-style scalar
+ * resolution — the same lineage go.yaml.in/yaml/v3's own decode defaults
+ * sit in), so the broader YAML 1.1 boolean/null set is included
+ * defensively (on/off, yes/no, not just YAML 1.2's own true/false/null),
+ * matched case-insensitively since YAML resolution itself is
+ * case-insensitive for these ("True", "ON", "Null" all resolve the same
+ * way a parser's plain-scalar resolver would).
+ */
+const RESERVED_WORDS = new Set(['true', 'false', 'yes', 'no', 'y', 'n', 'on', 'off', 'null', 'nil', 'nan', 'inf'])
+
+/**
+ * needsQuoting is the ONE predicate this module uses to decide whether a
+ * plain scalar is safe to emit unquoted — SAFE_UNQUOTED_PATTERN first (a
+ * fast, purely structural check that also independently catches every
+ * number-looking string this schema ever produces: `0x10`, `1e3`,
+ * `2026-01-01`, `12:30`, `.inf`, and a bare `~` all contain a character
+ * outside the whitelist, or start with a digit/`.`/`~` rather than a
+ * letter/underscore, so none of them need their own separate numeric
+ * check), then RESERVED_WORDS for the purely-alphabetic words the
+ * pattern alone cannot rule out.
+ */
+function needsQuoting(s: string): boolean {
+  if (!SAFE_UNQUOTED_PATTERN.test(s)) return true
+  return RESERVED_WORDS.has(s.toLowerCase())
+}
+
+/** yamlKeyNeedsQuoting reports whether a mapping key needs JSON-style double-quoting to round-trip as the literal string it is — the same needsQuoting rule emitYamlScalar applies to values below (P2 item 11: keys and values share one rule, not two independently-drifting ones). A modelMeta/pricing "provider/model" key always trips this (contains "/"), matching the production file's own convention of quoting every routable id. */
+export function yamlKeyNeedsQuoting(key: string): boolean {
+  return needsQuoting(key)
+}
+
+/**
+ * YAML_UNSAFE_CONTROL_PATTERN matches every character JSON.stringify's own
+ * quoting leaves as a literal byte/code unit but that a YAML 1.1 scanner
+ * (this config's consumer: Kubernetes' CRD machinery, go.yaml.in/yaml/v3 —
+ * needsQuoting's own doc comment) does not accept literally inside a
+ * double-quoted scalar (N6, verify-redesign-final.md — checked against
+ * PyYAML and go-yaml v3 across 346 round-trip cases):
+ *   - U+0085 (NEL) and the rest of the C1 control range U+0080-U+009F —
+ *     NEL is itself a YAML 1.1 line-break character, folded into a space
+ *     or rejected outright by a scanner mid-key; the surrounding C1 range
+ *     is non-printable by the same spec.
+ *   - U+2028 (LINE SEPARATOR) / U+2029 (PARAGRAPH SEPARATOR) — YAML's other
+ *     two line-break characters.
+ *   - U+007F (DEL) — non-printable, rejected outright by PyYAML.
+ * JSON already escapes every C0 control (U+0000-U+001F) and the two
+ * structural characters ('"', '\\'), so this only needs to add the range
+ * JSON's own grammar has no reason to touch.
+ */
+const YAML_UNSAFE_CONTROL_PATTERN = new RegExp(
+  '[\\u007f\\u0080-\\u009f' + String.fromCharCode(0x2028) + String.fromCharCode(0x2029) + ']',
+  'g',
+)
+
+/**
+ * escapeYamlUnsafeControls post-processes a JSON.stringify'd, already-
+ * quoted string, replacing every YAML_UNSAFE_CONTROL_PATTERN character
+ * with a YAML double-quoted escape a scanner accepts literally: `\xHH`
+ * (YAML's 2-hex-digit, 8-bit escape) for a single-byte code point
+ * (U+007F, U+0080-U+009F), `\uHHHH` (4-hex-digit, 16-bit escape) for
+ * U+2028/U+2029. Safe to run over the whole quoted string, including its
+ * surrounding quotes and any escape sequences JSON.stringify already
+ * produced: none of those ever contain a raw byte in this pattern's
+ * range (JSON's own escapes are all plain ASCII), so this only ever
+ * touches a literal occurrence of one of the target characters.
+ */
+function escapeYamlUnsafeControls(quoted: string): string {
+  return quoted.replace(YAML_UNSAFE_CONTROL_PATTERN, (ch) => {
+    const code = ch.codePointAt(0) as number
+    return code <= 0xff ? `\\x${code.toString(16).padStart(2, '0')}` : `\\u${code.toString(16).padStart(4, '0')}`
+  })
+}
+
+/** emitYamlKey renders one mapping key — quoted (JSON-style, valid YAML double-quoting) only when yamlKeyNeedsQuoting says so, plain otherwise. */
+export function emitYamlKey(key: string): string {
+  return yamlKeyNeedsQuoting(key) ? escapeYamlUnsafeControls(JSON.stringify(key)) : key
+}
+
+/** emitYamlScalar renders one leaf value in "key: <here>" position OR a flow list/map element — quoted (JSON-style) whenever needsQuoting says the plain form is unsafe, plain otherwise. Booleans/numbers/null render via their own JS literal, never through the string quoting path (a real `true`/`false`/`null`/number is safe unquoted by construction — only a STRING value can accidentally spell one of those). */
+export function emitYamlScalar(value: YamlPrimitive): string {
+  if (value === null) return 'null'
+  if (typeof value === 'boolean' || typeof value === 'number') return String(value)
+  return needsQuoting(value) ? escapeYamlUnsafeControls(JSON.stringify(value)) : value
+}
+
+/** emitYamlFlowList renders a primitive list as one flow-style line — "[]" empty, "[a, b, c]" otherwise — matching the production file's own short-list convention (middleware.yaml: `providers: []`, `models: ["qwen3.8-max", "qwen3.8-flash"]`). */
+export function emitYamlFlowList(values: YamlPrimitive[]): string {
+  if (values.length === 0) return '[]'
+  return `[${values.map((v) => emitYamlScalar(v)).join(', ')}]`
+}
+
+/** emitYamlFlowMap renders a primitive-valued map as one flow-style line — "{}" empty, "{ k: v, k2: v2 }" otherwise (note the padding spaces inside the braces) — matching modelMeta's own production convention (`{ free: true }`, `{ contextTokens: 16384, free: true }`). */
+export function emitYamlFlowMap(entries: [string, YamlPrimitive][]): string {
+  if (entries.length === 0) return '{}'
+  return `{ ${entries.map(([k, v]) => `${emitYamlKey(k)}: ${emitYamlScalar(v)}`).join(', ')} }`
+}
+
+function isPlainObject(value: YamlValue): value is { [key: string]: YamlValue | undefined } {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function isPrimitive(value: YamlValue): value is YamlPrimitive {
+  return value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'
+}
+
+/**
+ * renderMapLines recursively renders a map's own entries as already-
+ * indented lines, at INDENT_UNIT * depth spaces. A nested map with at
+ * least one (non-undefined) key opens on its own "key:" line and recurses
+ * one level deeper; an empty nested map renders inline as "key: {}"; a
+ * primitive-only array renders inline as one flow list. A defensive
+ * fallback (block "- " items, JSON.stringify per item) covers an array
+ * containing anything else — this schema never produces one, but a
+ * generic render of the server's redacted config must never throw on a
+ * shape this module did not anticipate.
+ */
+function renderMapLines(map: { [key: string]: YamlValue | undefined }, depth: number): string[] {
+  const indent = INDENT_UNIT.repeat(depth)
+  const lines: string[] = []
+  for (const [key, value] of Object.entries(map)) {
+    if (value === undefined) continue
+    const keyPrefix = `${indent}${emitYamlKey(key)}:`
+    if (isPrimitive(value)) {
+      lines.push(`${keyPrefix} ${emitYamlScalar(value)}`)
+    } else if (Array.isArray(value)) {
+      if (value.every(isPrimitive)) {
+        lines.push(`${keyPrefix} ${emitYamlFlowList(value as YamlPrimitive[])}`)
+      } else {
+        lines.push(keyPrefix)
+        for (const item of value) {
+          lines.push(`${indent}${INDENT_UNIT}- ${isPrimitive(item) ? emitYamlScalar(item) : JSON.stringify(item)}`)
+        }
+      }
+    } else if (isPlainObject(value)) {
+      const nestedKeys = Object.keys(value).filter((k) => value[k] !== undefined)
+      if (nestedKeys.length === 0) {
+        lines.push(`${keyPrefix} {}`)
+      } else {
+        lines.push(keyPrefix)
+        lines.push(...renderMapLines(value, depth + 1))
+      }
+    }
+  }
+  return lines
+}
+
+/** emitYamlDocument renders a top-level map as block-style YAML, starting at zero indent — ConfigTree.vue's own top-level call against the whole redacted config. */
+export function emitYamlDocument(value: { [key: string]: YamlValue | undefined }, depth = 0): string {
+  return renderMapLines(value, depth).join('\n')
+}
+
+/**
+ * emitConfigSnippet wraps `body` under the fixed "spec.plugin.llmgateway.
+ * <...sectionPath>" prefix every ChangeHelper YAML snippet shares
+ * (redesign-plan.md section 3.4: "emits YAML nested at spec.plugin.
+ * llmgateway.<section>") — e.g. sectionPath ["groups", "eng"] with body
+ * {limits: {...}} renders the group's limits block at exactly the depth
+ * the production file itself uses (spec:0 plugin:1 llmgateway:2 groups:3
+ * eng:4 limits:5 <fields>:6 — 0/2/4/6/8/10/12 spaces).
+ */
+export function emitConfigSnippet(sectionPath: string[], body: { [key: string]: YamlValue | undefined }): string {
+  let wrapped: { [key: string]: YamlValue | undefined } = body
+  const fullPath = ['spec', 'plugin', 'llmgateway', ...sectionPath]
+  for (let i = fullPath.length - 1; i >= 0; i--) {
+    wrapped = { [fullPath[i]]: wrapped }
+  }
+  return emitYamlDocument(wrapped)
+}
+
+/**
+ * toYamlValue defensively converts an arbitrary JSON value (GET /admin/api/
+ * config's already-redacted `config: Record<string, unknown>`) into a
+ * YamlValue this module can render — recursing through plain objects and
+ * arrays, passing primitives through unchanged, and falling back to
+ * `String(input)` for anything else (a function, a Symbol — never actually
+ * present in a JSON-decoded response, but this must not throw even if the
+ * server's shape someday surprises it).
+ */
+export function toYamlValue(input: unknown): YamlValue {
+  if (input === null || typeof input === 'string' || typeof input === 'number' || typeof input === 'boolean') return input
+  if (Array.isArray(input)) return input.map(toYamlValue)
+  if (typeof input === 'object') {
+    const out: { [key: string]: YamlValue } = {}
+    for (const [k, v] of Object.entries(input as Record<string, unknown>)) out[k] = toYamlValue(v)
+    return out
+  }
+  return String(input)
+}
diff --git a/webui/src/pages/ConfigPage.vue b/webui/src/pages/ConfigPage.vue
new file mode 100644
index 0000000..3dd927a
--- /dev/null
+++ b/webui/src/pages/ConfigPage.vue
@@ -0,0 +1,54 @@
+<script setup lang="ts">
+import { computed, onMounted } from 'vue'
+
+import ChangeHelper from '@/components/ChangeHelper.vue'
+import ConfigTree from '@/components/ConfigTree.vue'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { useConfigStore } from '@/stores/config'
+import { useConsumersStore } from '@/stores/consumers'
+import { useDashboardStore } from '@/stores/dashboard'
+
+/**
+ * ConfigPage (redesign-plan.md section 3.4) composes the redacted config
+ * tree (ConfigTree.vue, GET /admin/api/config, fetched on demand) above
+ * the change helper (ChangeHelper.vue's five snippet-building forms) —
+ * group/user names for those forms' target pickers come from the already-
+ * polled dashboard store (overview.groups) and the on-demand consumers
+ * store (users), so this page fetches config once and reuses whatever the
+ * other two stores already have rather than a third redundant call.
+ */
+const config = useConfigStore()
+const dashboard = useDashboardStore()
+const consumers = useConsumersStore()
+
+onMounted(() => {
+  void config.ensureConfig()
+  void consumers.ensureConsumers()
+})
+
+const groupNames = computed(() => (dashboard.overview?.groups ?? []).map((g) => g.name))
+const userNames = computed(() => (consumers.data?.users ?? []).map((u) => u.name))
+</script>
+
+<template>
+  <div class="flex flex-col gap-6">
+    <Card v-if="config.error">
+      <CardHeader>
+        <CardTitle>Config</CardTitle>
+        <CardDescription class="text-destructive">{{ config.error }}</CardDescription>
+      </CardHeader>
+    </Card>
+    <p v-else-if="config.loading && !config.data" class="text-sm text-muted-foreground">loading…</p>
+    <ConfigTree v-else-if="config.data" :config="config.data.config" :warnings="config.data.warnings" />
+
+    <Card>
+      <CardHeader>
+        <CardTitle>Change helper</CardTitle>
+        <CardDescription>Build a paste-ready snippet for middleware.yaml or users.json — nothing here writes to the running config.</CardDescription>
+      </CardHeader>
+      <CardContent>
+        <ChangeHelper :group-names="groupNames" :user-names="userNames" />
+      </CardContent>
+    </Card>
+  </div>
+</template>
diff --git a/webui/src/pages/ConsumersPage.vue b/webui/src/pages/ConsumersPage.vue
new file mode 100644
index 0000000..557dc03
--- /dev/null
+++ b/webui/src/pages/ConsumersPage.vue
@@ -0,0 +1,48 @@
+<script setup lang="ts">
+import { computed } from 'vue'
+
+import AccessMatrix from '@/components/AccessMatrix.vue'
+import ConsumerDirectory from '@/components/ConsumerDirectory.vue'
+import { Tabs, TabsList, TabsTrigger } from '@/components/ui/tabs'
+import UserDetail from '@/components/UserDetail.vue'
+import { useNavStore } from '@/stores/nav'
+
+/**
+ * ConsumersPage (redesign-plan.md section 3.4) is the Consumers page's own
+ * router: `user=<name>` (set by an EntityLink kind="user" click anywhere in
+ * the panel) opens UserDetail; otherwise `view=directory|matrix` (default
+ * directory) switches between ConsumerDirectory and AccessMatrix. Both
+ * params live in nav.params (stores/nav.ts's own opaque per-page record),
+ * never a private local ref — a bookmarked/shared #consumers?user=... link
+ * must restore the same view.
+ */
+const nav = useNavStore()
+
+const userParam = computed(() => nav.params.user)
+const view = computed<'directory' | 'matrix'>(() => (nav.params.view === 'matrix' ? 'matrix' : 'directory'))
+
+function setView(next: unknown): void {
+  if (next !== 'directory' && next !== 'matrix') return
+  const { user: _user, ...rest } = nav.params
+  nav.goTo('consumers', { ...rest, view: next })
+}
+
+function closeUserDetail(): void {
+  const { user: _user, ...rest } = nav.params
+  nav.goTo('consumers', rest)
+}
+</script>
+
+<template>
+  <UserDetail v-if="userParam" :user-id="userParam" @close="closeUserDetail" />
+  <div v-else class="flex flex-col gap-4">
+    <Tabs :model-value="view" @update:model-value="setView">
+      <TabsList>
+        <TabsTrigger value="directory">Directory</TabsTrigger>
+        <TabsTrigger value="matrix">Access matrix</TabsTrigger>
+      </TabsList>
+    </Tabs>
+    <ConsumerDirectory v-if="view === 'directory'" />
+    <AccessMatrix v-else />
+  </div>
+</template>
diff --git a/webui/src/pages/HomePage.vue b/webui/src/pages/HomePage.vue
new file mode 100644
index 0000000..4c8707d
--- /dev/null
+++ b/webui/src/pages/HomePage.vue
@@ -0,0 +1,241 @@
+<script setup lang="ts">
+import { computed, onMounted, onUnmounted, ref, watch } from 'vue'
+
+import KpiTile from '@/components/KpiTile.vue'
+import TopList from '@/components/TopList.vue'
+import type { TopListItem } from '@/components/TopList.vue'
+import { Badge } from '@/components/ui/badge'
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card'
+import { adminFetch } from '@/lib/api'
+import { EVENT_KIND_LABEL, eventKindVariant } from '@/lib/events-filter'
+import { formatCompactCount, formatCost, formatTimestamp } from '@/lib/format'
+import { headroom, monthProgress, projectMonthEnd } from '@/lib/forecast'
+import {
+  budgetRatio,
+  budgetTier,
+  errorRateTier,
+  fleetErrorRate,
+  openBreakerCount,
+  sumGroupBudgetMicros,
+} from '@/lib/kpi'
+import { createVisibilityPoller } from '@/lib/polling'
+import type { VisibilityPoller } from '@/lib/polling'
+import { totalsUrl } from '@/lib/range'
+import { useAuthStore } from '@/stores/auth'
+import { useDashboardStore } from '@/stores/dashboard'
+import { useEventsStore } from '@/stores/events'
+import { useFiltersStore } from '@/stores/filters'
+import type { AdminEventKind, AdminTotalsResponse, AdminUsageModelsResponse } from '@/types/api'
+
+/**
+ * HomePage (redesign-plan.md section 3.4) is the redesign's landing
+ * page: fleet-wide KPI tiles, the top-5 spenders and top-5 models for
+ * the current global range, the 8 most recent events, and a count of
+ * config warnings / unpriced models. Every KPI tile reads from
+ * stores/dashboard.ts's existing 5s poll (overview/usage) — no extra
+ * round trip for figures that are already fetched fleet-wide. The two
+ * top-5 lists are the one genuinely NEW read this page makes (GET
+ * /admin/api/usage/totals?kind=user, and the existing GET /admin/api/
+ * usage/models ranking), refetched on a 60s poll rather than every 5s
+ * (Q12, redesign-plan.md DECISIONS: "new endpoints on demand or 60s").
+ */
+const TOP_LIST_LIMIT = 5
+const TOP_LIST_POLL_MS = 60_000
+
+const auth = useAuthStore()
+const dashboard = useDashboardStore()
+const events = useEventsStore()
+const filters = useFiltersStore()
+
+// --- Spend vs budget ---------------------------------------------------
+
+const spendTodayMicros = computed<number>(() => dashboard.usage?.total.costPerDayMicroUsd ?? 0)
+const spendMtdMicros = computed<number>(() => dashboard.usage?.total.costPerMonthMicroUsd ?? 0)
+/** Q2 (DECISIONS): the Home budget baseline is the sum of every configured group's costPerMonthUSD — "no budget set" reads as 0 here. */
+const budgetMicros = computed<number>(() => sumGroupBudgetMicros(dashboard.overview?.groups ?? []))
+const spendTier = computed(() => budgetTier(budgetRatio(spendMtdMicros.value, budgetMicros.value)))
+const spendDelta = computed<string>(() => {
+  const today = `${formatCost(spendTodayMicros.value)} today`
+  return budgetMicros.value > 0 ? `${today} · budget ${formatCost(budgetMicros.value)}/mo` : `${today} · no budget set`
+})
+
+// --- Projected month-end (lib/forecast.ts) ------------------------------
+
+const projectedMicros = computed<number | null>(() => projectMonthEnd(spendMtdMicros.value, monthProgress(new Date())))
+const projectedHeadroom = computed(() =>
+  headroom(projectedMicros.value, budgetMicros.value > 0 ? budgetMicros.value / 1_000_000 : undefined),
+)
+const projectedValue = computed<string>(() =>
+  projectedMicros.value === null ? 'not enough data yet' : formatCost(projectedMicros.value),
+)
+const projectedTier = computed(() => (projectedHeadroom.value.willExceed ? 'critical' : 'ok'))
+const projectedDelta = computed<string | undefined>(() => {
+  if (projectedMicros.value === null) return undefined
+  if (budgetMicros.value <= 0) return 'no budget set'
+  return projectedHeadroom.value.willExceed ? 'projected to exceed budget' : 'projected within budget'
+})
+
+// --- Requests/min --------------------------------------------------------
+
+const requestsPerMinute = computed<number>(() => dashboard.usage?.total.requestsPerMinute ?? 0)
+
+// --- Fleet error rate (lib/kpi.ts) ---------------------------------------
+
+const errorRate = computed(() => fleetErrorRate(dashboard.overview?.providers ?? []))
+const errorTier = computed(() => errorRateTier(errorRate.value.rate))
+const errorValue = computed<string>(() => {
+  const rate = errorRate.value.rate
+  if (rate === null) return 'no traffic'
+  if (rate <= 0) return '0%'
+  // Ceiling, not the usual floor: a genuinely non-zero error rate must
+  // never round down to a misleadingly clean "0%" (the opposite honesty
+  // direction from a SUCCESS rate, which floors so it never overstates
+  // — see lib/provider-rate.ts's own formatRatePercent doc comment).
+  return `${Math.ceil(rate * 100)}%`
+})
+const errorDelta = computed<string>(() => `${errorRate.value.failures}/${errorRate.value.attempts} attempts in the last minute`)
+
+// --- Open breakers / warnings / unpriced ---------------------------------
+
+const breakerCount = computed<number>(() => openBreakerCount(dashboard.overview?.providers ?? []))
+const warningCount = computed<number>(() => dashboard.overview?.warnings.length ?? 0)
+const unpricedCount = computed<number>(() => dashboard.overview?.pricing.unpriced ?? 0)
+
+// --- Top 5 users by cost / top 5 models by cost --------------------------
+
+const topUsers = ref<TopListItem[]>([])
+const topModels = ref<TopListItem[]>([])
+const topListsError = ref('')
+/** topListsReqId guards against an out-of-order response overwriting a newer one — the 60s visibility-poller tick and a range change fire fetchTopLists() independently, so two calls can be in flight together (P2 item 7). */
+let topListsReqId = 0
+
+async function fetchTopLists(): Promise<void> {
+  if (!auth.isAuthenticated) return
+  const requestId = ++topListsReqId
+  try {
+    const [usersRes, modelsRes] = await Promise.all([
+      adminFetch<AdminTotalsResponse>(
+        totalsUrl({ kind: 'user', window: filters.window, span: filters.span, metrics: ['cost'], limit: TOP_LIST_LIMIT }),
+      ),
+      adminFetch<AdminUsageModelsResponse>(
+        `/admin/api/usage/models?metric=cost&window=${filters.window}&span=${filters.span}&limit=${TOP_LIST_LIMIT}`,
+      ),
+    ])
+    if (requestId !== topListsReqId) return
+    topUsers.value = usersRes.rows.map((row) => ({
+      id: row.id,
+      label: row.id,
+      value: formatCost(row.values.cost ?? 0),
+      kind: 'user' as const,
+    }))
+    topModels.value = modelsRes.models.map((m) => ({
+      id: m.id,
+      label: m.id,
+      value: formatCost(m.value),
+      kind: 'model' as const,
+    }))
+    topListsError.value = ''
+  } catch (err) {
+    if (requestId !== topListsReqId) return
+    topListsError.value = err instanceof Error ? err.message : String(err)
+  }
+}
+
+let topListsPoller: VisibilityPoller | undefined
+watch(
+  () => filters.range,
+  () => void fetchTopLists(),
+)
+
+// --- Latest 8 events -------------------------------------------------------
+
+/** kindLabel falls back to the raw kind string for a kind EVENT_KIND_LABEL does not know (a server newer than this webui build) — same forward-compat convention lib/events-columns.ts's own identical helper documents. */
+function kindLabel(kind: string): string {
+  return EVENT_KIND_LABEL[kind as AdminEventKind] ?? kind
+}
+
+const latestEvents = computed(() => events.events.slice(0, 8))
+
+onMounted(() => {
+  // Events store is polled only while a page that reads it is mounted
+  // (its own doc comment) — Home is one more such consumer, alongside
+  // the (future) Reliability page's own EventsView section.
+  events.startPolling()
+  topListsPoller = createVisibilityPoller({ intervalMs: TOP_LIST_POLL_MS, tick: () => void fetchTopLists() })
+  topListsPoller.start()
+})
+onUnmounted(() => {
+  events.stopPolling()
+  topListsPoller?.stop()
+})
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <section aria-label="Key metrics" class="grid grid-cols-2 gap-3 sm:grid-cols-3 lg:grid-cols-4">
+      <KpiTile label="Spend (MTD)" :value="formatCost(spendMtdMicros)" :delta="spendDelta" :tier="spendTier" :to="{ page: 'spend' }" />
+      <KpiTile
+        label="Projected month-end"
+        :value="projectedValue"
+        :delta="projectedDelta"
+        :tier="projectedTier"
+        :to="{ page: 'spend' }"
+      />
+      <KpiTile label="Requests/min" :value="formatCompactCount(requestsPerMinute)" />
+      <KpiTile
+        label="Error rate (last minute)"
+        :value="errorValue"
+        :delta="errorDelta"
+        :tier="errorTier"
+        :to="{ page: 'reliability' }"
+      />
+      <KpiTile
+        label="Open breakers (per replica)"
+        :value="String(breakerCount)"
+        :tier="breakerCount > 0 ? 'warn' : 'ok'"
+        :to="{ page: 'models' }"
+      />
+      <KpiTile
+        label="Config warnings"
+        :value="String(warningCount)"
+        :tier="warningCount > 0 ? 'warn' : 'ok'"
+        :to="{ page: 'config' }"
+      />
+      <KpiTile
+        label="Unpriced models"
+        :value="String(unpricedCount)"
+        :tier="unpricedCount > 0 ? 'warn' : 'ok'"
+        :to="{ page: 'spend' }"
+      />
+    </section>
+
+    <p v-if="topListsError" class="text-sm text-destructive">Top lists failed to load: {{ topListsError }}</p>
+
+    <section aria-label="Top spenders and models" class="grid grid-cols-1 gap-3 lg:grid-cols-2">
+      <TopList title="Top 5 users by cost" :items="topUsers" empty-text="No spend in this range yet." />
+      <TopList title="Top 5 models by cost" :items="topModels" empty-text="No spend in this range yet." />
+    </section>
+
+    <Card>
+      <CardHeader>
+        <CardTitle>Latest events</CardTitle>
+      </CardHeader>
+      <CardContent>
+        <p v-if="latestEvents.length === 0" class="text-sm text-muted-foreground">No events recorded yet.</p>
+        <ol v-else class="flex flex-col gap-2">
+          <li
+            v-for="(event, i) in latestEvents"
+            :key="`${event.time}-${event.replica}-${i}`"
+            class="flex items-start justify-between gap-3 text-sm"
+          >
+            <span class="flex min-w-0 items-center gap-2">
+              <Badge :variant="eventKindVariant(event.kind)" class="shrink-0 font-normal">{{ kindLabel(event.kind) }}</Badge>
+              <span class="min-w-0 truncate text-muted-foreground">{{ event.message }}</span>
+            </span>
+            <span class="shrink-0 tabular-nums text-muted-foreground">{{ formatTimestamp(event.time) }}</span>
+          </li>
+        </ol>
+      </CardContent>
+    </Card>
+  </div>
+</template>
diff --git a/webui/src/pages/ModelsPage.vue b/webui/src/pages/ModelsPage.vue
new file mode 100644
index 0000000..2b87667
--- /dev/null
+++ b/webui/src/pages/ModelsPage.vue
@@ -0,0 +1,66 @@
+<script setup lang="ts">
+import { computed, onMounted, watch } from 'vue'
+
+import ModelCatalogTable from '@/components/ModelCatalogTable.vue'
+import ProviderHealthPanel from '@/components/ProviderHealthPanel.vue'
+import { useFiltersStore } from '@/stores/filters'
+import { useModelsStore } from '@/stores/models'
+import { useNavStore } from '@/stores/nav'
+
+/**
+ * ModelsPage (redesign-plan.md section 3.4, "Models & providers") — the
+ * catalog table (ModelCatalogTable.vue), the Providers accordion moved
+ * from the pre-redesign ProvidersView.vue (ProviderHealthPanel.vue, now
+ * also carrying fleet-wide performance), and the model-alias table
+ * (bundled into ProviderHealthPanel.vue — see that component's own doc
+ * comment for why it stayed with the accordion it was already part of).
+ *
+ * Page params (redesign-plan.md section 3.1): `q` (free-text search,
+ * ModelCatalogTable.vue's own SearchInput) and `model` (a canonical
+ * "provider/model" id — EntityLink.vue's own deep-link target for a model
+ * row elsewhere in the panel). Both are folded into the SAME `query`
+ * computed getter/setter below (ConsumerDirectory.vue's own `usageQuery`
+ * convention) — bound directly to nav.params rather than a local ref, so a
+ * `q`/`model` change from anywhere else (a ProviderHealthPanel "view
+ * models" link, browser back/forward, a hand-edited hash) is picked up
+ * reactively instead of only once on mount.
+ */
+const filters = useFiltersStore()
+const models = useModelsStore()
+const nav = useNavStore()
+
+const query = computed<string>({
+  get: () => nav.params.q ?? nav.params.model ?? '',
+  set: (value) => {
+    // `query` is the single source of truth from here on — a stale
+    // `model` param from a deep link is dropped (not merged forward),
+    // since `q` now carries the exact same information. An empty
+    // `value` is fine to pass straight through: buildHash
+    // (lib/hash-state.ts) already omits an empty-string param from the
+    // URL.
+    const { model: _model, ...rest } = nav.params
+    nav.goTo('models', { ...rest, q: value })
+  },
+})
+
+onMounted(() => void models.fetch())
+
+watch(
+  () => filters.range,
+  () => void models.fetch(),
+)
+</script>
+
+<template>
+  <div class="flex flex-col gap-6">
+    <ProviderHealthPanel />
+    <p v-if="models.error" class="text-sm text-destructive">{{ models.error }}</p>
+    <ModelCatalogTable
+      :rows="models.rows"
+      :query="query"
+      :latency-enabled="models.latencyEnabled"
+      :loading="models.loading"
+      @update:query="query = $event"
+    />
+  </div>
+</template>
diff --git a/webui/src/pages/ReliabilityPage.vue b/webui/src/pages/ReliabilityPage.vue
new file mode 100644
index 0000000..9b9daf4
--- /dev/null
+++ b/webui/src/pages/ReliabilityPage.vue
@@ -0,0 +1,317 @@
+<script setup lang="ts">
+import { computed, onMounted, watch } from 'vue'
+
+import EventsView from '@/components/EventsView.vue'
+import TimeSeriesChart from '@/components/TimeSeriesChart.vue'
+import type { TimeSeriesDataset } from '@/components/TimeSeriesChart.vue'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { formatBucketLabel } from '@/lib/format'
+import { formatErrorRatePercent } from '@/lib/provider-rate'
+import { useDashboardStore } from '@/stores/dashboard'
+import { useEventsStore } from '@/stores/events'
+import { useFiltersStore } from '@/stores/filters'
+import { useNavStore } from '@/stores/nav'
+import { seriesColor, useReliabilityStore } from '@/stores/reliability'
+import type { CountSeries, ProviderRatioSeries } from '@/stores/reliability'
+
+/**
+ * ReliabilityPage (redesign-plan.md section 3.4) — error-rate/failover/
+ * timeout/429/402 series, plus the pre-redesign Events view reused as a
+ * section. Every chart is an on-demand fetch (useReliabilityStore.fetch),
+ * not part of the 5s dashboard poll — refetched on mount and whenever the
+ * global range changes (Q12 DECISIONS).
+ *
+ * Page params (redesign-plan.md section 3.1): `provider` narrows every
+ * per-provider chart to one provider's own line ('' / absent means every
+ * configured provider, overlaid); `kind`/`user` seed the embedded Events
+ * section's own filters (stores/events.ts's initFromParams). All three
+ * round-trip through the URL hash the same way EntityLink.vue's params do
+ * — nav.goTo on every local change, read back via nav.params on mount.
+ */
+/** '' is the "every provider" state (selectedProvider/filterSelected below). Radix/reka-ui Select items cannot use an empty-string value (EventsView.vue's own identical ALL_KINDS doc comment) — ALL_PROVIDERS_OPTION is the Select-only sentinel, mapped to/from '' at the template boundary. */
+const ALL_PROVIDERS_OPTION = 'all'
+
+const dashboard = useDashboardStore()
+const events = useEventsStore()
+const filters = useFiltersStore()
+const nav = useNavStore()
+const reliability = useReliabilityStore()
+
+const selectedProvider = computed<string>(() => nav.params.provider ?? '')
+const providerSelectValue = computed<string>(() => selectedProvider.value || ALL_PROVIDERS_OPTION)
+
+function onProviderChange(value: unknown): void {
+  if (typeof value !== 'string') return
+  nav.goTo('reliability', { ...nav.params, provider: value === ALL_PROVIDERS_OPTION ? '' : value })
+}
+
+/** providerLabel strips the "provider:" scope prefix every reliability series carries — the display label is just the provider name. */
+function providerLabel(scope: string): string {
+  return scope.replace(/^provider:/, '')
+}
+
+function filterSelected<T extends { scope: string }>(series: T[]): T[] {
+  if (!selectedProvider.value) return series
+  return series.filter((s) => providerLabel(s.scope) === selectedProvider.value)
+}
+
+/**
+ * NaN, not 0, marks a bucket with no attempts (errorRateSeries' own "null
+ * means no traffic" convention) — chart.js draws a gap at a NaN point
+ * rather than a misleading flat 0%, and NaN is still a plain `number`, so
+ * TimeSeriesDataset's `data: number[]` needs no cast here.
+ */
+function toChartPoints(points: (number | null)[]): number[] {
+  return points.map((p) => (p === null ? Number.NaN : p))
+}
+
+const errorRateDatasets = computed<TimeSeriesDataset[]>(() =>
+  filterSelected<ProviderRatioSeries>(reliability.errorRate).map((s, i) => ({
+    label: providerLabel(s.scope),
+    data: toChartPoints(s.points),
+    color: seriesColor(i),
+  })),
+)
+
+function countDatasets(series: CountSeries[]): TimeSeriesDataset[] {
+  return filterSelected(series).map((s, i) => ({ label: providerLabel(s.scope), data: s.points, color: seriesColor(i) }))
+}
+
+const timeoutDatasets = computed(() => countDatasets(reliability.timeouts))
+const failoverDatasets = computed(() => countDatasets(reliability.failovers))
+
+const rejectionDatasets = computed<TimeSeriesDataset[]>(() => [
+  { label: '429 rejections', data: reliability.rejections, color: '--destructive' },
+])
+const unpricedDatasets = computed<TimeSeriesDataset[]>(() => [
+  { label: '402 unpriced refusals', data: reliability.unpriced, color: '--status-warn' },
+])
+
+const bucketLabels = computed<string[]>(() => reliability.buckets.map((b) => formatBucketLabel(b, reliability.windowUsed)))
+
+/**
+ * errorRatePercent adapts TimeSeriesChart's plain `number` valueFormatter
+ * contract (NaN marks a no-attempts bucket, toChartPoints' own doc
+ * comment) to lib/provider-rate.ts's shared formatErrorRatePercent, which
+ * takes `null` for the identical "nothing to report" case — the actual
+ * ceiling-percent/"no data" wording lives in exactly one place, shared
+ * with lib/model-table-columns.ts's per-model error-rate column.
+ */
+function errorRatePercent(value: number): string {
+  return formatErrorRatePercent(Number.isNaN(value) ? null : value)
+}
+
+const hasProviders = computed(() => (dashboard.overview?.providers.length ?? 0) > 0)
+const noFailoverConfigured = computed(() => dashboard.overview !== null && dashboard.overview.features.failover === false)
+
+// --- selected-provider performance (N3 fix, redesign-plan.md section
+// 3.3: "performance series=1 for the selected provider") ---
+const latencyStatsEnabled = computed(() => dashboard.overview?.features.latencyStats ?? false)
+/** providerPerfAvailable gates the whole selected-provider chart section — both conditions the task names ("when a provider is selected and latency stats are enabled"), mirroring reliability.fetchProviderPerf's own short-circuit so the fetch and the render never disagree about when there is data to show. */
+const providerPerfAvailable = computed(() => selectedProvider.value !== '' && latencyStatsEnabled.value)
+
+const providerPerfBucketLabels = computed<string[]>(() =>
+  reliability.providerPerfBuckets.map((b) => formatBucketLabel(b, reliability.providerPerfWindowUsed)),
+)
+/** p50/p95 read as NaN (a chart.js gap, toChartPoints' own convention above) for a bucket with no observations — AdminPerfRow's own doc comment: undefined never means 0ms. */
+const providerLatencyDatasets = computed<TimeSeriesDataset[]>(() => [
+  { label: 'p50', data: reliability.providerPerfPoints.map((p) => p.p50Ms ?? Number.NaN), color: '--chart-requests' },
+  { label: 'p95', data: reliability.providerPerfPoints.map((p) => p.p95Ms ?? Number.NaN), color: '--chart-tokens-in' },
+])
+const providerFailureDatasets = computed<TimeSeriesDataset[]>(() => [
+  { label: 'failures', data: reliability.providerPerfPoints.map((p) => p.failures), color: '--destructive' },
+])
+
+watch(
+  () => [selectedProvider.value, filters.range] as const,
+  ([provider]) => void reliability.fetchProviderPerf(provider),
+  { immediate: true },
+)
+
+/**
+ * monthRangeClamped is true whenever the global range is a month preset
+ * (3mo/6mo/12mo) — stores/reliability.ts's own hourOrDayWindow has NO
+ * month bucket at all for any reliability metric (its own doc comment:
+ * "neither family has a month bucket at all, matching their own 48h/35d
+ * TTLs"), so it substitutes a fixed 30-day day-window instead. Every
+ * chart below silently shows that 30-day window regardless of which
+ * month preset is selected — this note (P3 item 20) says so, rather than
+ * letting a reader believe a "12mo" label over a chart that is actually
+ * showing the most recent 30 days.
+ */
+const monthRangeClamped = computed(() => filters.window === 'month')
+
+// Refetch whenever the global range changes (Q12 DECISIONS: "new endpoints
+// on demand or 60s" — this is the "on demand" case, driven by the reader's
+// own range choice rather than a timer) or once the dashboard's 5s poll
+// first discovers which providers are configured (a page that mounts
+// before the first overview poll lands would otherwise see hasProviders
+// flip true with no series fetched yet to back it).
+watch(
+  () => [filters.range, dashboard.overview?.providers.length ?? 0],
+  () => void reliability.fetch(),
+)
+
+// kind/user round-trip back into the URL hash (redesign-plan.md section
+// 3.1's Reliability page params) whenever the reader changes the embedded
+// Events section's own filters — mirrors `provider`'s own onProviderChange
+// above, one nav.goTo call merging every current page param so neither
+// write clobbers the other.
+watch(
+  () => [events.kindFilter, events.userFilter],
+  ([kind, user]) => {
+    nav.goTo('reliability', { ...nav.params, kind, user })
+  },
+)
+
+// nav.params.kind/user react to a hash change this page's own Select/
+// SearchInput did NOT originate — browser back/forward, a hand-edited URL,
+// or returning here via the sidebar with the param cleared (P2 item 10:
+// stores/events.ts's own initFromParams applies a param only when it is
+// PRESENT, by design, for a one-shot seed — but called only on mount, that
+// left a kind/user filter set on an earlier visit stuck in place when the
+// reader returned with an empty hash). `immediate: true` covers the
+// initial mount too, so this replaces that one-shot call outright.
+// Undefined always resolves to '' ("no filter"), and this never loops
+// against the watch above: assigning a store field its OWN current value
+// is a same-value write, which Vue's reactivity does not re-trigger a
+// dependent watch for.
+watch(
+  () => [nav.params.kind, nav.params.user] as const,
+  ([kind, user]) => {
+    events.setKindFilter(kind ?? '')
+    events.setUserFilter(user ?? '')
+  },
+  { immediate: true },
+)
+
+onMounted(() => void reliability.fetch())
+</script>
+
+<template>
+  <div class="flex flex-col gap-6">
+    <Card>
+      <CardHeader class="flex flex-col gap-3 sm:flex-row sm:items-center sm:justify-between">
+        <div>
+          <CardTitle>Reliability</CardTitle>
+          <CardDescription>Provider error rate, failovers, timeouts, rate-limit rejections, and 402 refusals.</CardDescription>
+        </div>
+        <div class="flex flex-col gap-1">
+          <label id="reliability-provider-label" class="text-xs font-medium text-muted-foreground">Provider</label>
+          <Select :model-value="providerSelectValue" @update:model-value="onProviderChange">
+            <SelectTrigger aria-labelledby="reliability-provider-label" class="w-48">
+              <SelectValue placeholder="All providers" />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem :value="ALL_PROVIDERS_OPTION">All providers</SelectItem>
+              <SelectItem v-for="p in dashboard.overview?.providers ?? []" :key="p.name" :value="p.name">{{ p.name }}</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+      </CardHeader>
+      <CardContent>
+        <p v-if="reliability.error" class="text-sm text-destructive">{{ reliability.error }}</p>
+        <p v-else-if="!hasProviders" class="text-sm text-muted-foreground">No providers configured.</p>
+      </CardContent>
+    </Card>
+
+    <Alert v-if="monthRangeClamped" variant="warn">
+      <AlertDescription>
+        Reliability data has no monthly retention — every chart below shows the most recent 30 days, not the full
+        {{ filters.range }} range selected above.
+      </AlertDescription>
+    </Alert>
+
+    <Card v-if="hasProviders">
+      <CardHeader>
+        <CardTitle>Error rate by provider</CardTitle>
+        <CardDescription>Failed attempts / total attempts per bucket. A gap means no attempts in that bucket.</CardDescription>
+      </CardHeader>
+      <CardContent>
+        <TimeSeriesChart :labels="bucketLabels" :datasets="errorRateDatasets" :value-formatter="errorRatePercent" ariaLabel="Error rate by provider over time" />
+      </CardContent>
+    </Card>
+
+    <Card v-if="hasProviders">
+      <CardHeader>
+        <CardTitle>Selected provider performance</CardTitle>
+        <CardDescription>Latency (p50/p95) and failures per bucket for one provider.</CardDescription>
+      </CardHeader>
+      <CardContent class="flex flex-col gap-4">
+        <p v-if="selectedProvider === ''" class="text-sm text-muted-foreground">
+          Select a provider above to see its latency and failure breakdown per bucket.
+        </p>
+        <p v-else-if="!latencyStatsEnabled" class="text-sm text-muted-foreground">
+          Enable <code class="font-mono text-xs">admin.stats.latency</code> in the plugin config to see per-bucket latency for
+          {{ selectedProvider }}.
+        </p>
+        <template v-else-if="providerPerfAvailable">
+          <p v-if="reliability.providerPerfError" class="text-sm text-destructive">{{ reliability.providerPerfError }}</p>
+          <div class="grid gap-6 lg:grid-cols-2">
+            <div>
+              <p class="mb-2 text-sm font-medium text-muted-foreground">Latency (ms)</p>
+              <TimeSeriesChart
+                :labels="providerPerfBucketLabels"
+                :datasets="providerLatencyDatasets"
+                :ariaLabel="`p50/p95 latency for ${selectedProvider} over time`"
+              />
+            </div>
+            <div>
+              <p class="mb-2 text-sm font-medium text-muted-foreground">Failures</p>
+              <TimeSeriesChart
+                :labels="providerPerfBucketLabels"
+                :datasets="providerFailureDatasets"
+                :ariaLabel="`Failures for ${selectedProvider} over time`"
+              />
+            </div>
+          </div>
+        </template>
+      </CardContent>
+    </Card>
+
+    <Card v-if="hasProviders">
+      <CardHeader>
+        <CardTitle>Timeouts by provider</CardTitle>
+      </CardHeader>
+      <CardContent>
+        <TimeSeriesChart :labels="bucketLabels" :datasets="timeoutDatasets" ariaLabel="Timeouts by provider over time" />
+      </CardContent>
+    </Card>
+
+    <Card v-if="hasProviders">
+      <CardHeader>
+        <CardTitle>Failovers by provider</CardTitle>
+        <CardDescription v-if="noFailoverConfigured">This deployment has no failover chains configured.</CardDescription>
+      </CardHeader>
+      <CardContent>
+        <TimeSeriesChart :labels="bucketLabels" :datasets="failoverDatasets" ariaLabel="Failovers by provider over time" />
+      </CardContent>
+    </Card>
+
+    <div class="grid gap-6 lg:grid-cols-2">
+      <Card>
+        <CardHeader>
+          <CardTitle>Rate-limit rejections (429)</CardTitle>
+          <CardDescription>Fleet-wide, every scope combined.</CardDescription>
+        </CardHeader>
+        <CardContent>
+          <TimeSeriesChart :labels="bucketLabels" :datasets="rejectionDatasets" ariaLabel="Rate-limit rejections over time, fleet-wide" />
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Unpriced refusals (402)</CardTitle>
+          <CardDescription>Fleet-wide requests refused for having no resolvable price.</CardDescription>
+        </CardHeader>
+        <CardContent>
+          <TimeSeriesChart :labels="bucketLabels" :datasets="unpricedDatasets" ariaLabel="Unpriced refusals (402) over time, fleet-wide" />
+        </CardContent>
+      </Card>
+    </div>
+
+    <EventsView />
+  </div>
+</template>
diff --git a/webui/src/pages/SpendPage.vue b/webui/src/pages/SpendPage.vue
new file mode 100644
index 0000000..aec092f
--- /dev/null
+++ b/webui/src/pages/SpendPage.vue
@@ -0,0 +1,318 @@
+<script setup lang="ts">
+import { computed, onMounted, onUnmounted, watch } from 'vue'
+
+import AttributionDrilldown from '@/components/AttributionDrilldown.vue'
+import BurnDownChart from '@/components/BurnDownChart.vue'
+import CostAvoidedCard from '@/components/CostAvoidedCard.vue'
+import CostForecastCard from '@/components/CostForecastCard.vue'
+import PricingHealthTable from '@/components/PricingHealthTable.vue'
+import TimeSeriesChart from '@/components/TimeSeriesChart.vue'
+import type { TimeSeriesComparisonDataset, TimeSeriesDataset } from '@/components/TimeSeriesChart.vue'
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select'
+import { Tabs, TabsList, TabsTrigger } from '@/components/ui/tabs'
+import { useNow } from '@/composables/useNow'
+import { cacheSavingsStatus } from '@/lib/cache-savings'
+import { formatBucketLabel, formatCompactCount, formatCost } from '@/lib/format'
+import { useCatalogStore } from '@/stores/catalog'
+import { useDashboardStore } from '@/stores/dashboard'
+import { useFiltersStore } from '@/stores/filters'
+import { useNavStore } from '@/stores/nav'
+import {
+  isSpendBy,
+  isSpendMetric,
+  SPEND_BY,
+  SPEND_METRIC_LABEL,
+  SPEND_METRICS,
+  useSpendStore,
+} from '@/stores/spend'
+import type { SpendBy } from '@/stores/spend'
+import type { HistoryMetric, LimitsConfig } from '@/types/api'
+
+const SPEND_BY_LABEL: Record<SpendBy, string> = { model: 'By model', provider: 'By provider', group: 'By group' }
+
+const nav = useNavStore()
+const filters = useFiltersStore()
+const dashboard = useDashboardStore()
+const catalog = useCatalogStore()
+const spend = useSpendStore()
+const { now, start: startClock, stop: stopClock } = useNow()
+
+// --- page params (redesign-plan.md section 3.1: by/metric/ref/drill) ---
+
+const by = computed<SpendBy>(() => (nav.params.by && isSpendBy(nav.params.by) ? nav.params.by : 'model'))
+const metric = computed<HistoryMetric>(() => (nav.params.metric && isSpendMetric(nav.params.metric) ? nav.params.metric : 'cost'))
+const refParam = computed<string>(() => nav.params.ref ?? '')
+const drillParam = computed<string>(() => nav.params.drill ?? '')
+
+/** updateParams merges one changed field over the current by/metric/ref/drill and writes the whole set back via nav.goTo (which REPLACES, never merges, stores/nav.ts's own doc comment) — a key is included only when it differs from its default, keeping the hash as clean as every other page's own param convention. */
+function updateParams(next: Partial<{ by: SpendBy; metric: HistoryMetric; ref: string; drill: string }>): void {
+  const merged = {
+    by: next.by ?? by.value,
+    metric: next.metric ?? metric.value,
+    ref: next.ref ?? refParam.value,
+    drill: next.drill ?? drillParam.value,
+  }
+  const params: Record<string, string> = {}
+  if (merged.by !== 'model') params.by = merged.by
+  if (merged.metric !== 'cost') params.metric = merged.metric
+  if (merged.ref !== '') params.ref = merged.ref
+  if (merged.drill !== '') params.drill = merged.drill
+  nav.goTo('spend', params)
+}
+
+function onByChange(value: string | number): void {
+  if (typeof value === 'string' && isSpendBy(value)) updateParams({ by: value })
+}
+function onMetricUpdate(value: unknown): void {
+  if (typeof value === 'string' && isSpendMetric(value)) updateParams({ metric: value })
+}
+function onRefUpdate(value: string): void {
+  updateParams({ ref: value })
+}
+function onDrillUpdate(value: string): void {
+  updateParams({ drill: value })
+}
+
+// The breakdown-dimension selector has nothing left to choose once the
+// global scope filter has already narrowed to one group/user — the chart
+// then shows exactly that one entity's own line regardless of `by` (see
+// stores/spend.ts's own doc comment on scope narrowing).
+const byDisabled = computed<boolean>(() => filters.scope !== 'all')
+
+// --- sync page params + global filters into the store ---
+
+watch([by, metric, drillParam], ([b, m, d]) => {
+  spend.setSelection({ by: b, metric: m, drill: d })
+})
+watch(
+  () => [filters.range, filters.cmp, filters.scope],
+  () => void spend.refresh(),
+)
+
+onMounted(() => {
+  spend.$patch({ by: by.value, metric: metric.value, drill: drillParam.value })
+  void catalog.ensureLoaded()
+  spend.startPolling() // ticks once immediately — the page's initial fetch.
+  startClock()
+})
+onUnmounted(() => {
+  spend.stopPolling()
+  stopClock()
+})
+
+// --- breakdown chart ---
+
+/**
+ * BREAKDOWN_PALETTE cycles a colorblind-safe (Okabe & Ito, 2008) 8-color
+ * qualitative set across the breakdown chart's per-model/provider/group
+ * series. The first four reuse main.css's own existing --chart-* tokens
+ * (already that same palette's requests/tokens-in/tokens-out/cost
+ * members); the remaining four (--chart-series-a..d) extend it, defined
+ * alongside them in assets/main.css — main.css's original four tokens
+ * were sized for four FIXED semantic metrics, not an open-ended
+ * breakdown series count, so this page needed four more, but every chart
+ * color token lives in the one design-tokens file (Tailwind-only rule),
+ * never a component-local <style> block. Beyond 8 series (e.g. a fleet
+ * with more than 8 configured groups) colors repeat — an accepted
+ * qualitative-palette limit, not a bug: legend labels remain the
+ * disambiguator past that point, the same tradeoff any categorical chart
+ * palette makes once it runs out of distinguishable hues.
+ */
+const BREAKDOWN_PALETTE = [
+  '--chart-requests',
+  '--chart-tokens-in',
+  '--chart-tokens-out',
+  '--chart-cost',
+  '--chart-series-a',
+  '--chart-series-b',
+  '--chart-series-c',
+  '--chart-series-d',
+]
+
+function paletteColor(index: number): string {
+  return BREAKDOWN_PALETTE[index % BREAKDOWN_PALETTE.length]!
+}
+
+/** breakdownLabel strips a series' own scope-kind prefix ("model:"/"group:") for the chart legend — sumByProvider's own output already has no prefix (lib/series.ts). */
+function breakdownLabel(scope: string): string {
+  if (scope.startsWith('model:')) return scope.slice('model:'.length)
+  if (scope.startsWith('group:')) return scope.slice('group:'.length)
+  if (scope.startsWith('provider:')) return scope.slice('provider:'.length)
+  return scope
+}
+
+// The breakdown chart's own window (filters.window) decides the bucket
+// label format (lib/format.ts's formatBucketLabel), same as every other
+// chart in this panel.
+const breakdownLabels = computed<string[]>(() => spend.buckets.map((b) => formatBucketLabel(b, filters.window)))
+
+const breakdownDatasets = computed<TimeSeriesDataset[]>(() => {
+  const charted: TimeSeriesDataset[] = spend.breakdown.map((s, i) => ({
+    label: breakdownLabel(s.scope),
+    data: s.points,
+    color: paletteColor(i),
+  }))
+  if (spend.otherPoints) charted.push({ label: 'Other', data: spend.otherPoints, color: '--muted-foreground' })
+  return charted
+})
+
+// This IS a real "vs previous period" comparison (Q5) — unlike
+// BurnDownChart.vue's own flat budget reference line, which reuses the
+// same comparisonDatasets prop but opts OUT of the suffix (P2 item 5).
+const comparisonDatasets = computed<TimeSeriesComparisonDataset[]>(() =>
+  spend.comparisonPoints ? [{ label: 'Total', data: spend.comparisonPoints, color: '--foreground', labelSuffix: ' (previous period)' }] : [],
+)
+
+const valueFormatter = computed<(value: number) => string>(() => (metric.value === 'cost' ? formatCost : formatCompactCount))
+
+const totalInRange = computed<number>(() => spend.totalPoints.reduce((a, b) => a + b, 0))
+
+// --- forecast / burn-down scope derivation (Q2/DECISIONS: fleet budget = sum of group costPerMonthUSD) ---
+
+const scopeMtdMicros = computed<number>(() => {
+  if (filters.scope === 'all') return dashboard.usage?.total.costPerMonthMicroUsd ?? 0
+  if (filters.scope.startsWith('group:')) {
+    const name = filters.scope.slice('group:'.length)
+    return dashboard.usage?.groups.find((g) => g.id === name)?.costPerMonthMicroUsd ?? 0
+  }
+  if (filters.scope.startsWith('user:')) {
+    const name = filters.scope.slice('user:'.length)
+    return dashboard.usage?.users.find((u) => u.id === name)?.costPerMonthMicroUsd ?? 0
+  }
+  return 0
+})
+
+const scopeLimits = computed<LimitsConfig | undefined>(() => {
+  if (filters.scope === 'all') {
+    const groups = dashboard.overview?.groups ?? []
+    const budgeted = groups.filter((g) => (g.limits?.costPerMonthUSD ?? 0) > 0)
+    if (budgeted.length === 0) return undefined
+    const totalUsd = budgeted.reduce((sum, g) => sum + (g.limits?.costPerMonthUSD ?? 0), 0)
+    return { costPerMonthUSD: totalUsd }
+  }
+  if (filters.scope.startsWith('group:')) {
+    const name = filters.scope.slice('group:'.length)
+    return dashboard.overview?.groups.find((g) => g.name === name)?.limits
+  }
+  if (filters.scope.startsWith('user:')) {
+    const name = filters.scope.slice('user:'.length)
+    return dashboard.usage?.users.find((u) => u.id === name)?.limits
+  }
+  return undefined
+})
+
+const forecastAvailable = computed<boolean>(() => filters.scope === 'all' || filters.scope.startsWith('group:') || filters.scope.startsWith('user:'))
+
+// --- attribution drilldown gating ---
+
+const userModelStatsEnabled = computed<boolean>(() => dashboard.overview?.features.userModelStats ?? false)
+const cacheStatsEnabled = computed<boolean>(() => dashboard.overview?.features.cacheStats ?? false)
+
+/**
+ * cacheSavingsStatusResult (N2 fix, verify-redesign-final.md — replaces
+ * the P3-item-15 note this superseded, which described an already-fixed
+ * backend bug): lib/cache-savings.ts's own doc comment has the full,
+ * CURRENT backend-behaviour explanation this page passes down as plain
+ * props. `available` gates whether CostAvoidedCard.vue renders a dollar
+ * figure at all (false for an hour-window range — the backend never
+ * writes a per-hour cache-savings bucket, so there is no number to sum,
+ * not a genuine $0) or a caveat-annotated figure (month-window ranges,
+ * capped at the day counter's own 35-day retention).
+ */
+const cacheSavingsStatusResult = computed(() => cacheSavingsStatus(filters.window))
+const cacheSavingsAvailable = computed<boolean>(() => cacheSavingsStatusResult.value.available)
+const cacheSavingsNote = computed<string | null>(() => cacheSavingsStatusResult.value.note)
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between">
+      <div class="flex flex-wrap items-center gap-3">
+        <div class="flex flex-col gap-1">
+          <span class="text-xs font-medium text-muted-foreground">Breakdown</span>
+          <Tabs :model-value="by" @update:model-value="onByChange">
+            <TabsList>
+              <TabsTrigger v-for="key in SPEND_BY" :key="key" :value="key" :disabled="byDisabled">
+                {{ SPEND_BY_LABEL[key] }}
+              </TabsTrigger>
+            </TabsList>
+          </Tabs>
+        </div>
+        <div class="flex flex-col gap-1">
+          <label id="spend-metric-label" class="text-xs font-medium text-muted-foreground">Metric</label>
+          <Select :model-value="metric" @update:model-value="onMetricUpdate">
+            <SelectTrigger aria-labelledby="spend-metric-label" class="w-40">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem v-for="m in SPEND_METRICS" :key="m" :value="m">{{ SPEND_METRIC_LABEL[m] }}</SelectItem>
+            </SelectContent>
+          </Select>
+        </div>
+      </div>
+      <div class="text-right">
+        <p class="text-xs font-medium text-muted-foreground">{{ SPEND_METRIC_LABEL[metric] }} in range</p>
+        <p class="text-2xl font-semibold tabular-nums">{{ valueFormatter(totalInRange) }}</p>
+      </div>
+    </div>
+    <p v-if="byDisabled" class="text-sm text-muted-foreground">
+      Showing <span class="font-mono text-xs">{{ filters.scope }}</span> directly — clear the scope filter to break spend down by
+      model, provider, or group.
+    </p>
+    <p v-if="spend.error" class="text-sm text-destructive">{{ spend.error }}</p>
+    <!-- P3 item 23: catalog.error was never rendered — PricingHealthTable/
+    CostAvoidedCard both depend on catalog.modelsById and silently showed
+    empty/"no priced model" with no indication the catalog fetch itself
+    had failed. -->
+    <p v-if="catalog.error" class="text-sm text-destructive">{{ catalog.error }}</p>
+    <!-- P3 item 19 / Q5: a requested-but-unavailable comparison (a
+    single-provider scope) used to leave the "vs previous period" toggle
+    pressed with no dashed line and no explanation. -->
+    <p v-if="filters.cmpSpec.requested && spend.comparisonUnavailableReason" class="text-sm text-muted-foreground">
+      {{ spend.comparisonUnavailableReason }}
+    </p>
+
+    <TimeSeriesChart
+      :labels="breakdownLabels"
+      :datasets="breakdownDatasets"
+      :comparison-datasets="comparisonDatasets"
+      stacked
+      :value-formatter="valueFormatter"
+      :ariaLabel="`${SPEND_METRIC_LABEL[metric]} breakdown ${SPEND_BY_LABEL[by].toLowerCase()} over time`"
+    />
+
+    <div class="grid grid-cols-1 gap-4 lg:grid-cols-2">
+      <BurnDownChart
+        v-if="spend.burndownAvailable"
+        :buckets="spend.burndownBuckets"
+        :points="spend.burndownPoints"
+        :budget-micros="spend.burndownBudgetMicros"
+        :now="now"
+      />
+      <CostForecastCard v-if="forecastAvailable" :mtd-micros="scopeMtdMicros" :limits="scopeLimits" :now="now" />
+    </div>
+
+    <CostAvoidedCard
+      :models="spend.modelRanking"
+      :catalog="catalog.modelsById"
+      :ref-model="refParam"
+      :cache-stats-enabled="cacheStatsEnabled"
+      :cache-savings-available="cacheSavingsAvailable"
+      :cache-savings-note="cacheSavingsNote"
+      @update:ref-model="onRefUpdate"
+    />
+
+    <PricingHealthTable :models="spend.pricingHealthRanking" :catalog="catalog.modelsById" />
+
+    <AttributionDrilldown
+      :rows="spend.drilldownRows"
+      :metrics="spend.drilldownMetrics"
+      :drill="drillParam"
+      :disabled="spend.drilldownDisabled"
+      :user-model-stats-enabled="userModelStatsEnabled"
+      :window="filters.window"
+      :span="filters.span"
+      @update:drill="onDrillUpdate"
+    />
+  </div>
+</template>
diff --git a/webui/src/pages/TargetsPage.vue b/webui/src/pages/TargetsPage.vue
new file mode 100644
index 0000000..38b9a5a
--- /dev/null
+++ b/webui/src/pages/TargetsPage.vue
@@ -0,0 +1,53 @@
+<script setup lang="ts">
+import { computed, reactive } from 'vue'
+
+import TargetCallers from '@/components/TargetCallers.vue'
+import TargetsView from '@/components/TargetsView.vue'
+import { useNavStore } from '@/stores/nav'
+
+/**
+ * TargetsPage (redesign-plan.md section 3.4, "MCP & Agents") is
+ * TargetsView.vue's pre-redesign listing (unchanged: MCP servers/agents,
+ * their access lists, and request counters), plus the per-target caller
+ * breakdown ("TargetCallers.vue expander") and a fleet-wide "top callers"
+ * card, both reading GET /admin/api/usage/totals?kind=targetcaller.
+ *
+ * `target` (hash param) deep-links directly to one target's own callers —
+ * read as a computed straight off nav.params (P2 item 10: a local ref set
+ * only once on mount ignored a LATER hashchange — browser back/forward, a
+ * hand-edited URL — while the page stayed mounted) and kept in sync
+ * afterwards via nav.goTo so a reader who clicks a different target gets a
+ * bookmarkable/shareable URL, mirroring EntityLink.vue's own
+ * one-param-at-a-time convention.
+ */
+const nav = useNavStore()
+
+const selectedTargetId = computed<string>(() => nav.params.target ?? '')
+
+/**
+ * knownLabels remembers the real display name TargetsView.vue's own click
+ * handed selectTarget, keyed by composed id — selectedTargetLabel below
+ * falls back to the raw id (TargetCallers.vue's own card title) whenever
+ * the CURRENT selectedTargetId has no recorded label, e.g. a fresh deep
+ * link that never went through a click (the label is cosmetic only —
+ * TargetCallers.vue's own card title, not a lookup key — so this never
+ * blocks on the targets listing having loaded).
+ */
+const knownLabels = reactive<Record<string, string>>({})
+const selectedTargetLabel = computed<string>(() => knownLabels[selectedTargetId.value] ?? selectedTargetId.value)
+
+function selectTarget(id: string, label: string): void {
+  knownLabels[id] = label
+  nav.goTo('targets', { ...nav.params, target: id })
+}
+</script>
+
+<template>
+  <div class="flex flex-col gap-6">
+    <TargetsView @select="selectTarget" />
+
+    <TargetCallers v-if="selectedTargetId" :target="selectedTargetId" :title="`Callers of ${selectedTargetLabel}`" />
+
+    <TargetCallers title="Top callers, across every target" />
+  </div>
+</template>
diff --git a/webui/src/stores/catalog.spec.ts b/webui/src/stores/catalog.spec.ts
new file mode 100644
index 0000000..d65f7e7
--- /dev/null
+++ b/webui/src/stores/catalog.spec.ts
@@ -0,0 +1,146 @@
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/lib/api', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/api')>('@/lib/api')
+  return { ...actual, adminFetch: vi.fn() }
+})
+
+import { adminFetch, AdminApiError } from '@/lib/api'
+import { useAuthStore } from '@/stores/auth'
+import { useCatalogStore } from '@/stores/catalog'
+import type { AdminCatalogResponse } from '@/types/api'
+
+const mockedAdminFetch = vi.mocked(adminFetch)
+
+const catalogFixture: AdminCatalogResponse = {
+  providers: [
+    {
+      name: 'openai',
+      type: 'openai',
+      lastRefresh: '2026-09-23T00:00:00Z',
+      openUntil: '0001-01-01T00:00:00Z',
+      healthState: 'closed',
+      discoveryEnabled: true,
+      models: [
+        { id: 'openai/gpt-5', model: 'gpt-5', priceSource: 'builtin', inputPerMTokUsd: 1.25, outputPerMTokUsd: 10 },
+        { id: 'openai/gpt-5-mini:free', model: 'gpt-5-mini:free', priceSource: 'unpriced', displayFree: true },
+      ],
+    },
+  ],
+  aliases: [],
+}
+
+describe('useCatalogStore.fetch', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    mockedAdminFetch.mockReset()
+    useAuthStore().submit('test-admin-key')
+  })
+
+  it('is a no-op while unauthenticated', async () => {
+    setActivePinia(createPinia())
+    const catalog = useCatalogStore()
+    await catalog.fetch()
+    expect(mockedAdminFetch).not.toHaveBeenCalled()
+    expect(catalog.data).toBeNull()
+  })
+
+  it('populates data and fetchedAt on success, clearing any prior error', async () => {
+    mockedAdminFetch.mockResolvedValue(catalogFixture)
+    const catalog = useCatalogStore()
+    await catalog.fetch()
+
+    expect(catalog.data).toEqual(catalogFixture)
+    expect(catalog.fetchedAt).not.toBeNull()
+    expect(catalog.error).toBe('')
+    expect(catalog.loading).toBe(false)
+  })
+
+  it('indexes modelsById by canonical id across every provider', async () => {
+    mockedAdminFetch.mockResolvedValue(catalogFixture)
+    const catalog = useCatalogStore()
+    await catalog.fetch()
+
+    expect(catalog.modelsById.get('openai/gpt-5')?.priceSource).toBe('builtin')
+    expect(catalog.modelsById.get('openai/gpt-5-mini:free')?.displayFree).toBe(true)
+    expect(catalog.modelsById.size).toBe(2)
+  })
+
+  it('records a plain error message on a non-auth failure', async () => {
+    mockedAdminFetch.mockRejectedValue(new Error('boom'))
+    const catalog = useCatalogStore()
+    await catalog.fetch()
+
+    expect(catalog.error).toBe('boom')
+    expect(catalog.data).toBeNull()
+  })
+
+  it('does not surface an error for a 401/403 (the auth store owns that case)', async () => {
+    mockedAdminFetch.mockRejectedValue(new AdminApiError('unauthorized', 401))
+    const catalog = useCatalogStore()
+    await catalog.fetch()
+
+    expect(catalog.error).toBe('')
+  })
+
+  it('latest-request-wins: an older in-flight fetch never overwrites a newer one', async () => {
+    let resolveFirst!: (v: AdminCatalogResponse) => void
+    mockedAdminFetch.mockImplementationOnce(
+      () => new Promise<AdminCatalogResponse>((resolve) => (resolveFirst = resolve)),
+    )
+    const catalog = useCatalogStore()
+    const first = catalog.fetch()
+
+    mockedAdminFetch.mockResolvedValueOnce(catalogFixture)
+    await catalog.fetch()
+    expect(catalog.data).toEqual(catalogFixture)
+
+    resolveFirst({ providers: [], aliases: [] })
+    await first
+    // The first (older) fetch's empty result must not clobber the second's.
+    expect(catalog.data).toEqual(catalogFixture)
+  })
+})
+
+describe('useCatalogStore.ensureLoaded', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    mockedAdminFetch.mockReset()
+    mockedAdminFetch.mockResolvedValue(catalogFixture)
+    useAuthStore().submit('test-admin-key')
+  })
+
+  it('fetches when never loaded', async () => {
+    const catalog = useCatalogStore()
+    await catalog.ensureLoaded()
+    expect(mockedAdminFetch).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not refetch a fresh catalog', async () => {
+    const catalog = useCatalogStore()
+    await catalog.ensureLoaded()
+    await catalog.ensureLoaded()
+    expect(mockedAdminFetch).toHaveBeenCalledTimes(1)
+  })
+
+  it('refetches once stale', async () => {
+    vi.useFakeTimers()
+    try {
+      const catalog = useCatalogStore()
+      await catalog.ensureLoaded()
+      vi.advanceTimersByTime(5 * 60 * 1000 + 1)
+      await catalog.ensureLoaded()
+      expect(mockedAdminFetch).toHaveBeenCalledTimes(2)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('force bypasses the staleness check', async () => {
+    const catalog = useCatalogStore()
+    await catalog.ensureLoaded()
+    await catalog.ensureLoaded(true)
+    expect(mockedAdminFetch).toHaveBeenCalledTimes(2)
+  })
+})
diff --git a/webui/src/stores/catalog.ts b/webui/src/stores/catalog.ts
new file mode 100644
index 0000000..2c8d033
--- /dev/null
+++ b/webui/src/stores/catalog.ts
@@ -0,0 +1,98 @@
+import { defineStore } from 'pinia'
+
+import { AdminApiError, adminFetch } from '@/lib/api'
+import { useAuthStore } from '@/stores/auth'
+import type { AdminCatalogModel, AdminCatalogResponse } from '@/types/api'
+
+/**
+ * How long a fetched catalog stays fresh before ensureLoaded() will fetch
+ * again (redesign-plan.md section 3.3: "catalog (/catalog on demand,
+ * 5-minute stale)"). GET /admin/api/catalog reads the registry snapshot —
+ * no live counter round trip (admin_catalog.go's own doc comment) — so it
+ * changes only on a discovery refresh or a config reload, far slower than
+ * the 5s overview poll; every page that needs it (Spend's pricing health
+ * and cost-avoided reference picker, WP-F's Models catalog table) can
+ * treat a 5-minute-old copy as current rather than re-fetching on every
+ * mount.
+ */
+const STALE_MS = 5 * 60 * 1000
+
+/**
+ * useCatalogStore fetches GET /admin/api/catalog on demand (never part of
+ * the 5s dashboard poll, Q12/DECISIONS) and indexes it by canonical
+ * "provider/model" id (admin_catalog.go's providerModelScopeID — the SAME
+ * id AdminUsageModelEntry.id and AdminSeriesResponse's `model:{canonical}`
+ * scope already use, so every consumer joins against it with a plain map
+ * lookup, no id reformatting).
+ *
+ * Lands FIRST in WP-D (redesign-plan.md section 4): WP-F's Models page
+ * (ModelCatalogTable.vue, ProviderHealthPanel.vue) depends on this store
+ * existing before it can build against it.
+ */
+export const useCatalogStore = defineStore('catalog', {
+  state: () => ({
+    data: null as AdminCatalogResponse | null,
+    fetchedAt: null as Date | null,
+    loading: false,
+    error: '',
+    /** reqId guards against an out-of-order response overwriting a newer one — the same latest-request-wins convention every other store's own fetch action follows (stores/dashboard.ts, stores/spend.ts). */
+    reqId: 0,
+  }),
+  getters: {
+    /** stale is true before the first successful fetch, or once STALE_MS has elapsed since it — ensureLoaded's own refetch condition, also readable by a caller that wants to show "catalog data may be out of date" copy. */
+    stale(state): boolean {
+      if (!state.fetchedAt) return true
+      return Date.now() - state.fetchedAt.getTime() > STALE_MS
+    },
+    /**
+     * modelsById indexes every provider's models by canonical id — the one
+     * join key every consumer (PricingHealthTable, CostAvoidedCard's
+     * reference-model picker, WP-F's ModelCatalogTable) needs, computed
+     * once per fetch (a Pinia getter is cached per state reference) rather
+     * than every consumer re-scanning `data.providers` itself.
+     */
+    modelsById(state): Map<string, AdminCatalogModel> {
+      const map = new Map<string, AdminCatalogModel>()
+      for (const provider of state.data?.providers ?? []) {
+        for (const model of provider.models) map.set(model.id, model)
+      }
+      return map
+    },
+  },
+  actions: {
+    /**
+     * ensureLoaded fetches only when the catalog has never loaded, or has
+     * gone stale (STALE_MS) — every page that reads catalog data calls
+     * this from its own onMounted rather than unconditionally fetching, so
+     * navigating between Spend/Models repeatedly does not re-pay this read
+     * every time. `force` bypasses the staleness check (a reader-initiated
+     * "refresh catalog" action, if one is ever added).
+     */
+    async ensureLoaded(force = false): Promise<void> {
+      if (!force && this.data && !this.stale) return
+      await this.fetch()
+    },
+    async fetch(): Promise<void> {
+      const auth = useAuthStore()
+      if (!auth.isAuthenticated) return
+      const requestId = ++this.reqId
+      this.loading = true
+      try {
+        const res = await adminFetch<AdminCatalogResponse>('/admin/api/catalog')
+        // Stale: a newer fetch() call already superseded this one.
+        if (requestId !== this.reqId) return
+        this.data = res
+        this.fetchedAt = new Date()
+        this.error = ''
+      } catch (err) {
+        if (requestId !== this.reqId) return
+        if (err instanceof AdminApiError && (err.status === 401 || err.status === 403)) {
+          return
+        }
+        this.error = err instanceof Error ? err.message : String(err)
+      } finally {
+        if (requestId === this.reqId) this.loading = false
+      }
+    },
+  },
+})
diff --git a/webui/src/stores/config.ts b/webui/src/stores/config.ts
new file mode 100644
index 0000000..a82a0fc
--- /dev/null
+++ b/webui/src/stores/config.ts
@@ -0,0 +1,44 @@
+import { defineStore } from 'pinia'
+
+import { AdminApiError, adminFetch } from '@/lib/api'
+import { useAuthStore } from '@/stores/auth'
+import type { AdminConfigResponse } from '@/types/api'
+
+/**
+ * useConfigStore backs the Config page (redesign-plan.md section 3.4): the
+ * redacted config tree plus config warnings, from GET /admin/api/config —
+ * fetched on demand (ConfigPage.vue's own onMounted), not polled: the
+ * plugin's own config is immutable for a running replica's lifetime (a
+ * config edit needs a reload/restart), so there is nothing to poll for.
+ * ConfigPage.vue still exposes a manual refresh (in case the operator just
+ * redeployed and wants the freshly-loaded config without a full page
+ * reload).
+ */
+export const useConfigStore = defineStore('config', {
+  state: () => ({
+    data: null as AdminConfigResponse | null,
+    loading: false,
+    error: '',
+  }),
+  actions: {
+    async fetchConfig(): Promise<void> {
+      const auth = useAuthStore()
+      if (!auth.isAuthenticated) return
+      this.loading = true
+      try {
+        this.data = await adminFetch<AdminConfigResponse>('/admin/api/config')
+        this.error = ''
+      } catch (err) {
+        if (err instanceof AdminApiError && (err.status === 401 || err.status === 403)) return
+        this.error = err instanceof Error ? err.message : String(err)
+      } finally {
+        this.loading = false
+      }
+    },
+    /** ensureConfig fetches only when there is no data yet — ConfigPage.vue's own onMounted call. */
+    async ensureConfig(): Promise<void> {
+      if (this.loading || this.data) return
+      await this.fetchConfig()
+    },
+  },
+})
diff --git a/webui/src/stores/consumers.spec.ts b/webui/src/stores/consumers.spec.ts
new file mode 100644
index 0000000..3a29a44
--- /dev/null
+++ b/webui/src/stores/consumers.spec.ts
@@ -0,0 +1,188 @@
+// consumers.spec.ts mirrors dashboard.spec.ts's own mocking convention
+// (that file's own doc comment): adminFetch (lib/api.ts) is mocked
+// entirely, no real network or sessionStorage access.
+
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/lib/api', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/api')>('@/lib/api')
+  return { ...actual, adminFetch: vi.fn() }
+})
+
+import { AdminApiError, adminFetch } from '@/lib/api'
+import { useAuthStore } from '@/stores/auth'
+import { useConsumersStore } from '@/stores/consumers'
+import type { AdminConsumersResponse, AdminSeriesResponse, AdminTotalsResponse } from '@/types/api'
+
+const mockedAdminFetch = vi.mocked(adminFetch)
+
+const emptyConsumers: AdminConsumersResponse = { users: [], groups: [] }
+const emptySeries: AdminSeriesResponse = { metric: 'req', window: 'day', span: 7, offset: 0, buckets: [], series: [], unknown: [] }
+const emptyTotals: AdminTotalsResponse = { kind: 'usermodel', window: 'day', span: 7, offset: 0, metrics: ['req'], rows: [] }
+
+describe('useConsumersStore.fetchConsumers / ensureConsumers', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    mockedAdminFetch.mockReset()
+    useAuthStore().submit('test-admin-key')
+  })
+
+  it('fetches and stores the /admin/api/consumers response', async () => {
+    mockedAdminFetch.mockResolvedValue(emptyConsumers)
+    const store = useConsumersStore()
+    await store.fetchConsumers()
+
+    expect(mockedAdminFetch).toHaveBeenCalledWith('/admin/api/consumers')
+    // toEqual (not toBe): Pinia wraps state in a reactive Proxy, so
+    // store.data is never the same object reference as the fixture
+    // adminFetch resolved with, only structurally identical.
+    expect(store.data).toEqual(emptyConsumers)
+    expect(store.error).toBe('')
+    expect(store.fetchedAt).not.toBeNull()
+  })
+
+  it('records the error message on failure', async () => {
+    mockedAdminFetch.mockRejectedValue(new Error('boom'))
+    const store = useConsumersStore()
+    await store.fetchConsumers()
+
+    expect(store.error).toBe('boom')
+  })
+
+  it('does not surface an error on a 401 (the auth store owns that case)', async () => {
+    mockedAdminFetch.mockRejectedValue(new AdminApiError('unauthorized', 401))
+    const store = useConsumersStore()
+    await store.fetchConsumers()
+
+    expect(store.error).toBe('')
+  })
+
+  it('ensureConsumers fetches when there is no data yet', async () => {
+    mockedAdminFetch.mockResolvedValue(emptyConsumers)
+    const store = useConsumersStore()
+    await store.ensureConsumers()
+
+    expect(mockedAdminFetch).toHaveBeenCalledTimes(1)
+  })
+
+  it('ensureConsumers skips a second call while the first fetch is still fresh', async () => {
+    mockedAdminFetch.mockResolvedValue(emptyConsumers)
+    const store = useConsumersStore()
+    await store.ensureConsumers()
+    await store.ensureConsumers()
+
+    expect(mockedAdminFetch).toHaveBeenCalledTimes(1)
+  })
+
+  it('ensureConsumers re-fetches once the staleness window has passed', async () => {
+    vi.useFakeTimers()
+    try {
+      mockedAdminFetch.mockResolvedValue(emptyConsumers)
+      const store = useConsumersStore()
+      await store.ensureConsumers()
+
+      vi.advanceTimersByTime(60_001)
+      await store.ensureConsumers()
+
+      expect(mockedAdminFetch).toHaveBeenCalledTimes(2)
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+})
+
+describe('useConsumersStore.fetchUserDetail', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    mockedAdminFetch.mockReset()
+    useAuthStore().submit('test-admin-key')
+  })
+
+  it('fetches req and cost series for the given user, keyed by user id', async () => {
+    mockedAdminFetch.mockResolvedValue(emptySeries)
+    const store = useConsumersStore()
+    await store.fetchUserDetail('alice', 'day', 7, false)
+
+    const paths = mockedAdminFetch.mock.calls.map((c) => c[0] as string)
+    expect(paths.some((p) => p.includes('scope=user%3Aalice') && p.includes('metric=req'))).toBe(true)
+    expect(paths.some((p) => p.includes('scope=user%3Aalice') && p.includes('metric=cost'))).toBe(true)
+    expect(store.detail.alice.loading).toBe(false)
+    expect(store.detail.alice.error).toBe('')
+    expect(store.detail.alice.reqSeries).toEqual(emptySeries)
+    expect(store.detail.alice.costSeries).toEqual(emptySeries)
+  })
+
+  it('does not fetch usermodel totals when userModelStatsEnabled is false', async () => {
+    mockedAdminFetch.mockResolvedValue(emptySeries)
+    const store = useConsumersStore()
+    await store.fetchUserDetail('alice', 'day', 7, false)
+
+    const paths = mockedAdminFetch.mock.calls.map((c) => c[0] as string)
+    expect(paths.some((p) => p.includes('kind=usermodel'))).toBe(false)
+    expect(store.detail.alice.modelTotals).toBeNull()
+  })
+
+  it('fetches usermodel totals when userModelStatsEnabled is true', async () => {
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      if (path.includes('kind=usermodel')) return emptyTotals
+      return emptySeries
+    }) as typeof adminFetch)
+    const store = useConsumersStore()
+    await store.fetchUserDetail('alice', 'day', 7, true)
+
+    expect(store.detail.alice.modelTotals).toEqual(emptyTotals)
+  })
+
+  // P1 item 2: usermodel only accepts day/month (no hour bucket at all) —
+  // a bare `window=hour` 400s server-side BEFORE the 404-disabled-feature
+  // gate even runs. The previous spec matched adminFetch by path PREFIX
+  // only and never passed an hour-resolution window, so it never caught
+  // this. This test asserts the exact usermodel URL when the caller
+  // passes an hour window (the 24h/48h global ranges).
+  it('clamps an hour-resolution window to day/month (span 7) for the usermodel totals call, never window=hour', async () => {
+    let usermodelUrl = ''
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      if (path.includes('kind=usermodel')) {
+        usermodelUrl = path
+        return emptyTotals
+      }
+      return emptySeries
+    }) as typeof adminFetch)
+    const store = useConsumersStore()
+    await store.fetchUserDetail('alice', 'hour', 48, true)
+
+    expect(usermodelUrl).toBe('/admin/api/usage/totals?kind=usermodel&window=day&span=7&metrics=req%2Ccost&user=alice')
+  })
+
+  // P1 item 2: the req/cost series calls are UNCLAMPED — they legitimately
+  // accept any window (h/d/m), unlike usermodel. This pins that the fix
+  // above did not over-broadly clamp every call this action makes.
+  it('does NOT clamp the req/cost series calls — they pass the caller\'s window straight through', async () => {
+    const paths: string[] = []
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      paths.push(path)
+      if (path.includes('kind=usermodel')) return emptyTotals
+      return emptySeries
+    }) as typeof adminFetch)
+    const store = useConsumersStore()
+    await store.fetchUserDetail('alice', 'hour', 48, false)
+
+    const seriesUrls = paths.filter((p) => p.includes('/usage/series'))
+    expect(seriesUrls).toHaveLength(2)
+    for (const url of seriesUrls) expect(url).toContain('window=hour&span=48')
+  })
+
+  it('records a per-user error without clobbering a different user\'s already-loaded detail', async () => {
+    mockedAdminFetch.mockResolvedValue(emptySeries)
+    const store = useConsumersStore()
+    await store.fetchUserDetail('alice', 'day', 7, false)
+
+    mockedAdminFetch.mockRejectedValue(new Error('boom'))
+    await store.fetchUserDetail('bob', 'day', 7, false)
+
+    expect(store.detail.alice.error).toBe('')
+    expect(store.detail.alice.reqSeries).toEqual(emptySeries)
+    expect(store.detail.bob.error).toBe('boom')
+  })
+})
diff --git a/webui/src/stores/consumers.ts b/webui/src/stores/consumers.ts
new file mode 100644
index 0000000..45766da
--- /dev/null
+++ b/webui/src/stores/consumers.ts
@@ -0,0 +1,159 @@
+import { defineStore } from 'pinia'
+
+import { AdminApiError, adminFetch } from '@/lib/api'
+import { dayOrMonthWindow, seriesUrl, totalsUrl } from '@/lib/range'
+import { useAuthStore } from '@/stores/auth'
+import type { AdminConsumersResponse, AdminSeriesResponse, AdminTotalsResponse, HistoryWindow } from '@/types/api'
+
+/** REFRESH_STALE_MS is how long a previously-fetched /admin/api/consumers response is trusted before ConsumersPage.vue's mount triggers a fresh fetch — this endpoint reflects the operator's own config (users/groups/access lists), which changes on a config edit, not every 5s like the polled dashboard store. A 60s staleness window (matches Q12's "new endpoints on demand or 60s" DECISION) means switching between pages within the Consumers tab never re-fetches on every mount, while a long-open session still notices a config reload eventually. */
+const REFRESH_STALE_MS = 60_000
+
+/** UserDetailState is one user's on-demand detail — UserDetail.vue's own data (timeline series, per-model totals), fetched only when that user's row is actually opened, keyed by user id so switching between two already-opened users never re-fetches. */
+export interface UserDetailState {
+  loading: boolean
+  error: string
+  reqSeries: AdminSeriesResponse | null
+  costSeries: AdminSeriesResponse | null
+  /** null while userModelStats is off (no fetch attempted), the 404 case (see modelTotalsUnavailable), or before the first fetch resolves. */
+  modelTotals: AdminTotalsResponse | null
+  /** True once the usermodel totals call itself came back 404 (admin.go: disabled feature gate) — checked INDEPENDENTLY of the caller's own userModelStatsEnabled flag, since that flag reads the polled overview, which may not have loaded yet on a fresh deep link/reload, or may be stale relative to a live config change (see UserDetail.vue's own featuresUserModelStats watch). */
+  modelTotalsUnavailable: boolean
+  fetchedAt: number | null
+  /** reqId guards against an out-of-order response overwriting a newer one (latest-request-wins) — two ranges in flight for the same user can otherwise land out of order. */
+  reqId: number
+}
+
+function emptyDetail(): UserDetailState {
+  return {
+    loading: false,
+    error: '',
+    reqSeries: null,
+    costSeries: null,
+    modelTotals: null,
+    modelTotalsUnavailable: false,
+    fetchedAt: null,
+    reqId: 0,
+  }
+}
+
+/** settledError reads one Error message off a rejected PromiseSettledResult, or '' for a fulfilled one — fetchUserDetail's own small helper for building a combined error message out of whichever of its three independent requests failed. */
+function settledError(result: PromiseSettledResult<unknown>): string {
+  if (result.status !== 'rejected') return ''
+  return result.reason instanceof Error ? result.reason.message : String(result.reason)
+}
+
+/**
+ * useConsumersStore backs the Consumers page (redesign-plan.md section
+ * 3.3/3.4): the user/group directory + access lists from GET /admin/api/
+ * consumers (fetched on demand, not on the 5s dashboard poll — this data
+ * is config-shaped, not live traffic), plus each opened user's own detail
+ * (timeline series, usermodel totals) fetched lazily per user id.
+ */
+export const useConsumersStore = defineStore('consumers', {
+  state: () => ({
+    data: null as AdminConsumersResponse | null,
+    loading: false,
+    error: '',
+    fetchedAt: null as number | null,
+    detail: {} as Record<string, UserDetailState>,
+  }),
+  actions: {
+    /** fetchConsumers fetches GET /admin/api/consumers unconditionally — callers that want the staleness guard use ensureConsumers instead. */
+    async fetchConsumers(): Promise<void> {
+      const auth = useAuthStore()
+      if (!auth.isAuthenticated) return
+      this.loading = true
+      try {
+        this.data = await adminFetch<AdminConsumersResponse>('/admin/api/consumers')
+        this.error = ''
+        this.fetchedAt = Date.now()
+      } catch (err) {
+        if (err instanceof AdminApiError && (err.status === 401 || err.status === 403)) return
+        this.error = err instanceof Error ? err.message : String(err)
+      } finally {
+        this.loading = false
+      }
+    },
+    /** ensureConsumers fetches only when there is no data yet, or the last fetch is older than REFRESH_STALE_MS — ConsumersPage.vue's own onMounted call, so navigating back to the page within a minute does not re-fetch. */
+    async ensureConsumers(): Promise<void> {
+      if (this.loading) return
+      if (this.data && this.fetchedAt !== null && Date.now() - this.fetchedAt < REFRESH_STALE_MS) return
+      await this.fetchConsumers()
+    },
+    /**
+     * fetchUserDetail loads one user's timeline (req + cost series) and,
+     * only when `userModelStatsEnabled` is true (AdminFeaturesView.
+     * userModelStats — GET /admin/api/usage/totals?kind=usermodel 404s
+     * otherwise, admin.go), their per-model usermodel totals. Always
+     * re-fetches when called (UserDetail.vue calls this on mount and on
+     * every global range/span/features change) — the caller decides
+     * staleness, this action does not guess.
+     *
+     * The three requests run via Promise.allSettled, not Promise.all: a
+     * 400/404/503 on the usermodel call (or a transient failure on either
+     * series call) must never wipe out data from the OTHER two calls that
+     * did succeed — each field below keeps its previous value when its own
+     * request failed, rather than the whole detail view going blank over
+     * one failing endpoint (P1). The usermodel window/span is clamped to
+     * day/month (lib/range.ts's dayOrMonthWindow, shared with stores/
+     * spend.ts's drilldown and lib/target-columns.ts's targetcaller calls)
+     * — that endpoint has no hour bucket at all, so an hour-resolution
+     * global range (24h/48h) would otherwise 400 before the server's own
+     * 404-when-disabled feature gate even runs (stats_read.go).
+     */
+    async fetchUserDetail(userId: string, window: HistoryWindow, span: number, userModelStatsEnabled: boolean): Promise<void> {
+      const auth = useAuthStore()
+      if (!auth.isAuthenticated) return
+      const existing = this.detail[userId] ?? emptyDetail()
+      const requestId = existing.reqId + 1
+      this.detail[userId] = { ...existing, loading: true, reqId: requestId }
+
+      const clamped = dayOrMonthWindow(window, span)
+      const [reqResult, costResult, modelResult] = await Promise.allSettled([
+        adminFetch<AdminSeriesResponse>(seriesUrl({ scope: [`user:${userId}`], metric: 'req', window, span })),
+        adminFetch<AdminSeriesResponse>(seriesUrl({ scope: [`user:${userId}`], metric: 'cost', window, span })),
+        userModelStatsEnabled
+          ? adminFetch<AdminTotalsResponse>(
+              totalsUrl({ kind: 'usermodel', user: userId, window: clamped.window, span: clamped.span, metrics: ['req', 'cost'] }),
+            )
+          : Promise.resolve(null as AdminTotalsResponse | null),
+      ])
+
+      // A newer fetchUserDetail call for this same user already
+      // superseded this one (latest-request-wins) — drop this result.
+      if (this.detail[userId]?.reqId !== requestId) return
+
+      const authRejected = [reqResult, costResult, modelResult].some(
+        (r) => r.status === 'rejected' && r.reason instanceof AdminApiError && (r.reason.status === 401 || r.reason.status === 403),
+      )
+      if (authRejected) return
+
+      const modelTotalsUnavailable =
+        modelResult.status === 'rejected' && modelResult.reason instanceof AdminApiError && modelResult.reason.status === 404
+
+      const current = this.detail[userId] ?? emptyDetail()
+      // A 404 on the usermodel call is a known, EXPECTED state (the
+      // feature is off server-side) — surfaced via modelTotalsUnavailable
+      // instead, never folded into the generic error message. Deduped
+      // (Set) — the req and cost calls commonly fail with the IDENTICAL
+      // message (e.g. the same network error, or the same 503 "usage
+      // store unavailable"), and repeating it twice reads as noise, not
+      // two distinct problems.
+      const errorMessages = new Set(
+        [settledError(reqResult), settledError(costResult), modelTotalsUnavailable ? '' : settledError(modelResult)].filter(Boolean),
+      )
+      const combinedError = Array.from(errorMessages).join('; ')
+
+      this.detail[userId] = {
+        loading: false,
+        error: combinedError,
+        reqSeries: reqResult.status === 'fulfilled' ? reqResult.value : current.reqSeries,
+        costSeries: costResult.status === 'fulfilled' ? costResult.value : current.costSeries,
+        modelTotals: modelResult.status === 'fulfilled' ? modelResult.value : modelTotalsUnavailable ? null : current.modelTotals,
+        modelTotalsUnavailable,
+        fetchedAt: Date.now(),
+        reqId: requestId,
+      }
+    },
+  },
+})
diff --git a/webui/src/stores/dashboard.spec.ts b/webui/src/stores/dashboard.spec.ts
index 49d4330..339bba9 100644
--- a/webui/src/stores/dashboard.spec.ts
+++ b/webui/src/stores/dashboard.spec.ts
@@ -38,6 +38,8 @@ const emptyOverview: AdminOverviewResponse = {
   redis: { configured: false, lastErrAt: '0001-01-01T00:00:00Z' },
   cache: { enabled: false },
   retry: { enabled: false },
+  features: { userModelStats: false, latencyStats: false, cacheStats: false, lastSeen: false, failover: false },
+  pricing: { override: 0, builtin: 0, litellm: 0, free: 0, unpriced: 0 },
 }
 const emptyUsage: AdminUsageResponse = {
   users: [],
diff --git a/webui/src/stores/dashboard.ts b/webui/src/stores/dashboard.ts
index db2e80c..9df0968 100644
--- a/webui/src/stores/dashboard.ts
+++ b/webui/src/stores/dashboard.ts
@@ -10,13 +10,14 @@ const POLL_MS = 5000
 
 /**
  * useDashboardStore polls GET /admin/api/overview, GET /admin/api/usage,
- * and GET /admin/api/targets together every POLL_MS, feeding the
- * Providers, Usage, and MCP & Agents views (the store's own `overview`
- * field keeps the backend's name — see ProvidersView.vue's doc comment
- * for the UI-label/API-name split). A single store (not three) because
- * every route is always fetched together — the old vanilla-JS page's own
- * Promise.all([overview, usage]) pattern, extended to targets (Feature B,
- * v0.21) rather than given its own separate poll timer.
+ * and GET /admin/api/targets together every POLL_MS — the fleet-wide,
+ * always-current data every page in the redesigned shell reads from
+ * (Home's KPI tiles, ConsumerDirectory/UserDetail's own usage rows,
+ * ProviderHealthPanel's provider list, TargetsView's target list). A
+ * single store (not three) because every route is always fetched
+ * together — the old vanilla-JS page's own Promise.all([overview, usage])
+ * pattern, extended to targets (Feature B, v0.21) rather than given its
+ * own separate poll timer.
  */
 export const useDashboardStore = defineStore('dashboard', {
   state: () => ({
@@ -110,12 +111,14 @@ export const useDashboardStore = defineStore('dashboard', {
       this.poller = createVisibilityPoller({ intervalMs: POLL_MS, tick: () => void this.refresh() })
       this.poller.start()
     },
-    // P11 review fix: a stopPolling action mirroring history.ts/events.ts's
-    // own stop() used to live here too, but nothing outside its OWN spec
-    // ever called it — App.vue mounts this store's poller once, for the
-    // app's whole session, and never unmounts it (unlike history.ts/
-    // events.ts, whose stores are torn down when ChartsView/EventsView
-    // unmount). Dead application-facing API surface, removed; `poller`
-    // itself stays (startPolling's own idempotency guard still needs it).
+    // P11 review fix: a stopPolling action mirroring events.ts's own
+    // stop() used to live here too, but nothing outside its OWN spec ever
+    // called it — App.vue mounts this store's poller once, for the app's
+    // whole session, and never unmounts it (unlike events.ts, whose store
+    // IS torn down when EventsView unmounts — the same page-scoped
+    // pattern the pre-redesign Usage/Charts tabs' own now-deleted stores
+    // used to follow too). Dead application-facing API surface, removed;
+    // `poller` itself stays (startPolling's own idempotency guard still
+    // needs it).
   },
 })
diff --git a/webui/src/stores/events.spec.ts b/webui/src/stores/events.spec.ts
index 170d5b1..32e132c 100644
--- a/webui/src/stores/events.spec.ts
+++ b/webui/src/stores/events.spec.ts
@@ -195,3 +195,28 @@ describe('useEventsStore.startPolling / stopPolling', () => {
     }
   })
 })
+
+// initFromParams was removed (P2 item 10): ReliabilityPage.vue now keeps
+// kindFilter/userFilter synced with nav.params via its own reactive
+// `watch(() => [nav.params.kind, nav.params.user], ...)`, rather than a
+// one-shot mount-time seed — that watch's own doc comment covers why.
+
+describe('useEventsStore.setKindFilter / setUserFilter', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+  })
+
+  it('setKindFilter sets the exact-match kind filter, including back to the "" (every kind) sentinel', () => {
+    const events = useEventsStore()
+    events.setKindFilter('timeout')
+    expect(events.kindFilter).toBe('timeout')
+    events.setKindFilter('')
+    expect(events.kindFilter).toBe('')
+  })
+
+  it('setUserFilter sets the raw, un-normalized user/group search text', () => {
+    const events = useEventsStore()
+    events.setUserFilter('alice')
+    expect(events.userFilter).toBe('alice')
+  })
+})
diff --git a/webui/src/stores/events.ts b/webui/src/stores/events.ts
index 98d9364..5c3f090 100644
--- a/webui/src/stores/events.ts
+++ b/webui/src/stores/events.ts
@@ -12,11 +12,13 @@ const POLL_MS = 5000
 const EVENTS_LIMIT = 200
 
 /**
- * useEventsStore polls GET /admin/api/events?limit=200, feeding the new
- * Events tab (App.vue, F3). Unlike useDashboardStore, this store is
- * polled only while the Events view is mounted (EventsView.vue's own
- * onMounted/onUnmounted) rather than for the app's whole lifetime — an
- * operator who never opens the tab pays no extra request for it.
+ * useEventsStore polls GET /admin/api/events?limit=200, feeding
+ * EventsView.vue — the Reliability page's own embedded events section
+ * (redesign-plan.md section 3.4), and Home's own latest-8-events list.
+ * Unlike useDashboardStore, this store is polled only while a page that
+ * reads it is mounted (EventsView.vue's own onMounted/onUnmounted) rather
+ * than for the app's whole lifetime — an operator who never opens
+ * Reliability or Home pays no extra request for it.
  */
 export const useEventsStore = defineStore('events', {
   state: () => ({
@@ -32,20 +34,23 @@ export const useEventsStore = defineStore('events', {
     lastUpdated: null as Date | null,
     error: '',
     /**
-     * kindFilter/userFilter (F9, hash-state) — the Events view's own kind
-     * Select and user SearchInput. Lifted up here rather than kept as
-     * local refs in EventsView.vue, mirroring stores/nav.ts's own
-     * usageQuery doc comment: state that must survive a #<tab>?<query>
-     * hash round trip (composables/useHashState.ts, lib/hash-state.ts's
-     * parseEventsParams/kind,user) needs one canonical place to read from
-     * and write to, not a component-local ref useHashState cannot reach.
-     * kindFilter is an exact AdminEventKind string, or '' for "every
-     * kind" (EventsView.vue's own ALL_KINDS sentinel maps to/from this at
-     * the template boundary — see lib/events-filter.ts's own EventFilter
-     * shape, which this pairs with directly). userFilter is the raw,
-     * un-normalized search text; EventsView.vue binds it via
-     * useSearchQuery's external-ref option (composables/useSearchQuery.ts)
-     * the same way UsageView.vue binds nav.usageQuery.
+     * kindFilter/userFilter — the Events section's own kind Select and
+     * user SearchInput (redesign-plan.md section 3.4, EventsView.vue
+     * reused as a Reliability page section). Lifted up here rather than
+     * kept as local refs in EventsView.vue so ReliabilityPage.vue can
+     * keep them synced with nav.params (`kind`/`user`, section 3.1's
+     * Reliability page params) via its own reactive `watch(() =>
+     * [nav.params.kind, nav.params.user], ...)` — not just seeded once on
+     * mount (P2 item 10: a one-shot mount-time seed left a filter set on
+     * an earlier visit stuck in place across a remount with the param
+     * cleared, and never picked up a hash change, e.g. browser back/
+     * forward, while already mounted). kindFilter is an exact
+     * AdminEventKind string, or '' for "every kind" (EventsView.vue's own
+     * ALL_KINDS sentinel maps to/from this at the template boundary — see
+     * lib/events-filter.ts's own EventFilter shape, which this pairs with
+     * directly). userFilter is the raw, un-normalized search text;
+     * EventsView.vue binds it via useSearchQuery's external-ref option
+     * (composables/useSearchQuery.ts).
      */
     kindFilter: '',
     userFilter: '',
diff --git a/webui/src/stores/filters.spec.ts b/webui/src/stores/filters.spec.ts
new file mode 100644
index 0000000..42135cf
--- /dev/null
+++ b/webui/src/stores/filters.spec.ts
@@ -0,0 +1,71 @@
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import { useFiltersStore } from '@/stores/filters'
+
+beforeEach(() => {
+  setActivePinia(createPinia())
+})
+
+describe('useFiltersStore: defaults', () => {
+  it('defaults to range=7d, cmp=none, scope=all', () => {
+    const filters = useFiltersStore()
+    expect(filters.range).toBe('7d')
+    expect(filters.cmp).toBe('none')
+    expect(filters.scope).toBe('all')
+  })
+
+  it('derives window/span from the default range', () => {
+    const filters = useFiltersStore()
+    expect(filters.window).toBe('day')
+    expect(filters.span).toBe(7)
+  })
+})
+
+describe('useFiltersStore.setFilters', () => {
+  it('applies only the provided fields, leaving the rest untouched', () => {
+    const filters = useFiltersStore()
+    filters.setFilters({ range: '30d' })
+    expect(filters.range).toBe('30d')
+    expect(filters.cmp).toBe('none')
+    expect(filters.scope).toBe('all')
+  })
+
+  it('updates window/span when range changes', () => {
+    const filters = useFiltersStore()
+    filters.setFilters({ range: '12mo' })
+    expect(filters.window).toBe('month')
+    expect(filters.span).toBe(12)
+  })
+
+  it('applies range/cmp/scope together in one call', () => {
+    const filters = useFiltersStore()
+    filters.setFilters({ range: '14d', cmp: 'prev', scope: 'group:eng' })
+    expect(filters.range).toBe('14d')
+    expect(filters.cmp).toBe('prev')
+    expect(filters.scope).toBe('group:eng')
+  })
+})
+
+describe('useFiltersStore.cmpSpec', () => {
+  it('requested is false when cmp is none, even for a comparable range', () => {
+    const filters = useFiltersStore()
+    expect(filters.cmpSpec.requested).toBe(false)
+  })
+
+  it('requested is true when cmp is prev and the range supports it', () => {
+    const filters = useFiltersStore()
+    filters.setFilters({ cmp: 'prev' })
+    expect(filters.cmpSpec.available).toBe(true)
+    expect(filters.cmpSpec.requested).toBe(true)
+    expect(filters.cmpSpec.offset).toBe(7)
+  })
+
+  it('requested stays false when cmp is prev but the range does not support comparison', () => {
+    const filters = useFiltersStore()
+    filters.setFilters({ cmp: 'prev', range: '48h' })
+    expect(filters.cmpSpec.available).toBe(false)
+    expect(filters.cmpSpec.requested).toBe(false)
+    expect(filters.cmpSpec.reason).toBe('retention limit')
+  })
+})
diff --git a/webui/src/stores/filters.ts b/webui/src/stores/filters.ts
new file mode 100644
index 0000000..a98cd71
--- /dev/null
+++ b/webui/src/stores/filters.ts
@@ -0,0 +1,54 @@
+import { defineStore } from 'pinia'
+
+import { comparison, DEFAULT_CMP, DEFAULT_RANGE, RANGE_PRESETS } from '@/lib/range'
+import type { CmpMode, ComparisonResult, RangeKey } from '@/lib/range'
+import type { HistoryWindow } from '@/types/api'
+
+/** DEFAULT_SCOPE is the global filter bar's "no scope narrowing" value (redesign-plan.md section 3.1: `scope=all|group:x|user:x|provider:x`, default `all`). */
+export const DEFAULT_SCOPE = 'all'
+
+/**
+ * useFiltersStore holds the three GLOBAL filters every page reads from
+ * the address bar (redesign-plan.md section 3.1/3.3): the time range,
+ * whether to compare against the previous equal-length period, and an
+ * optional scope narrowing (a single group/user/provider, or 'all').
+ * Kept as one small store, not folded into stores/nav.ts, because these
+ * three are page-INDEPENDENT — every page's own store (spend, consumers,
+ * models, reliability) reads them the same way, unlike nav.ts's `params`,
+ * which are page-specific and opaque to this store.
+ */
+export const useFiltersStore = defineStore('filters', {
+  state: () => ({
+    range: DEFAULT_RANGE as RangeKey,
+    cmp: DEFAULT_CMP as CmpMode,
+    scope: DEFAULT_SCOPE,
+  }),
+  getters: {
+    /** window is the current range's bucket resolution (lib/range.ts's RANGE_PRESETS) — every page-store fetch reads this instead of re-deriving it from `range` itself. */
+    window: (state): HistoryWindow => RANGE_PRESETS[state.range].window,
+    /** span is the current range's bucket count. */
+    span: (state): number => RANGE_PRESETS[state.range].span,
+    /**
+     * cmpSpec folds `cmp` and lib/range.ts's comparison(range) into one
+     * read: `requested` is true only when the reader asked for a
+     * comparison (`cmp === 'prev'`) AND the current range actually
+     * supports one (comparison().available) — a page-store's fetch
+     * checks `requested` alone rather than re-deriving that AND itself
+     * every time, and a stale `cmp: 'prev'` left over from a range that
+     * DID support it survives a switch to one that does not without
+     * silently firing an invalid request.
+     */
+    cmpSpec: (state): ComparisonResult & { requested: boolean } => {
+      const result = comparison(state.range)
+      return { ...result, requested: state.cmp === 'prev' && result.available }
+    },
+  },
+  actions: {
+    /** setFilters applies any subset of range/cmp/scope in one call — omitted fields keep their current value, the same "apply a partial update, one atomic write" convention the pre-redesign stores/history.ts's own setSelection (deleted; this store replaces it) used, and stores/spend.ts's own setSelection still follows today. */
+    setFilters(next: { range?: RangeKey; cmp?: CmpMode; scope?: string }): void {
+      if (next.range !== undefined) this.range = next.range
+      if (next.cmp !== undefined) this.cmp = next.cmp
+      if (next.scope !== undefined) this.scope = next.scope
+    },
+  },
+})
diff --git a/webui/src/stores/history.spec.ts b/webui/src/stores/history.spec.ts
deleted file mode 100644
index 78bd3bf..0000000
--- a/webui/src/stores/history.spec.ts
+++ /dev/null
@@ -1,598 +0,0 @@
-// history.spec.ts covers useHistoryStore's model-ranking behaviour: the
-// Models tab reads a different endpoint from the other three tabs, and the
-// scope picker's model list is refreshed alongside whichever of the two is
-// active. Both must degrade independently — a failing picker list must
-// never blank a rendered chart or surface an error over it, which is the
-// asymmetry these tests pin.
-//
-// Same harness as dashboard.spec.ts: a Pinia store is plain reactive state
-// in the 'node' environment, with adminFetch (lib/api.ts) fully mocked, so
-// no real network or sessionStorage access happens.
-
-import { createPinia, setActivePinia } from 'pinia'
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-
-vi.mock('@/lib/api', async () => {
-  const actual = await vi.importActual<typeof import('@/lib/api')>('@/lib/api')
-  return { ...actual, adminFetch: vi.fn() }
-})
-
-import { adminFetch } from '@/lib/api'
-import { useAuthStore } from '@/stores/auth'
-import { metricsForTab, useHistoryStore } from '@/stores/history'
-import type { AdminUsageModelsResponse, UsageHistoryResponse } from '@/types/api'
-
-const mockedAdminFetch = vi.mocked(adminFetch)
-
-function modelsResponse(models: AdminUsageModelsResponse['models']): AdminUsageModelsResponse {
-  return { metric: 'cost', window: 'hour', span: 24, models }
-}
-function seriesResponse(): UsageHistoryResponse {
-  return { scope: 'total', metric: 'req', window: 'hour', points: [{ bucket: '2026082012', value: 5 }] }
-}
-
-/** Routes a mocked adminFetch call by URL, so tests assert on behaviour rather than call order. */
-function routeFetch(handlers: { models?: () => unknown; series?: () => unknown }): void {
-  mockedAdminFetch.mockImplementation((path: string) => {
-    if (path.startsWith('/admin/api/usage/models')) {
-      return Promise.resolve(handlers.models ? handlers.models() : modelsResponse([]))
-    }
-    return Promise.resolve(handlers.series ? handlers.series() : seriesResponse())
-  })
-}
-
-/** deferred exposes a promise's resolve function, so a test controls exactly when a mocked fetch "arrives" — the out-of-order-responses tests below depend on resolving the NEWER request before the OLDER one. */
-function deferred<T>(): { promise: Promise<T>; resolve: (value: T) => void } {
-  let resolve!: (value: T) => void
-  const promise = new Promise<T>((res) => {
-    resolve = res
-  })
-  return { promise, resolve }
-}
-
-/** flush drains the microtask queue — a setTimeout(0) macrotask fires only after every already-queued microtask (every chained .then/await) has run, which a plain `await Promise.resolve()` is not guaranteed to cover in one hop through fetchSeries' own multi-step await chain. */
-function flush(): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, 0))
-}
-
-describe('useHistoryStore model ranking', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    mockedAdminFetch.mockReset()
-    useAuthStore().submit('test-admin-key')
-  })
-
-  it('asks the history endpoint for no metric on the Models tab', () => {
-    // The Models tab reads the ranking endpoint instead, so requesting a
-    // history metric for it would be a wasted round trip per refresh.
-    expect(metricsForTab('models')).toEqual([])
-    expect(metricsForTab('tokens')).toEqual(['tokin', 'tokout'])
-  })
-
-  it('fetches the ranking, not a series, when the Models tab is active', async () => {
-    routeFetch({ models: () => modelsResponse([{ id: 'uni/qwen3.8-flash-next', value: 4_100_000 }]) })
-    const history = useHistoryStore()
-    history.tab = 'models'
-
-    await history.refresh()
-
-    expect(history.modelRanking).toEqual([{ id: 'uni/qwen3.8-flash-next', value: 4_100_000 }])
-    const paths = mockedAdminFetch.mock.calls.map((c) => String(c[0]))
-    expect(paths.some((p) => p.startsWith('/admin/api/usage/history'))).toBe(false)
-  })
-
-  // free-models-plan.md: a cost-default ranking hides every free model
-  // (its cost total is always 0) — the store now defaults to ranking by
-  // request count instead.
-  it('defaults modelMetric to "req", not "cost"', () => {
-    expect(useHistoryStore().modelMetric).toBe('req')
-  })
-
-  // free-models-plan.md: the ranking fetch always requests the per-model
-  // detail breakdown (requests/tokensIn/tokensOut/costMicroUsd/free), not
-  // just the single ranked `value` — lib/model-table-columns.ts's table
-  // renders every figure regardless of which metric is currently ranking.
-  it('always sends detail=1 on the ranking fetch, regardless of metric or prefix', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'models'
-    history.modelFilter = 'openai/'
-
-    await history.fetchModelRanking()
-
-    const rankingCall = mockedAdminFetch.mock.calls.map((c) => String(c[0])).find((p) => p.startsWith('/admin/api/usage/models'))
-    expect(rankingCall).toContain('detail=1')
-  })
-
-  // The scope picker's model list (fetchModelOptions) only ever needs ids
-  // — it must NOT pay for the detail breakdown the ranking fetch above
-  // does.
-  it('never sends detail=1 on the picker-list fetch', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-
-    await history.fetchModelOptions()
-
-    const optionsCall = mockedAdminFetch.mock.calls.map((c) => String(c[0])).find((p) => p.includes('/usage/models'))
-    expect(optionsCall).not.toContain('detail=1')
-  })
-
-  it('ranks by the selected metric, independently of the tab', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'models'
-
-    history.setModelMetric('tokin')
-    await history.refresh()
-
-    const rankingCall = mockedAdminFetch.mock.calls
-      .map((c) => String(c[0]))
-      .find((p) => p.startsWith('/admin/api/usage/models') && p.includes('metric=tokin'))
-    expect(rankingCall).toBeDefined()
-  })
-
-  // F2 (dashboard-plan.md): the ranking now sums the same WINDOW_SPAN
-  // buckets the time-series tabs chart, not just window's current bucket —
-  // WINDOW_LABEL ("24h"/"30d"/"12mo") is honest for the Models tab too.
-  it('asks the ranking endpoint for the window span, not just the current bucket', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'models'
-
-    await history.refresh()
-
-    const rankingCall = mockedAdminFetch.mock.calls
-      .map((c) => String(c[0]))
-      .find((p) => p.startsWith('/admin/api/usage/models'))
-    expect(rankingCall).toContain('span=24') // WINDOW_SPAN.hour, the default window
-  })
-
-  it('asks the picker list for requests, so a free model is still selectable', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-
-    await history.fetchModelOptions()
-
-    const optionsCall = mockedAdminFetch.mock.calls.map((c) => String(c[0])).find((p) => p.includes('/usage/models'))
-    expect(optionsCall).toContain('metric=req')
-    expect(optionsCall).toContain('span=24') // WINDOW_SPAN.hour, the default window
-  })
-
-  // Q1 (dashboard-plan.md DECISIONS, read-amplification review finding):
-  // fetchModelOptions is a real extra store read and must NOT repeat on
-  // every refresh() call — refresh() is what both the 30s auto-refresh
-  // tick and every setScope/setTab/setModelMetric change call.
-  it('never fetches the picker list from a plain refresh() call (Q1: read amplification)', async () => {
-    routeFetch({ series: () => seriesResponse() })
-    const history = useHistoryStore()
-
-    await history.refresh()
-
-    expect(history.seriesByMetric.req).toHaveLength(1)
-    expect(history.modelOptions).toEqual([])
-    const optionsCall = mockedAdminFetch.mock.calls.map((c) => String(c[0])).some((p) => p.includes('/usage/models'))
-    expect(optionsCall).toBe(false)
-  })
-
-  it('fetches the picker list on a window change, unlike a scope/tab/modelMetric change', async () => {
-    routeFetch({ models: () => modelsResponse([{ id: 'alpha/a-model-1', value: 3 }]) })
-    const history = useHistoryStore()
-
-    history.setWindow('day')
-    await flush()
-
-    expect(history.modelOptions).toEqual([{ id: 'alpha/a-model-1', value: 3 }])
-  })
-
-  it('swallows a picker-list failure without touching the chart error', async () => {
-    // Asserted directly on fetchModelOptions rather than through refresh:
-    // inside refresh a succeeding series fetch clears `error` afterwards
-    // anyway, which would let this pass even if the swallow were removed.
-    routeFetch({
-      models: () => {
-        throw new Error('models endpoint down')
-      },
-    })
-    const history = useHistoryStore()
-    history.error = 'pre-existing chart error'
-
-    await history.fetchModelOptions()
-
-    expect(history.error).toBe('pre-existing chart error')
-    expect(history.modelOptions).toEqual([])
-  })
-
-  // setWindow fires refresh() (series/ranking) and fetchModelOptions
-  // (picker list) in parallel (Q1's two trigger points) — one failing must
-  // never touch the other's own state.
-  it('keeps the freshly-fetched chart intact when the picker list fails on the same window change', async () => {
-    routeFetch({
-      series: () => seriesResponse(),
-      models: () => {
-        throw new Error('models endpoint down')
-      },
-    })
-    const history = useHistoryStore()
-
-    history.setWindow('day')
-    await flush()
-
-    expect(history.seriesByMetric.req).toHaveLength(1)
-    expect(history.error).toBe('')
-    expect(history.modelOptions).toEqual([])
-  })
-
-  it('surfaces a failing ranking fetch, unlike the picker list', async () => {
-    mockedAdminFetch.mockImplementation((path: string) => {
-      if (path.includes('limit=20')) return Promise.reject(new Error('ranking unavailable'))
-      return Promise.resolve(modelsResponse([]))
-    })
-    const history = useHistoryStore()
-    history.tab = 'models'
-
-    await history.refresh()
-
-    expect(history.error).toBe('ranking unavailable')
-  })
-})
-
-// F6 (dashboard-plan.md): modelFilter narrows the Models tab's ranking to a
-// provider/model prefix, set by ProvidersView.vue's provider-header link
-// (nav.goToModels) or a `#charts?tab=models&filter=...` hash param
-// (lib/hash-state.ts, composables/useHashState.ts). P3 review fix: while
-// the Models tab is active, setModelFilter ALSO sends the new prefix to
-// the server and refetches the ranking (fetchModelRanking's own doc
-// comment) — it is no longer a pure client-side re-slice. Setting it while
-// any OTHER tab is active stays fetch-free, since only the Models tab
-// reads modelFilter at all (ChartsView.vue).
-describe('useHistoryStore model filter (F6)', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    mockedAdminFetch.mockReset()
-    useAuthStore().submit('test-admin-key')
-  })
-
-  it('starts with no filter', () => {
-    expect(useHistoryStore().modelFilter).toBe('')
-  })
-
-  it('setModelFilter sets the prefix without fetching anything when not on the Models tab', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'requests' // explicit, not relying on the store's own default
-    const callsBefore = mockedAdminFetch.mock.calls.length
-
-    history.setModelFilter('openai/')
-    await flush()
-
-    expect(history.modelFilter).toBe('openai/')
-    expect(mockedAdminFetch.mock.calls.length).toBe(callsBefore)
-  })
-
-  it('setModelFilter refetches the ranking with the encoded prefix when the Models tab IS active', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'models'
-    const callsBefore = mockedAdminFetch.mock.calls.length
-
-    history.setModelFilter('openai/')
-    await flush()
-
-    expect(history.modelFilter).toBe('openai/')
-    expect(mockedAdminFetch.mock.calls.length).toBeGreaterThan(callsBefore)
-    const rankingCall = mockedAdminFetch.mock.calls.map((c) => String(c[0])).find((p) => p.startsWith('/admin/api/usage/models'))
-    expect(rankingCall).toContain(`prefix=${encodeURIComponent('openai/')}`)
-  })
-
-  it('setTab clears a previously-set modelFilter (a plain tab click must not carry a stale provider filter)', () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.setModelFilter('openai/')
-
-    history.setTab('tokens')
-
-    expect(history.modelFilter).toBe('')
-  })
-
-  it('setTab(models) also clears modelFilter — nav.goToModels relies on re-applying setModelFilter AFTER this', () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'requests'
-    history.setModelFilter('openai/')
-
-    history.setTab('models')
-
-    expect(history.modelFilter).toBe('')
-  })
-
-  it('setTab is a no-op (including on modelFilter) when the tab does not actually change', () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'models'
-    history.setModelFilter('openai/')
-
-    history.setTab('models') // already on 'models' — the early return must skip the clear too
-
-    expect(history.modelFilter).toBe('openai/')
-  })
-
-  // P3 review fix: the ranking fetch now sends the active prefix to the
-  // server (filtering BEFORE the limit is applied), instead of only ever
-  // re-slicing an already-fetched, unprefixed top-N client-side.
-  it('sends &prefix=<encoded filter> on the ranking fetch when modelFilter is set', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'models'
-    history.modelFilter = 'openai/'
-
-    await history.fetchModelRanking()
-
-    const rankingCall = mockedAdminFetch.mock.calls.map((c) => String(c[0])).find((p) => p.startsWith('/admin/api/usage/models'))
-    expect(rankingCall).toContain(`prefix=${encodeURIComponent('openai/')}`)
-  })
-
-  it('omits the prefix param entirely when modelFilter is empty', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'models'
-
-    await history.fetchModelRanking()
-
-    const rankingCall = mockedAdminFetch.mock.calls.map((c) => String(c[0])).find((p) => p.startsWith('/admin/api/usage/models'))
-    expect(rankingCall).not.toContain('prefix=')
-  })
-
-  // P3 review fix: setModelFilter now refetches too, but ONLY while the
-  // Models tab is active — a stale (unprefixed, or differently-prefixed)
-  // already-fetched ranking must not linger once the filter changes, since
-  // the server-side prefix now genuinely changes what that fetch returns.
-  it('setModelFilter refetches the ranking when the Models tab is active and the prefix actually changes', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'models'
-    const callsBefore = mockedAdminFetch.mock.calls.length
-
-    history.setModelFilter('openai/')
-    await flush()
-
-    expect(mockedAdminFetch.mock.calls.length).toBeGreaterThan(callsBefore)
-    const rankingCall = mockedAdminFetch.mock.calls.map((c) => String(c[0])).find((p) => p.startsWith('/admin/api/usage/models'))
-    expect(rankingCall).toContain(`prefix=${encodeURIComponent('openai/')}`)
-  })
-
-  it('setModelFilter does NOT refetch when the value is unchanged (early return)', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'models'
-    history.setModelFilter('openai/')
-    await flush()
-    const callsBefore = mockedAdminFetch.mock.calls.length
-
-    history.setModelFilter('openai/') // same value again
-
-    expect(mockedAdminFetch.mock.calls.length).toBe(callsBefore)
-  })
-})
-
-// Review findings 1/2/9: out-of-order responses must never overwrite a
-// newer selection, stale data must never render under the new selection's
-// labels, and `loading` must only ever be cleared by the request that is
-// still current.
-describe('useHistoryStore: latest-request-wins', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    mockedAdminFetch.mockReset()
-    useAuthStore().submit('test-admin-key')
-  })
-
-  it('drops a fetchSeries response that resolves late, after a newer scope already superseded it', async () => {
-    const alice = deferred<UsageHistoryResponse>()
-    const ops = deferred<UsageHistoryResponse>()
-    mockedAdminFetch.mockImplementation((path: string) => {
-      if (path.includes('scope=user%3Aalice')) return alice.promise
-      if (path.includes('scope=group%3Aops')) return ops.promise
-      return Promise.resolve(modelsResponse([])) // fetchModelOptions' own parallel call
-    })
-    const history = useHistoryStore()
-
-    history.setScope('user:alice') // slow — resolves LAST, below
-    history.setScope('group:ops') // fast — resolves FIRST, below; must win regardless
-
-    ops.resolve({ scope: 'group:ops', metric: 'req', window: 'hour', points: [{ bucket: '2026082012', value: 42 }] })
-    await flush()
-    alice.resolve({ scope: 'user:alice', metric: 'req', window: 'hour', points: [{ bucket: '2026082012', value: 999 }] })
-    await flush()
-
-    // The stale alice response must never land, however late it arrives.
-    expect(history.seriesByMetric.req).toEqual([{ bucket: '2026082012', value: 42 }])
-    expect(history.scope).toBe('group:ops')
-  })
-
-  it('never re-sets `loading` to true after the CURRENT request has already cleared it (a stale request resolving late)', async () => {
-    const alice = deferred<UsageHistoryResponse>()
-    const ops = deferred<UsageHistoryResponse>()
-    mockedAdminFetch.mockImplementation((path: string) => {
-      if (path.includes('scope=user%3Aalice')) return alice.promise
-      if (path.includes('scope=group%3Aops')) return ops.promise
-      return Promise.resolve(modelsResponse([]))
-    })
-    const history = useHistoryStore()
-
-    history.setScope('user:alice')
-    history.setScope('group:ops')
-
-    ops.resolve({ scope: 'group:ops', metric: 'req', window: 'hour', points: [] })
-    await flush()
-    expect(history.loading).toBe(false) // the current request has already settled
-
-    alice.resolve({ scope: 'user:alice', metric: 'req', window: 'hour', points: [] })
-    await flush()
-    expect(history.loading).toBe(false) // the stale request settling later must not flip it back on
-  })
-
-  it('clears seriesByMetric synchronously on a window change, before the new fetch resolves — no stale bucket renders under the new window\'s labels', () => {
-    routeFetch({ series: () => seriesResponse() })
-    const history = useHistoryStore()
-    history.seriesByMetric = { req: [{ bucket: '2026082012', value: 5 }] }
-
-    history.setWindow('day')
-
-    expect(history.seriesByMetric).toEqual({})
-  })
-
-  it('clears modelRanking synchronously on a model-metric change, before the new fetch resolves', () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    history.tab = 'models'
-    history.modelRanking = [{ id: 'alpha/a-model-1', value: 3 }]
-
-    // 'cost', not 'req' — the store now DEFAULTS to 'req' (free-models-
-    // plan.md), so setModelMetric('req') here would be a no-op early
-    // return rather than the actual change this test means to exercise.
-    history.setModelMetric('cost')
-
-    expect(history.modelRanking).toEqual([])
-  })
-
-  it('does not clear seriesByMetric on an auto-refresh tick (same selection) — only a selection CHANGE clears it', async () => {
-    routeFetch({ series: () => seriesResponse() })
-    const history = useHistoryStore()
-    await history.refresh()
-    expect(history.seriesByMetric.req).toHaveLength(1)
-
-    await history.refresh() // same scope/window/tab — the 30s auto-refresh's own call shape
-
-    expect(history.seriesByMetric.req).toHaveLength(1)
-  })
-
-  it('marks the selection loaded after its first fetch and keeps it loaded across refreshes, clearing it only on a selection change', async () => {
-    routeFetch({ series: () => seriesResponse() })
-    const history = useHistoryStore()
-    expect(history.loaded).toBe(false)
-    await history.refresh()
-    expect(history.loaded).toBe(true)
-
-    await history.refresh()
-    expect(history.loaded).toBe(true)
-
-    history.setWindow('day')
-    expect(history.loaded).toBe(false)
-  })
-
-  it('the 30s auto-refresh tick (startAutoRefresh) never re-fetches the picker list — only refresh() itself (Q1)', async () => {
-    vi.useFakeTimers()
-    try {
-      routeFetch({ series: () => seriesResponse() })
-      const history = useHistoryStore()
-
-      history.startAutoRefresh() // ticks once immediately, then every REFRESH_MS (lib/polling.ts)
-      await vi.advanceTimersByTimeAsync(0)
-      await vi.advanceTimersByTimeAsync(90_000) // three more ticks
-      await vi.advanceTimersByTimeAsync(0)
-
-      expect(history.modelOptions).toEqual([])
-      const optionsCall = mockedAdminFetch.mock.calls.map((c) => String(c[0])).some((p) => p.includes('/usage/models'))
-      expect(optionsCall).toBe(false)
-      history.stopAutoRefresh()
-    } finally {
-      vi.useRealTimers()
-    }
-  })
-
-  it('auto-refresh tick skips while a fetch is still in flight, so a slow request is never superseded by the timer', async () => {
-    vi.useFakeTimers()
-    try {
-      const slow = deferred<UsageHistoryResponse>()
-      mockedAdminFetch.mockImplementation((path: string) =>
-        path.startsWith('/admin/api/usage/models') ? Promise.resolve(modelsResponse([])) : slow.promise,
-      )
-      const history = useHistoryStore()
-      void history.refresh()
-      const callsBefore = mockedAdminFetch.mock.calls.length
-      history.startAutoRefresh()
-      await vi.advanceTimersByTimeAsync(90_000)
-      expect(mockedAdminFetch.mock.calls.length).toBe(callsBefore)
-
-      slow.resolve(seriesResponse())
-      await vi.advanceTimersByTimeAsync(0)
-      expect(history.seriesByMetric.req).toHaveLength(1)
-      history.stopAutoRefresh()
-    } finally {
-      vi.useRealTimers()
-    }
-  })
-})
-// P12 review fix: restoring a Charts hash with several params set at once
-// (composables/useHashState.ts's applyFromHash) or clicking through via
-// nav.ts's goToCharts/goToModels used to call several of the single-field
-// setters above back to back, each independently clearing state and
-// firing its OWN refresh() (and, for a window change, fetchModelOptions()
-// too) — every fetch but the last immediately superseded and discarded.
-// setSelection batches the whole change into ONE refresh() call.
-describe('useHistoryStore.setSelection (P12: batched, one fetch)', () => {
-  beforeEach(() => {
-    setActivePinia(createPinia())
-    mockedAdminFetch.mockReset()
-    useAuthStore().submit('test-admin-key')
-  })
-
-  it('applying scope+window+tab+modelMetric together fires exactly one series fetch (plus one picker-list fetch for the window change) — not one per field', async () => {
-    routeFetch({ series: () => seriesResponse() })
-    const history = useHistoryStore()
-
-    // tab stays at its default ('requests', metricsForTab -> 1 metric), so
-    // the "one series fetch" below is a single adminFetch call, not the
-    // 2-call 'tokens' case — isolating the batching behavior itself from
-    // metricsForTab's own separate multi-metric fan-out.
-    history.setSelection({ scope: 'user:alice', window: 'day', tab: 'requests', modelMetric: 'req' })
-    await flush()
-
-    expect(history.scope).toBe('user:alice')
-    expect(history.window).toBe('day')
-    expect(history.modelMetric).toBe('req')
-    const calls = mockedAdminFetch.mock.calls.map((c) => String(c[0]))
-    const seriesCalls = calls.filter((p) => p.startsWith('/admin/api/usage/history'))
-    const optionsCalls = calls.filter((p) => p.startsWith('/admin/api/usage/models'))
-    expect(seriesCalls).toHaveLength(1) // one series fetch, not the 3-4 the old per-field setters would have fired
-    expect(optionsCalls).toHaveLength(1) // fetchModelOptions, fired once for the window change
-  })
-
-  it('does nothing (no state change, no fetch) when every field already matches the current selection', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-    const callsBefore = mockedAdminFetch.mock.calls.length
-
-    history.setSelection({ scope: 'total', window: 'hour', tab: 'requests', modelMetric: 'req' }) // all defaults
-    await flush()
-
-    expect(mockedAdminFetch.mock.calls.length).toBe(callsBefore)
-  })
-
-  it('applies modelFilter AFTER tab resets it — setSelection({ tab: "models", modelFilter: prefix }) lands on the intended prefix (nav.ts goToModels\' own call shape)', async () => {
-    routeFetch({})
-    const history = useHistoryStore()
-
-    history.setSelection({ tab: 'models', modelFilter: 'openai/' })
-    await flush()
-
-    expect(history.tab).toBe('models')
-    expect(history.modelFilter).toBe('openai/')
-    const rankingCall = mockedAdminFetch.mock.calls.map((c) => String(c[0])).find((p) => p.startsWith('/admin/api/usage/models'))
-    expect(rankingCall).toContain(`prefix=${encodeURIComponent('openai/')}`)
-    // Only ONE ranking fetch — not a first unprefixed one from the tab
-    // switch followed by a second, corrective one from the filter.
-    const rankingCalls = mockedAdminFetch.mock.calls.map((c) => String(c[0])).filter((p) => p.startsWith('/admin/api/usage/models'))
-    expect(rankingCalls).toHaveLength(1)
-  })
-
-  it('only fetchModelOptions is skipped when window is not part of the call, even though other fields change', async () => {
-    routeFetch({ series: () => seriesResponse() })
-    const history = useHistoryStore()
-
-    history.setSelection({ scope: 'user:alice' })
-    await flush()
-
-    const optionsCalls = mockedAdminFetch.mock.calls.map((c) => String(c[0])).filter((p) => p.startsWith('/admin/api/usage/models'))
-    expect(optionsCalls).toHaveLength(0)
-  })
-})
diff --git a/webui/src/stores/history.ts b/webui/src/stores/history.ts
deleted file mode 100644
index 48539cc..0000000
--- a/webui/src/stores/history.ts
+++ /dev/null
@@ -1,483 +0,0 @@
-import { defineStore } from 'pinia'
-
-import { AdminApiError, adminFetch } from '@/lib/api'
-import { createVisibilityPoller, type VisibilityPoller } from '@/lib/polling'
-import { useAuthStore } from '@/stores/auth'
-import type {
-  AdminUsageModelEntry,
-  AdminUsageModelsResponse,
-  HistoryMetric,
-  HistoryWindow,
-  UsageHistoryPoint,
-  UsageHistoryResponse,
-} from '@/types/api'
-
-/**
- * The chart tabs the Charts view offers. The first three are metrics over
- * time (see metricsForTab below); "models" is the odd one out — a ranking
- * across models for a single point in time, with its own metric picked
- * separately (modelMetric below), because "which model" is the dimension
- * that tab varies rather than the metric.
- */
-export type ChartTab = 'requests' | 'tokens' | 'cost' | 'models'
-
-/**
- * The tabs that render a time series — every ChartTab except the ranking.
- * UsageChart is typed on this rather than on ChartTab so that adding
- * another ranking-style tab is a compile error there, not a chart with a
- * silently missing dataset spec.
- */
-export type TimeSeriesTab = Exclude<ChartTab, 'models'>
-
-/**
- * The metrics the Models ranking can rank by. Deliberately a single
- * metric, unlike the stacked "tokens" time-series tab: a bar's LENGTH in a
- * ranking is the comparison being made, so splitting it across two stacked
- * series would make two models with different in/out mixes visually
- * incomparable.
- */
-export type ModelMetric = 'req' | 'tokin' | 'tokout' | 'cost'
-
-/** MODEL_METRIC_LABEL is the ranking metric picker's display text. */
-export const MODEL_METRIC_LABEL: Record<ModelMetric, string> = {
-  cost: 'Cost',
-  req: 'Requests',
-  tokin: 'Tokens in',
-  tokout: 'Tokens out',
-}
-
-/**
- * How many ranked models the Models tab requests. Matches the server's own
- * default (admin.go: usageModelsDefaultLimit) and stays well under its max.
- * Exported (P3 review fix) so ChartsView.vue can show a "Top N models"
- * note whenever the fetched ranking is exactly this long — the reader must
- * be told the list is a truncated top-N, not the complete set, the same
- * signal the on-screen search/filter affordances elsewhere in this panel
- * already give for a narrowed-but-possibly-incomplete list.
- */
-export const MODEL_RANKING_LIMIT = 20
-
-/**
- * How many models the SCOPE PICKER offers. Higher than the ranking's own
- * limit — the picker is a lookup, not a top-N — and capped at the server's
- * maximum (admin.go: usageModelsMaxLimit).
- */
-const MODEL_OPTIONS_LIMIT = 100
-
-/**
- * How often the current selection refetches while the Charts view is open.
- * Slower than the dashboard's 5s poll (dashboard.ts) — history buckets
- * change on the timescale of the window itself, not every request.
- */
-const REFRESH_MS = 30_000
-
-/**
- * WINDOW_SPAN is the bucket count requested per window: 24h at hour
- * resolution, 30d at day resolution, 12mo at month resolution. Each stays
- * within historyMaxSpan's own per-window ceiling (admin.go: 48/35/13), so
- * every request is valid without the UI needing to know that ceiling.
- */
-export const WINDOW_SPAN: Record<HistoryWindow, number> = {
-  hour: 24,
-  day: 30,
-  month: 12,
-}
-
-/**
- * WINDOW_LABEL is the window-switcher's own display text — a real span of
- * buckets, matching WINDOW_SPAN above, for EVERY tab including Models: the
- * ranking endpoint now sums the same WINDOW_SPAN buckets the time-series
- * tabs chart (F2 review fix), rather than reading modelTotals' old
- * single-current-bucket behaviour, so "24h"/"30d"/"12mo" is accurate for
- * it too and this is the one label every tab shares — no separate
- * MODEL_WINDOW_LABEL needed any more.
- */
-export const WINDOW_LABEL: Record<HistoryWindow, string> = {
-  hour: '24h',
-  day: '30d',
-  month: '12mo',
-}
-
-/**
- * metricsForTab maps a chart tab to the metric(s) it needs. "tokens" is the
- * one tab needing two: GET /admin/api/usage/history takes a single metric
- * per call (tokin XOR tokout), and the Charts view stacks both into one bar
- * chart (operator brief: "STACKED tokens-in vs tokens-out").
- */
-export function metricsForTab(tab: ChartTab): HistoryMetric[] {
-  switch (tab) {
-    case 'requests':
-      return ['req']
-    case 'tokens':
-      return ['tokin', 'tokout']
-    case 'cost':
-      return ['cost']
-    case 'models':
-      // The Models tab reads the ranking endpoint, not the history one —
-      // it needs no time series, so it asks for no metric here.
-      return []
-  }
-}
-
-/**
- * useHistoryStore drives the Charts view: current scope/window/tab
- * selection, the fetched series for whatever metric(s) that selection
- * needs, and a 30s auto-refresh of the current selection. Changing scope,
- * window, or tab always triggers an immediate refetch (operator brief:
- * "history fetch on selection + 30s refresh").
- */
-export const useHistoryStore = defineStore('history', {
-  state: () => ({
-    /** "total" | "user:{id}" | "group:{id}" — the raw scope query value serveAdminUsageHistory expects. */
-    scope: 'total',
-    window: 'hour' as HistoryWindow,
-    tab: 'requests' as ChartTab,
-    /**
-     * Which metric the Models ranking ranks by — independent of `tab`.
-     * Defaults to 'req' (free-models-plan.md), not 'cost': a cost-default
-     * ranking silently hides every free model (its cost total is always
-     * 0), and the picker/table both need free models to be reachable
-     * without the reader first knowing to switch metrics.
-     */
-    modelMetric: 'req' as ModelMetric,
-    seriesByMetric: {} as Partial<Record<HistoryMetric, UsageHistoryPoint[]>>,
-    /** The current Models-tab ranking. Empty means "nothing used in this window". */
-    modelRanking: [] as AdminUsageModelEntry[],
-    /** Models with non-zero traffic, for the scope picker's model entries. */
-    modelOptions: [] as AdminUsageModelEntry[],
-    /**
-     * modelFilter narrows the Models tab's ranking to ids starting with
-     * this prefix (F6, dashboard-plan.md). P3 review fix: while the
-     * Models tab is active, this is now also a SERVER query param —
-     * setModelFilter sends it to /admin/api/usage/models as `prefix`
-     * (fetchModelRanking's own doc comment) and refetches, since
-     * filtering must happen before the server applies its top-N limit.
-     * lib/model-filter.ts's filterModelsByPrefix still re-slices the
-     * result client-side too (ChartsView.vue), a harmless no-op pass once
-     * the server has already narrowed the set. Set by ProvidersView.vue's
-     * provider-header link (nav.goToModels(`${p.name}/`), stores/nav.ts —
-     * WP-B1) so "view this provider's models" lands on a pre-filtered
-     * ranking instead of the reader hunting for it themselves, and it
-     * round-trips through the `#charts?tab=models&filter=` hash param
-     * (lib/hash-state.ts, composables/useHashState.ts) so a reload or a
-     * shared link restores it too. Empty string means no filter.
-     */
-    modelFilter: '',
-    loading: false,
-    /** True once the current selection's first fetch committed; cleared by the setters. Drives the "Loading…" line so background refreshes don't flash it over rendered data. */
-    loaded: false,
-    error: '',
-    poller: undefined as VisibilityPoller | undefined,
-    /**
-     * seriesReqId guards fetchSeries and fetchModelRanking against
-     * out-of-order responses (review finding: "latest-request-wins"). The
-     * two are mutually exclusive per refresh() call (exactly one runs,
-     * picked by `tab`), so ONE shared counter is enough — a fetch started
-     * by an OLDER selection (scope/window/tab/modelMetric) always loses to
-     * whichever fetch started most recently, never to load order. Each
-     * fetch captures the id it was issued under before its own await, then
-     * only commits its result (and clears `loading`) if that id is still
-     * the current one when it resolves.
-     */
-    seriesReqId: 0,
-    /** optionsReqId is fetchModelOptions' own independent counter (a background, parallel fetch — see that action's own doc comment for why it never touches `loading`/`error`). */
-    optionsReqId: 0,
-  }),
-  actions: {
-    setScope(scope: string): void {
-      if (scope === this.scope) return
-      this.scope = scope
-      // Clear the OLD selection's series before fetching the new one (review
-      // finding: stale data must never render under the new selection's
-      // labels) — done in the setter, not inside refresh()/fetchSeries(),
-      // so the 30s auto-refresh timer (same selection, no setter involved)
-      // does not blank the chart on every tick.
-      this.seriesByMetric = {}
-      this.error = ''
-      this.loaded = false
-      void this.refresh()
-    },
-    setWindow(window: HistoryWindow): void {
-      if (window === this.window) return
-      this.window = window
-      // Window changes the time-series bucket resolution, the Models
-      // ranking's own span, AND the picker's model list (Q1,
-      // dashboard-plan.md DECISIONS: fetchModelOptions runs only on a
-      // window change or initial load, never on the 30s auto-refresh tick)
-      // — clear/refetch all three.
-      this.seriesByMetric = {}
-      this.modelRanking = []
-      this.error = ''
-      this.loaded = false
-      void this.refresh()
-      void this.fetchModelOptions()
-    },
-    setTab(tab: ChartTab): void {
-      if (tab === this.tab) return
-      this.tab = tab
-      this.seriesByMetric = {}
-      this.modelRanking = []
-      // A stale provider-prefix filter from an earlier nav.goToModels visit
-      // must not silently carry into a plain "Models" tab click — F6's
-      // nav.goToModels always re-applies its own setModelFilter call right
-      // after this one, so clearing here unconditionally never fights it.
-      this.modelFilter = ''
-      this.error = ''
-      this.loaded = false
-      void this.refresh()
-    },
-    /**
-     * setModelFilter narrows the Models tab's ranking to ids starting with
-     * `prefix`.
-     *
-     * P3 review fix: this used to be a PURE client-side re-slice of
-     * already-fetched data, never a refetch (modelFilter's own state doc
-     * comment above still describes the re-slice half, lib/model-filter.ts's
-     * filterModelsByPrefix). Now that fetchModelRanking also sends `prefix`
-     * to the SERVER (see that action's own doc comment), the already-fetched
-     * ranking can be stale relative to a NEW prefix — it may have been
-     * fetched under the old prefix (or no prefix at all), so simply
-     * re-slicing it client-side no longer reflects what the server would
-     * return for the new one. Refetching only when the Models tab is
-     * actually active (the only tab that reads modelFilter at all — see
-     * filterModelsByPrefix's own call site, ChartsView.vue) keeps this a
-     * no-op fetch-wise everywhere else, and the early return on an
-     * unchanged value keeps repeated identical calls (or nav.goToModels
-     * re-applying the same prefix) from firing a redundant fetch.
-     */
-    setModelFilter(prefix: string): void {
-      if (prefix === this.modelFilter) return
-      this.modelFilter = prefix
-      if (this.tab !== 'models') return
-      this.modelRanking = []
-      this.error = ''
-      this.loaded = false
-      void this.refresh()
-    },
-    /**
-     * setSelection (P12 review fix) applies scope/window/tab/modelMetric/
-     * modelFilter as ONE atomic change, instead of the caller invoking
-     * several of the single-field setters above back to back. Each of
-     * those setters independently clears state and calls refresh() (and,
-     * for window, fetchModelOptions() too) — restoring a Charts hash with
-     * several params set at once (composables/useHashState.ts's
-     * applyFromHash) or nav.ts's goToCharts/goToModels used to call three
-     * or four of them in a row, firing that many fetches, every one but
-     * the LAST immediately discarded by seriesReqId's own
-     * latest-request-wins guard (stores/history.ts state doc comment) —
-     * wasted round trips against a Redis-backed endpoint for a result that
-     * was never going to render. setSelection instead applies every
-     * provided field directly, clears the derived state ONCE, and fires
-     * exactly one refresh() (plus one fetchModelOptions() only when
-     * `window` is part of this call) once every field has been applied.
-     *
-     * Field application order matters for one case: `tab` resets
-     * `modelFilter` to '' first (mirroring setTab's own "a stale
-     * provider-prefix filter must not silently carry into a plain tab
-     * switch" convention), and only THEN does this function's own
-     * `modelFilter` field (if provided in the SAME call) apply the real
-     * value — so `setSelection({ tab: 'models', modelFilter: prefix })`
-     * (nav.ts's goToModels) lands on the intended prefix, not '' followed
-     * by a second, separate fetch to correct it.
-     */
-    setSelection(next: {
-      scope?: string
-      window?: HistoryWindow
-      tab?: ChartTab
-      modelMetric?: ModelMetric
-      modelFilter?: string
-    }): void {
-      let changed = false
-      let windowChanged = false
-      if (next.window !== undefined && next.window !== this.window) {
-        this.window = next.window
-        changed = true
-        windowChanged = true
-      }
-      if (next.tab !== undefined && next.tab !== this.tab) {
-        this.tab = next.tab
-        this.modelFilter = ''
-        changed = true
-      }
-      if (next.scope !== undefined && next.scope !== this.scope) {
-        this.scope = next.scope
-        changed = true
-      }
-      if (next.modelMetric !== undefined && next.modelMetric !== this.modelMetric) {
-        this.modelMetric = next.modelMetric
-        changed = true
-      }
-      if (next.modelFilter !== undefined && next.modelFilter !== this.modelFilter) {
-        this.modelFilter = next.modelFilter
-        changed = true
-      }
-      if (!changed) return
-      this.seriesByMetric = {}
-      this.modelRanking = []
-      this.error = ''
-      this.loaded = false
-      void this.refresh()
-      if (windowChanged) void this.fetchModelOptions()
-    },
-    setModelMetric(metric: ModelMetric): void {
-      if (metric === this.modelMetric) return
-      this.modelMetric = metric
-      this.modelRanking = []
-      this.error = ''
-      this.loaded = false
-      void this.refresh()
-    },
-    /**
-     * refresh fetches whatever the CURRENT selection needs: the ranking on
-     * the Models tab, a time series otherwise. It deliberately does NOT
-     * also refresh the scope picker's model list any more (Q1,
-     * dashboard-plan.md DECISIONS — folded from a review finding on read
-     * amplification): fetchModelOptions is a real extra store read
-     * (modelSpanTotals, admin.go), and this action is what the 30s
-     * auto-refresh timer calls every tick — repeating that read every
-     * cycle bought the picker nothing a reader would ever notice. See
-     * fetchModelOptions' own doc comment for its two actual call sites.
-     */
-    async refresh(): Promise<void> {
-      await (this.tab === 'models' ? this.fetchModelRanking() : this.fetchSeries())
-    },
-    async fetchSeries(): Promise<void> {
-      const auth = useAuthStore()
-      if (!auth.isAuthenticated) return
-      const requestId = ++this.seriesReqId
-      this.loading = true
-      try {
-        const span = WINDOW_SPAN[this.window]
-        const metrics = metricsForTab(this.tab)
-        const results = await Promise.all(
-          metrics.map((metric) =>
-            adminFetch<UsageHistoryResponse>(
-              `/admin/api/usage/history?scope=${encodeURIComponent(this.scope)}&metric=${metric}&window=${this.window}&span=${span}`,
-            ),
-          ),
-        )
-        // Stale: a newer selection (or the models-tab fetch) already
-        // superseded this one — drop the result rather than overwriting
-        // whatever the current selection has since fetched or cleared.
-        if (requestId !== this.seriesReqId) return
-        const next: Partial<Record<HistoryMetric, UsageHistoryPoint[]>> = {}
-        metrics.forEach((metric, i) => {
-          next[metric] = results[i]!.points
-        })
-        this.seriesByMetric = next
-        this.loaded = true
-        this.error = ''
-      } catch (err) {
-        if (requestId !== this.seriesReqId) return
-        if (err instanceof AdminApiError && (err.status === 401 || err.status === 403)) {
-          return
-        }
-        this.error = err instanceof Error ? err.message : String(err)
-      } finally {
-        // Only the still-current request clears `loading` — an older,
-        // already-superseded fetch settling later must not flip it back to
-        // false while the newer one it lost to is still in flight.
-        if (requestId === this.seriesReqId) this.loading = false
-      }
-    },
-    async fetchModelRanking(): Promise<void> {
-      const auth = useAuthStore()
-      if (!auth.isAuthenticated) return
-      const requestId = ++this.seriesReqId
-      this.loading = true
-      try {
-        const span = WINDOW_SPAN[this.window]
-        // P3 review fix: when a provider-prefix filter is active
-        // (modelFilter, set by ProvidersView.vue's provider-header link via
-        // nav.goToModels), send it to the server so filtering happens
-        // BEFORE the limit is applied — the client-side filterModelsByPrefix
-        // pass in ChartsView.vue stays too, as a harmless second pass (it
-        // is a no-op once the server has already narrowed the set), but
-        // without this the server's own fleet-wide top-N could omit a
-        // provider's models entirely, or return only a partial view of them
-        // (the CONFIRMED problem this fixes).
-        const prefixParam = this.modelFilter ? `&prefix=${encodeURIComponent(this.modelFilter)}` : ''
-        // detail=1 (free-models-plan.md): the Models tab's own ranking
-        // fetch always asks for the per-entry requests/tokensIn/tokensOut/
-        // costMicroUsd/free breakdown, not just the single ranked `value` —
-        // lib/model-table-columns.ts's table renders all four figures
-        // (plus the free badge) beside every row regardless of which
-        // metric is currently ranking. fetchModelOptions below stays
-        // detail-free: the scope picker only ever needs an id list.
-        const res = await adminFetch<AdminUsageModelsResponse>(
-          `/admin/api/usage/models?metric=${this.modelMetric}&window=${this.window}&limit=${MODEL_RANKING_LIMIT}&span=${span}${prefixParam}&detail=1`,
-        )
-        if (requestId !== this.seriesReqId) return
-        this.modelRanking = res.models
-        this.loaded = true
-        this.error = ''
-      } catch (err) {
-        if (requestId !== this.seriesReqId) return
-        if (err instanceof AdminApiError && (err.status === 401 || err.status === 403)) {
-          return
-        }
-        this.error = err instanceof Error ? err.message : String(err)
-      } finally {
-        if (requestId === this.seriesReqId) this.loading = false
-      }
-    },
-    /**
-     * fetchModelOptions loads the picker's model list: models with at least
-     * one REQUEST across the current window's span. Requests, not the
-     * ranking's own metric, deliberately — a model can serve traffic while
-     * reporting no tokens and costing nothing, and such a model must still
-     * be selectable. A failure here is swallowed rather than surfaced: it
-     * degrades the picker, and must not replace a rendered chart's own
-     * error (or clear it).
-     *
-     * Called only on initial load and on a window change (Q1,
-     * dashboard-plan.md DECISIONS) — never from refresh() itself, so the
-     * 30s auto-refresh tick pays for the ranking/series alone. See
-     * setWindow above and ChartsView.vue's onMounted for the two call
-     * sites.
-     */
-    async fetchModelOptions(): Promise<void> {
-      const auth = useAuthStore()
-      if (!auth.isAuthenticated) return
-      const requestId = ++this.optionsReqId
-      try {
-        const span = WINDOW_SPAN[this.window]
-        const res = await adminFetch<AdminUsageModelsResponse>(
-          `/admin/api/usage/models?metric=req&window=${this.window}&limit=${MODEL_OPTIONS_LIMIT}&span=${span}`,
-        )
-        // Stale: a later window change already fired its own picker-list
-        // fetch — never let an older window's model list overwrite it.
-        if (requestId !== this.optionsReqId) return
-        this.modelOptions = res.models
-      } catch {
-        // Intentionally ignored — see the doc comment above.
-      }
-    },
-    /**
-     * startAutoRefresh drives refresh() through the shared
-     * createVisibilityPoller (lib/polling.ts, F5) instead of a bare
-     * setInterval: it ticks once immediately (the selection's initial
-     * fetch — see ChartsView.vue's onMounted, which no longer calls
-     * refresh() itself), then every REFRESH_MS while the tab is visible,
-     * pausing while it is hidden and catching up the moment it is looked
-     * at again. The in-flight skip is unchanged from before this move: a
-     * tick bumps seriesReqId on every real fetch, so an unconditional tick
-     * would supersede (and discard) any request slower than REFRESH_MS,
-     * forever.
-     */
-    startAutoRefresh(): void {
-      if (this.poller) return
-      this.poller = createVisibilityPoller({
-        intervalMs: REFRESH_MS,
-        tick: () => {
-          if (!this.loading) void this.refresh()
-        },
-      })
-      this.poller.start()
-    },
-    stopAutoRefresh(): void {
-      this.poller?.stop()
-      this.poller = undefined
-    },
-  },
-})
diff --git a/webui/src/stores/models.spec.ts b/webui/src/stores/models.spec.ts
new file mode 100644
index 0000000..b139df5
--- /dev/null
+++ b/webui/src/stores/models.spec.ts
@@ -0,0 +1,196 @@
+// models.spec.ts covers useModelsStore.fetch's catalog-store integration
+// (useCatalogStore.ensureLoaded, then join via lib/model-table-columns.ts's
+// buildModelCatalogRows) — same mocked-adminFetch, Pinia-under-vitest
+// harness as dashboard.spec.ts/reliability.spec.ts.
+
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/lib/api', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/api')>('@/lib/api')
+  return { ...actual, adminFetch: vi.fn() }
+})
+
+import { adminFetch } from '@/lib/api'
+import { useAuthStore } from '@/stores/auth'
+import { useCatalogStore } from '@/stores/catalog'
+import { useModelsStore } from '@/stores/models'
+import type { AdminCatalogResponse, AdminPerfResponse, AdminUsageModelsResponse } from '@/types/api'
+
+const mockedAdminFetch = vi.mocked(adminFetch)
+
+const catalogResponse: AdminCatalogResponse = {
+  providers: [
+    {
+      lastRefresh: '2026-01-01T00:00:00Z',
+      openUntil: '0001-01-01T00:00:00Z',
+      name: 'openai',
+      type: 'openai',
+      healthState: 'closed',
+      discoveryEnabled: true,
+      models: [{ id: 'openai/gpt-5', model: 'gpt-5', priceSource: 'builtin', inputPerMTokUsd: 1, outputPerMTokUsd: 2 }],
+    },
+  ],
+  aliases: [],
+}
+
+const rankingResponse: AdminUsageModelsResponse = {
+  metric: 'cost',
+  window: 'day',
+  span: 7,
+  offset: 0,
+  detail: true,
+  models: [{ id: 'openai/gpt-5', value: 1, requests: 5, tokensIn: 50, tokensOut: 60, costMicroUsd: 100 }],
+}
+
+const perfResponse: AdminPerfResponse = {
+  kind: 'model',
+  window: 'day',
+  span: 7,
+  offset: 0,
+  latencyEnabled: true,
+  rows: [{ id: 'openai/gpt-5', p50Ms: 100, p95Ms: 300, count: 5, attempts: 5, failures: 0 }],
+}
+
+const providerPerfResponse: AdminPerfResponse = {
+  kind: 'provider',
+  window: 'day',
+  span: 7,
+  offset: 0,
+  latencyEnabled: true,
+  rows: [{ id: 'openai', p50Ms: 90, p95Ms: 250, count: 20, attempts: 20, failures: 1, timeouts: 0, failovers: 2 }],
+}
+
+function mockPerformance(path: string): AdminPerfResponse {
+  return path.includes('kind=provider') ? providerPerfResponse : perfResponse
+}
+
+describe('useModelsStore.fetch', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    mockedAdminFetch.mockReset()
+    useAuthStore().submit('test-admin-key')
+  })
+
+  it('ensures the catalog store is loaded, then joins ranking + performance onto it, plus provider performance', async () => {
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      if (path === '/admin/api/catalog') return catalogResponse
+      if (path.startsWith('/admin/api/usage/models')) return rankingResponse
+      if (path.startsWith('/admin/api/performance')) return mockPerformance(path)
+      throw new Error(`unexpected path ${path}`)
+    }) as typeof adminFetch)
+
+    const models = useModelsStore()
+    await models.fetch()
+
+    expect(models.rows).toHaveLength(1)
+    expect(models.rows[0]).toMatchObject({ id: 'openai/gpt-5', requests: 5, p50Ms: 100, attempts: 5 })
+    expect(models.providerPerf).toEqual(providerPerfResponse.rows)
+    expect(models.perfWindow).toEqual({ window: 'day', span: 7 })
+    expect(models.latencyEnabled).toBe(true)
+    expect(models.lastUpdated).not.toBeNull()
+    expect(models.error).toBe('')
+  })
+
+  // P1 item 1: the ranking fetch used to omit `metric` entirely, which
+  // admin.go's validHistoryMetric rejects as a 400 "unknown metric" — the
+  // previous version of this spec matched adminFetch by path PREFIX only
+  // (`path.startsWith('/admin/api/usage/models')`), which is why it never
+  // caught a missing/wrong query parameter. This test asserts the exact
+  // URL string.
+  it('requests the ranking with metric=req (not omitted, not the Spend page\'s own metric)', async () => {
+    let rankingUrl = ''
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      if (path === '/admin/api/catalog') return catalogResponse
+      if (path.startsWith('/admin/api/usage/models')) {
+        rankingUrl = path
+        return rankingResponse
+      }
+      if (path.startsWith('/admin/api/performance')) return mockPerformance(path)
+      throw new Error(`unexpected path ${path}`)
+    }) as typeof adminFetch)
+
+    const models = useModelsStore()
+    await models.fetch()
+
+    expect(rankingUrl).toBe('/admin/api/usage/models?window=day&span=7&limit=100&detail=1&metric=req')
+  })
+
+  it('reuses an already-loaded, still-fresh catalog store without re-fetching /admin/api/catalog', async () => {
+    const catalog = useCatalogStore()
+    catalog.data = catalogResponse
+    catalog.fetchedAt = new Date()
+
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      if (path.startsWith('/admin/api/usage/models')) return rankingResponse
+      if (path.startsWith('/admin/api/performance')) return perfResponse
+      throw new Error(`unexpected path ${path}`)
+    }) as typeof adminFetch)
+
+    const models = useModelsStore()
+    await models.fetch()
+
+    expect(mockedAdminFetch).not.toHaveBeenCalledWith('/admin/api/catalog')
+    expect(models.rows).toHaveLength(1)
+  })
+
+  it('records an error and leaves rows empty when the catalog itself fails to load', async () => {
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      if (path === '/admin/api/catalog') throw new Error('catalog boom')
+      throw new Error(`unexpected path ${path}`)
+    }) as typeof adminFetch)
+
+    const models = useModelsStore()
+    await models.fetch()
+
+    expect(models.rows).toEqual([])
+    expect(models.error).toContain('catalog boom')
+  })
+
+  // P2 item 6: fetch() used to have an `if (this.loading) return` guard,
+  // which silently dropped a fetch() call started during a range change
+  // mid-flight (a reader on Models who changes the range twice quickly
+  // saw the SECOND range change simply do nothing). The replacement is
+  // latest-request-wins (reqId), matching stores/catalog.ts's own
+  // convention — this test exercises the actual property that matters: a
+  // SLOWER, earlier fetch() resolving AFTER a faster, later one must
+  // never overwrite the later (more current) result with stale data.
+  it('discards a slower first fetch() result once a newer fetch() has already resolved (latest-request-wins)', async () => {
+    const staleRanking: AdminUsageModelsResponse = {
+      ...rankingResponse,
+      models: [{ ...rankingResponse.models[0], id: 'openai/stale-model' }],
+    }
+    let resolveFirstRanking: ((v: AdminUsageModelsResponse) => void) | undefined
+    let rankingCallCount = 0
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      if (path === '/admin/api/catalog') return catalogResponse
+      if (path.startsWith('/admin/api/usage/models')) {
+        rankingCallCount += 1
+        // The FIRST fetch()'s own ranking call hangs until the test
+        // resolves it by hand, below — the SECOND (and any later)
+        // ranking call resolves immediately, so `second` finishes well
+        // before `first` does.
+        if (rankingCallCount === 1) return new Promise<AdminUsageModelsResponse>((resolve) => (resolveFirstRanking = resolve))
+        return rankingResponse
+      }
+      if (path.startsWith('/admin/api/performance')) return mockPerformance(path)
+      throw new Error(`unexpected path ${path}`)
+    }) as typeof adminFetch)
+
+    const models = useModelsStore()
+    const first = models.fetch()
+    await vi.waitFor(() => {
+      if (!resolveFirstRanking) throw new Error('first ranking request not issued yet')
+    })
+    const second = models.fetch()
+    await second
+    expect(models.rows[0]?.id).toBe('openai/gpt-5')
+
+    // `first` finally resolves, with STALE data — it must be discarded,
+    // not overwrite the already-current `second` result.
+    resolveFirstRanking?.(staleRanking)
+    await first
+    expect(models.rows[0]?.id).toBe('openai/gpt-5')
+    expect(models.loading).toBe(false)
+  })
+})
diff --git a/webui/src/stores/models.ts b/webui/src/stores/models.ts
new file mode 100644
index 0000000..9ad8f92
--- /dev/null
+++ b/webui/src/stores/models.ts
@@ -0,0 +1,83 @@
+import { defineStore } from 'pinia'
+
+import { AdminApiError, adminFetch } from '@/lib/api'
+import { buildModelCatalogRows } from '@/lib/model-table-columns'
+import type { ModelCatalogRow } from '@/lib/model-table-columns'
+import { useCatalogStore } from '@/stores/catalog'
+import { useFiltersStore } from '@/stores/filters'
+import { hourOrDayWindow } from '@/stores/reliability'
+import type { AdminPerfResponse, AdminPerfRow, AdminUsageModelsResponse, HistoryWindow } from '@/types/api'
+
+/**
+ * useModelsStore fetches the Models page's own catalog table (redesign-
+ * plan.md section 3.3/3.4) — on demand, not part of the 5s dashboard poll
+ * (Q12 DECISIONS), refetched on mount and whenever the global range
+ * changes. Joins three independent responses via lib/model-table-columns.
+ * ts's buildModelCatalogRows: the catalog (useCatalogStore, WP-D — shared
+ * 5-minute-stale cache, so navigating here after Spend already paid this
+ * read costs nothing extra), the current range's usage ranking
+ * (`detail=1`, up to the server's own 100-row cap), and fleet performance
+ * (`kind=model`, server default: top 50 by req in span).
+ *
+ * Ranking accepts any HistoryWindow (hour/day/month — redesign-plan.md
+ * section 1.3.iv's metric x kind table, model scope), but performance does
+ * not (PerfWindow is hour/day only, types/api.ts) — reuses
+ * stores/reliability.ts's own hourOrDayWindow clamp for the performance
+ * request only, leaving the ranking request on the global filters window
+ * unclamped.
+ */
+export const useModelsStore = defineStore('models', {
+  state: () => ({
+    rows: [] as ModelCatalogRow[],
+    /** GET /admin/api/performance?kind=provider's own rows (fleet p50/p95, attempts/failures, timeouts, failovers per provider) — ProviderHealthPanel.vue's own doc comment. Keyed by provider name at read time, not here, so this store stays a plain array like `rows` above. */
+    providerPerf: [] as AdminPerfRow[],
+    /** The hour/day window + span hourOrDayWindow actually resolved for both performance requests — ProviderHealthPanel.vue's badge titles read this rather than filters.window/span directly whenever a month-range clamp was applied. */
+    perfWindow: { window: 'day' as Extract<HistoryWindow, 'hour' | 'day'>, span: 0 },
+    /** GET /admin/api/performance's own latencyEnabled (AdminPerfResponse) — shared by BOTH the model and provider performance requests below (the same admin.stats.latency toggle gates both), surfaced so ModelCatalogTable.vue/ProviderHealthPanel.vue can hint at it rather than silently showing every row's p50/p95 as "—". */
+    latencyEnabled: false,
+    loading: false,
+    lastUpdated: null as Date | null,
+    error: '',
+    /** reqId guards against an out-of-order response overwriting a newer one (latest-request-wins, stores/catalog.ts's own convention) — a range change mid-flight no longer gets silently dropped by an `if (this.loading) return` guard. */
+    reqId: 0,
+  }),
+  actions: {
+    async fetch(): Promise<void> {
+      const requestId = ++this.reqId
+      this.loading = true
+      try {
+        const catalog = useCatalogStore()
+        const filters = useFiltersStore()
+        await catalog.ensureLoaded()
+        if (requestId !== this.reqId) return
+        if (!catalog.data) {
+          this.error = catalog.error || 'catalog unavailable'
+          return
+        }
+
+        const perfWindow = hourOrDayWindow(filters.window, filters.span)
+        const [rankingRes, perfRes, providerPerfRes] = await Promise.all([
+          adminFetch<AdminUsageModelsResponse>(
+            `/admin/api/usage/models?window=${filters.window}&span=${filters.span}&limit=100&detail=1&metric=req`,
+          ),
+          adminFetch<AdminPerfResponse>(`/admin/api/performance?kind=model&window=${perfWindow.window}&span=${perfWindow.span}`),
+          adminFetch<AdminPerfResponse>(`/admin/api/performance?kind=provider&window=${perfWindow.window}&span=${perfWindow.span}`),
+        ])
+        if (requestId !== this.reqId) return
+
+        this.rows = buildModelCatalogRows(catalog.data, rankingRes, perfRes)
+        this.providerPerf = providerPerfRes.rows ?? []
+        this.perfWindow = perfWindow
+        this.latencyEnabled = perfRes.latencyEnabled
+        this.lastUpdated = new Date()
+        this.error = ''
+      } catch (err) {
+        if (requestId !== this.reqId) return
+        if (err instanceof AdminApiError && (err.status === 401 || err.status === 403)) return
+        this.error = err instanceof Error ? err.message : String(err)
+      } finally {
+        if (requestId === this.reqId) this.loading = false
+      }
+    },
+  },
+})
diff --git a/webui/src/stores/nav.spec.ts b/webui/src/stores/nav.spec.ts
index 489a85b..c8b8d17 100644
--- a/webui/src/stores/nav.spec.ts
+++ b/webui/src/stores/nav.spec.ts
@@ -1,16 +1,6 @@
-// nav.spec.ts covers useNavStore's two navigation actions (F6). Real
-// Pinia + real useHistoryStore, no mocking needed: useAuthStore.
-// isAuthenticated defaults to false in this 'node' test environment (no
-// sessionStorage — key-storage.ts's own try/catch guard), so history.ts's
-// setScope/setTab/setModelFilter run their synchronous state updates and
-// their own fire-and-forget refresh()/fetchSeries() short-circuits
-// immediately at its own `if (!auth.isAuthenticated) return` guard,
-// exactly like dashboard.spec.ts's own precedent (see that file's header
-// comment).
 import { createPinia, setActivePinia } from 'pinia'
 import { beforeEach, describe, expect, it } from 'vitest'
 
-import { useHistoryStore } from '@/stores/history'
 import { useNavStore } from '@/stores/nav'
 
 beforeEach(() => {
@@ -18,69 +8,41 @@ beforeEach(() => {
 })
 
 describe('useNavStore: initial state', () => {
-  it('defaults activeTab to "providers" and usageQuery to empty', () => {
+  it('defaults page to "home" and params to an empty record', () => {
     const nav = useNavStore()
-    expect(nav.activeTab).toBe('providers')
-    expect(nav.usageQuery).toBe('')
+    expect(nav.page).toBe('home')
+    expect(nav.params).toEqual({})
   })
 })
 
-describe('useNavStore.goToCharts', () => {
-  it('sets the history scope and switches activeTab to "charts"', () => {
+describe('useNavStore.goTo', () => {
+  it('sets page and params together', () => {
     const nav = useNavStore()
-    const history = useHistoryStore()
-    nav.goToCharts('user:alice')
-    expect(history.scope).toBe('user:alice')
-    expect(nav.activeTab).toBe('charts')
+    nav.goTo('consumers', { user: 'alice' })
+    expect(nav.page).toBe('consumers')
+    expect(nav.params).toEqual({ user: 'alice' })
   })
 
-  it('accepts every scope prefix history.ts recognizes', () => {
+  it('defaults params to an empty record when omitted', () => {
     const nav = useNavStore()
-    const history = useHistoryStore()
-    for (const scope of ['total', 'user:alice', 'group:eng', 'model:openai/gpt-4']) {
-      nav.goToCharts(scope)
-      expect(history.scope).toBe(scope)
+    nav.goTo('models', { model: 'openai/gpt-5' })
+    nav.goTo('spend')
+    expect(nav.page).toBe('spend')
+    expect(nav.params).toEqual({})
+  })
+
+  it('replaces, never merges, the previous page\'s params', () => {
+    const nav = useNavStore()
+    nav.goTo('consumers', { user: 'alice', view: 'directory' })
+    nav.goTo('consumers', { view: 'matrix' })
+    expect(nav.params).toEqual({ view: 'matrix' })
+  })
+
+  it('accepts every page id', () => {
+    const nav = useNavStore()
+    for (const page of ['home', 'spend', 'consumers', 'models', 'reliability', 'config', 'targets'] as const) {
+      nav.goTo(page)
+      expect(nav.page).toBe(page)
     }
   })
-
-  it('switches the Charts tab back to "requests" first when it was showing "models" (no scope picker there)', () => {
-    const nav = useNavStore()
-    const history = useHistoryStore()
-    history.setTab('models')
-    nav.goToCharts('group:eng')
-    expect(history.tab).toBe('requests')
-    expect(history.scope).toBe('group:eng')
-  })
-
-  it('leaves a non-models tab untouched', () => {
-    const nav = useNavStore()
-    const history = useHistoryStore()
-    history.setTab('cost')
-    nav.goToCharts('total')
-    expect(history.tab).toBe('cost')
-  })
-})
-
-describe('useNavStore.goToModels', () => {
-  it('switches to the Models tab, applies the prefix filter, and switches activeTab to "charts"', () => {
-    const nav = useNavStore()
-    const history = useHistoryStore()
-    nav.goToModels('openai/')
-    expect(history.tab).toBe('models')
-    expect(history.modelFilter).toBe('openai/')
-    expect(nav.activeTab).toBe('charts')
-  })
-
-  it('applies the filter AFTER switching tabs, so setTab\'s own modelFilter reset never wins the race', () => {
-    const nav = useNavStore()
-    const history = useHistoryStore()
-    // Already on the Models tab with a stale filter from an earlier visit —
-    // setTab('models') is a no-op (tab === this.tab guard, history.ts) and
-    // so does NOT reset modelFilter on its own; goToModels's own explicit
-    // setModelFilter call is what must still land the new prefix.
-    history.setTab('models')
-    history.setModelFilter('stale/')
-    nav.goToModels('anthropic/')
-    expect(history.modelFilter).toBe('anthropic/')
-  })
 })
diff --git a/webui/src/stores/nav.ts b/webui/src/stores/nav.ts
index e9215d2..412b444 100644
--- a/webui/src/stores/nav.ts
+++ b/webui/src/stores/nav.ts
@@ -1,78 +1,42 @@
 import { defineStore } from 'pinia'
 
-import type { TabValue } from '@/composables/useTabHash'
-import { useHistoryStore } from '@/stores/history'
+import { DEFAULT_PAGE } from '@/lib/pages'
+import type { PageId } from '@/lib/pages'
 
 /**
- * useNavStore (F6) is the one place cross-tab "jump to Charts, pointed at
- * X" navigation lives: every ScopeLink.vue click (usage-columns.ts's id
- * cell, the Groups accordion trigger here, and WP-B2's ProvidersView.vue
- * per-model links) and the Providers tab's own per-provider header link
- * call one of the two actions below, instead of each call site poking
- * history.ts's scope/tab state AND App.vue's own active-tab separately.
+ * useNavStore is the redesign's single navigation store (redesign-plan.md
+ * section 3.3, replacing the old activeTab/usageQuery shape): which page
+ * is showing, and that page's own query params, as an opaque string
+ * record. "Opaque" is deliberate — nav.ts itself never interprets a
+ * param's meaning (a Spend page's `by`/`metric`/`ref`/`drill`, a
+ * Consumers page's `q`/`view`/`user`, ...); each page (and its own store,
+ * owned by that page's work package) reads `params` itself. This keeps
+ * nav.ts, and the shell that wraps it (App.vue, SidebarNav.vue,
+ * composables/useHashState.ts), free of any per-page knowledge — adding a
+ * new page-specific param never touches this file.
  *
- * `activeTab` is typed with TabValue, the SAME union App.vue's Tabs
- * v-model already binds to (composables/useTabHash.ts) — WP-B2 extends
- * that union with 'events' (F3); this store picks the extension up for
- * free with no edit here, since it imports the type rather than
- * redeclaring its own copy (vue.md: "share types once, import
- * everywhere").
+ * Global filters (time range, comparison, scope) are NOT part of
+ * `params` — those live in stores/filters.ts, page-independent by
+ * design (every page reads the same three).
  */
 export const useNavStore = defineStore('nav', {
   state: () => ({
-    activeTab: 'providers' as TabValue,
-    /**
-     * usageQuery is the Usage tab's own search box value (F9's
-     * useSearchQuery(external), WP-B2 — composables/useSearchQuery.ts
-     * gains an optional external ref so UsageView.vue can bind this
-     * instead of owning a local ref), lifted up here rather than kept
-     * local to that component so it survives a navigation away from and
-     * back to the Usage tab, and so #<tab>?q=... hash state (F9,
-     * lib/hash-state.ts) has one canonical place to read/write it from.
-     */
-    usageQuery: '',
+    page: DEFAULT_PAGE as PageId,
+    params: {} as Record<string, string>,
   }),
   actions: {
     /**
-     * goToCharts switches to the Charts tab with `scope` selected —
-     * "total" | "user:{id}" | "group:{id}" | "model:{id}" (history.ts's
-     * own scope string convention, unchanged here). If the Charts view is
-     * currently showing the Models ranking — which has no scope picker at
-     * all (ChartsView.vue's own template branch) — it is switched back to
-     * the Requests tab FIRST, so the newly-set scope is immediately
-     * visible rather than silently inert behind the ranking view.
-     *
-     * P12 review fix: both fields are applied through ONE
-     * history.setSelection() call rather than two separate setTab()/
-     * setScope() calls — each of THOSE independently fires its own
-     * refresh(), so switching off the Models tab AND changing scope in the
-     * same click used to fire two fetches back to back, the first always
-     * discarded (seriesReqId's own latest-request-wins guard) the instant
-     * the second landed.
+     * goTo navigates to `page` with `params` as that page's complete
+     * param set (not merged with whatever the previous page's params
+     * were — a page's own params are meaningless once you've left it).
+     * Every EntityLink.vue click, SidebarNav.vue link, and TopList.vue
+     * row calls this instead of poking `page`/`params` separately, so a
+     * single click is always one atomic state change (and, downstream,
+     * one hash rewrite — composables/useHashState.ts's own watcher).
      */
-    goToCharts(scope: string): void {
-      const history = useHistoryStore()
-      history.setSelection(history.tab === 'models' ? { tab: 'requests', scope } : { scope })
-      this.activeTab = 'charts'
-    },
-    /**
-     * goToModels switches to the Charts tab's Models ranking, pre-filtered
-     * to `prefix` (ProvidersView.vue's per-provider header link passes
-     * `${provider.name}/`) — history.ts's own modelFilter/setModelFilter
-     * (WP-B2, F6 charts+providers side).
-     *
-     * P12 review fix: `tab` and `modelFilter` are applied through ONE
-     * history.setSelection() call — setSelection's own field-ordering
-     * (tab's own modelFilter reset happens BEFORE this call's `modelFilter`
-     * field is applied, see its doc comment) preserves the exact ordering
-     * this used to need two separate calls for (setTab('models') resetting
-     * modelFilter, THEN setModelFilter(prefix) applying the real value),
-     * while firing exactly one ranking fetch instead of one per call.
-     */
-    goToModels(prefix: string): void {
-      const history = useHistoryStore()
-      history.setSelection({ tab: 'models', modelFilter: prefix })
-      this.activeTab = 'charts'
+    goTo(page: PageId, params: Record<string, string> = {}): void {
+      this.page = page
+      this.params = params
     },
   },
 })
diff --git a/webui/src/stores/reliability.spec.ts b/webui/src/stores/reliability.spec.ts
new file mode 100644
index 0000000..cb0192f
--- /dev/null
+++ b/webui/src/stores/reliability.spec.ts
@@ -0,0 +1,352 @@
+// reliability.spec.ts covers the pure helpers (hourOrDayWindow,
+// errorRateSeries, seriesColor) directly, plus useReliabilityStore.fetch's
+// provider-scope-list-from-dashboard-overview wiring and its zero-providers
+// short-circuit — mirroring dashboard.spec.ts's own mocked-adminFetch,
+// Pinia-under-vitest approach (that file's own doc comment).
+
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/lib/api', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/api')>('@/lib/api')
+  return { ...actual, adminFetch: vi.fn() }
+})
+
+import { adminFetch } from '@/lib/api'
+import { errorRateSeries, hourOrDayWindow, RELIABILITY_SERIES_COLORS, seriesColor, useReliabilityStore } from '@/stores/reliability'
+import { useAuthStore } from '@/stores/auth'
+import { useDashboardStore } from '@/stores/dashboard'
+import type { AdminOverviewResponse, AdminPerfResponse, AdminPerfRow, AdminSeriesResponse } from '@/types/api'
+
+const mockedAdminFetch = vi.mocked(adminFetch)
+
+describe('hourOrDayWindow', () => {
+  it('passes an hour window through unchanged, with its own span', () => {
+    expect(hourOrDayWindow('hour', 48)).toEqual({ window: 'hour', span: 48 })
+  })
+
+  it('passes a day window through unchanged, with its own span', () => {
+    expect(hourOrDayWindow('day', 14)).toEqual({ window: 'day', span: 14 })
+  })
+
+  it('clamps a month window (no hour/day equivalent span) to a fixed 30-day window', () => {
+    expect(hourOrDayWindow('month', 6)).toEqual({ window: 'day', span: 30 })
+  })
+})
+
+describe('errorRateSeries', () => {
+  function series(entries: { scope: string; points: number[] }[]): AdminSeriesResponse {
+    return { metric: 'x', window: 'hour', span: entries[0]?.points.length ?? 0, offset: 0, buckets: [], series: entries, unknown: [] }
+  }
+
+  it('divides fail by attempt per bucket for a matching scope', () => {
+    const attempts = series([{ scope: 'provider:openai', points: [100, 50] }])
+    const fails = series([{ scope: 'provider:openai', points: [1, 5] }])
+    expect(errorRateSeries(attempts, fails)).toEqual([{ scope: 'provider:openai', points: [0.01, 0.1] }])
+  })
+
+  it('reports null (never 0) for a bucket with zero attempts', () => {
+    const attempts = series([{ scope: 'provider:openai', points: [0, 10] }])
+    const fails = series([{ scope: 'provider:openai', points: [0, 0] }])
+    expect(errorRateSeries(attempts, fails)).toEqual([{ scope: 'provider:openai', points: [null, 0] }])
+  })
+
+  it('treats a scope missing entirely from the fail series as zero failures, not a thrown error', () => {
+    const attempts = series([{ scope: 'provider:anthropic', points: [10] }])
+    const fails = series([])
+    expect(errorRateSeries(attempts, fails)).toEqual([{ scope: 'provider:anthropic', points: [0] }])
+  })
+
+  it('delegates the division itself to lib/series.ts ratioSeries verbatim (no extra clamping here)', () => {
+    const attempts = series([{ scope: 'provider:x', points: [5] }])
+    const fails = series([{ scope: 'provider:x', points: [9] }])
+    // Deliberately > 1 (should not happen with real counters) — asserts
+    // this function does not silently clamp on top of ratioSeries' own
+    // behavior, so the two never quietly diverge.
+    expect(errorRateSeries(attempts, fails)).toEqual([{ scope: 'provider:x', points: [1.8] }])
+  })
+})
+
+describe('seriesColor', () => {
+  it('cycles through RELIABILITY_SERIES_COLORS by index', () => {
+    expect(seriesColor(0)).toBe(RELIABILITY_SERIES_COLORS[0])
+    expect(seriesColor(RELIABILITY_SERIES_COLORS.length)).toBe(RELIABILITY_SERIES_COLORS[0])
+    expect(seriesColor(RELIABILITY_SERIES_COLORS.length + 1)).toBe(RELIABILITY_SERIES_COLORS[1])
+  })
+})
+
+const emptyOverview: AdminOverviewResponse = {
+  version: '1',
+  replica: 'pod-a',
+  instance: 'test-gateway',
+  warnings: [],
+  providers: [],
+  groups: [],
+  aliases: [],
+  redis: { configured: false, lastErrAt: '0001-01-01T00:00:00Z' },
+  cache: { enabled: false },
+  retry: { enabled: false },
+  features: { userModelStats: false, latencyStats: false, cacheStats: false, lastSeen: false, failover: false },
+  pricing: { override: 0, builtin: 0, litellm: 0, free: 0, unpriced: 0 },
+}
+
+function providerOverview(names: string[]): AdminOverviewResponse {
+  return {
+    ...emptyOverview,
+    providers: names.map((name) => ({
+      name,
+      type: 'openai',
+      baseUrl: 'https://api.example.com',
+      lastRefresh: '0001-01-01T00:00:00Z',
+      models: [],
+      modelCount: 0,
+      modelMeta: {},
+      discoveryEnabled: false,
+      healthState: 'closed',
+      openUntil: '0001-01-01T00:00:00Z',
+      attemptsDay: 0,
+      failuresDay: 0,
+      attemptsMinute: 0,
+      failuresMinute: 0,
+      modelRates: {},
+    })),
+  }
+}
+
+describe('useReliabilityStore.fetch', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    mockedAdminFetch.mockReset()
+    useAuthStore().submit('test-admin-key')
+  })
+
+  it('short-circuits to empty state with no adminFetch calls when no providers are configured', async () => {
+    useDashboardStore().overview = emptyOverview
+    const reliability = useReliabilityStore()
+
+    await reliability.fetch()
+
+    expect(mockedAdminFetch).not.toHaveBeenCalled()
+    expect(reliability.errorRate).toEqual([])
+    expect(reliability.lastUpdated).not.toBeNull()
+    expect(reliability.error).toBe('')
+  })
+
+  it('fetches attempt/fail/timeout/fover per configured provider scope, plus total rej/r402, and assigns every field', async () => {
+    useDashboardStore().overview = providerOverview(['openai', 'anthropic'])
+    const reliability = useReliabilityStore()
+
+    function seriesFor(metric: string, points: number[]): AdminSeriesResponse {
+      return {
+        metric,
+        window: 'day',
+        span: points.length,
+        offset: 0,
+        buckets: points.map((_, i) => `2026010${i + 1}`),
+        series:
+          metric === 'rej' || metric === 'r402'
+            ? [{ scope: 'total', points }]
+            : [
+                { scope: 'provider:openai', points },
+                { scope: 'provider:anthropic', points: points.map((p) => p * 2) },
+              ],
+        unknown: [],
+      }
+    }
+
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      if (path.includes('metric=attempt')) return seriesFor('attempt', [100, 100])
+      if (path.includes('metric=fail')) return seriesFor('fail', [1, 2])
+      if (path.includes('metric=timeout')) return seriesFor('timeout', [0, 1])
+      if (path.includes('metric=fover')) return seriesFor('fover', [0, 0])
+      if (path.includes('metric=rej')) return seriesFor('rej', [3, 4])
+      if (path.includes('metric=r402')) return seriesFor('r402', [0, 1])
+      throw new Error(`unexpected path ${path}`)
+    }) as typeof adminFetch)
+
+    await reliability.fetch()
+
+    expect(reliability.buckets).toEqual(['20260101', '20260102'])
+    expect(reliability.windowUsed).toBe('day')
+    expect(reliability.errorRate).toEqual([
+      { scope: 'provider:openai', points: [0.01, 0.02] },
+      { scope: 'provider:anthropic', points: [0.01, 0.02] },
+    ])
+    expect(reliability.timeouts).toHaveLength(2)
+    expect(reliability.failovers).toHaveLength(2)
+    expect(reliability.rejections).toEqual([3, 4])
+    expect(reliability.unpriced).toEqual([0, 1])
+    expect(reliability.lastUpdated).not.toBeNull()
+    expect(reliability.error).toBe('')
+  })
+
+  // P2 item 6: fetch() used to have an `if (this.loading) return` guard,
+  // which silently dropped a range change that started while a fetch was
+  // already in flight. The replacement is latest-request-wins (reqId) —
+  // this test exercises the property that actually matters: a SLOWER,
+  // earlier fetch() resolving AFTER a faster, later one must never
+  // overwrite the later (more current) result with stale data.
+  it('discards a slower first fetch() result once a newer fetch() has already resolved (latest-request-wins)', async () => {
+    useDashboardStore().overview = providerOverview(['openai'])
+    const reliability = useReliabilityStore()
+
+    function seriesFor(metric: string, scope: string, points: number[]): AdminSeriesResponse {
+      return { metric, window: 'day', span: points.length, offset: 0, buckets: ['20260101', '20260102'], series: [{ scope, points }], unknown: [] }
+    }
+
+    let resolveFirstAttempt: ((v: AdminSeriesResponse) => void) | undefined
+    let attemptCallCount = 0
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      if (path.includes('metric=attempt')) {
+        attemptCallCount += 1
+        // The FIRST fetch()'s own attempt call hangs until the test
+        // resolves it by hand, below — every LATER attempt call
+        // (`second`'s, and any after it) resolves immediately.
+        if (attemptCallCount === 1) return new Promise<AdminSeriesResponse>((resolve) => (resolveFirstAttempt = resolve))
+        return seriesFor('attempt', 'provider:openai', [9, 9])
+      }
+      if (path.includes('metric=fail')) return seriesFor('fail', 'provider:openai', [0, 0])
+      if (path.includes('metric=timeout')) return seriesFor('timeout', 'provider:openai', [0, 0])
+      if (path.includes('metric=fover')) return seriesFor('fover', 'provider:openai', [0, 0])
+      if (path.includes('metric=rej')) return seriesFor('rej', 'total', [9, 9])
+      if (path.includes('metric=r402')) return seriesFor('r402', 'total', [0, 0])
+      throw new Error(`unexpected path ${path}`)
+    }) as typeof adminFetch)
+
+    const first = reliability.fetch()
+    await vi.waitFor(() => {
+      if (!resolveFirstAttempt) throw new Error('first attempt request not issued yet')
+    })
+    const second = reliability.fetch()
+    await second
+    expect(reliability.rejections).toEqual([9, 9])
+
+    // `first` finally resolves, with STALE data — it must be discarded,
+    // not overwrite the already-current `second` result.
+    resolveFirstAttempt?.(seriesFor('attempt', 'provider:openai', [1, 1]))
+    await first
+    expect(reliability.rejections).toEqual([9, 9])
+    expect(reliability.loading).toBe(false)
+  })
+
+  it('records a non-auth failure message without throwing', async () => {
+    useDashboardStore().overview = providerOverview(['openai'])
+    const reliability = useReliabilityStore()
+    mockedAdminFetch.mockImplementation((async () => {
+      throw new Error('series boom')
+    }) as typeof adminFetch)
+
+    await reliability.fetch()
+
+    expect(reliability.error).toContain('series boom')
+  })
+})
+
+// fetchProviderPerf (N3 fix, verify-redesign-final.md: "performance
+// series=1 for the selected provider" was never wired up).
+describe('useReliabilityStore.fetchProviderPerf', () => {
+  beforeEach(() => {
+    setActivePinia(createPinia())
+    mockedAdminFetch.mockReset()
+    useAuthStore().submit('test-admin-key')
+  })
+
+  function overviewWithLatency(enabled: boolean): AdminOverviewResponse {
+    return { ...providerOverview(['openai']), features: { ...emptyOverview.features, latencyStats: enabled } }
+  }
+
+  it('short-circuits with no adminFetch call when no provider is selected', async () => {
+    useDashboardStore().overview = overviewWithLatency(true)
+    const reliability = useReliabilityStore()
+
+    await reliability.fetchProviderPerf('')
+
+    expect(mockedAdminFetch).not.toHaveBeenCalled()
+    expect(reliability.providerPerfPoints).toEqual([])
+    expect(reliability.providerPerfBuckets).toEqual([])
+  })
+
+  it('short-circuits with no adminFetch call when admin.stats.latency is off, even with a provider selected', async () => {
+    useDashboardStore().overview = overviewWithLatency(false)
+    const reliability = useReliabilityStore()
+
+    await reliability.fetchProviderPerf('openai')
+
+    expect(mockedAdminFetch).not.toHaveBeenCalled()
+    expect(reliability.providerPerfLatencyEnabled).toBe(false)
+  })
+
+  it('fetches GET /admin/api/performance?kind=provider&series=1 for exactly the selected provider, and assigns every field', async () => {
+    useDashboardStore().overview = overviewWithLatency(true)
+    const reliability = useReliabilityStore()
+
+    const response: AdminPerfResponse = {
+      kind: 'provider',
+      window: 'day',
+      span: 2,
+      offset: 0,
+      buckets: ['20260101', '20260102'],
+      points: [
+        { id: '20260101', p50Ms: 10, p95Ms: 20, count: 5, attempts: 5, failures: 1 },
+        { id: '20260102', count: 3, attempts: 3, failures: 0 },
+      ],
+      latencyEnabled: true,
+    }
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      expect(path).toContain('kind=provider')
+      expect(path).toContain('series=1')
+      expect(path).toContain('id=openai')
+      return response
+    }) as typeof adminFetch)
+
+    await reliability.fetchProviderPerf('openai')
+
+    expect(reliability.providerPerfBuckets).toEqual(['20260101', '20260102'])
+    expect(reliability.providerPerfWindowUsed).toBe('day')
+    expect(reliability.providerPerfPoints).toEqual(response.points)
+    expect(reliability.providerPerfLatencyEnabled).toBe(true)
+    expect(reliability.providerPerfError).toBe('')
+  })
+
+  it('discards a slower first fetchProviderPerf() result once a newer one has already resolved (latest-request-wins)', async () => {
+    useDashboardStore().overview = overviewWithLatency(true)
+    const reliability = useReliabilityStore()
+
+    function response(points: AdminPerfRow[]): AdminPerfResponse {
+      return { kind: 'provider', window: 'day', span: points.length, offset: 0, buckets: ['20260101', '20260102'], points, latencyEnabled: true }
+    }
+
+    let resolveFirst: ((v: AdminPerfResponse) => void) | undefined
+    let callCount = 0
+    mockedAdminFetch.mockImplementation((async () => {
+      callCount += 1
+      if (callCount === 1) return new Promise<AdminPerfResponse>((resolve) => (resolveFirst = resolve))
+      return response([{ id: '20260101', count: 9, attempts: 9, failures: 9 }])
+    }) as typeof adminFetch)
+
+    const first = reliability.fetchProviderPerf('openai')
+    await vi.waitFor(() => {
+      if (!resolveFirst) throw new Error('first request not issued yet')
+    })
+    const second = reliability.fetchProviderPerf('openai')
+    await second
+    expect(reliability.providerPerfPoints).toEqual([{ id: '20260101', count: 9, attempts: 9, failures: 9 }])
+
+    resolveFirst?.(response([{ id: '20260101', count: 1, attempts: 1, failures: 1 }]))
+    await first
+    expect(reliability.providerPerfPoints).toEqual([{ id: '20260101', count: 9, attempts: 9, failures: 9 }])
+    expect(reliability.providerPerfLoading).toBe(false)
+  })
+
+  it('records a non-auth failure message without throwing', async () => {
+    useDashboardStore().overview = overviewWithLatency(true)
+    const reliability = useReliabilityStore()
+    mockedAdminFetch.mockImplementation((async () => {
+      throw new Error('perf series boom')
+    }) as typeof adminFetch)
+
+    await reliability.fetchProviderPerf('openai')
+
+    expect(reliability.providerPerfError).toContain('perf series boom')
+  })
+})
diff --git a/webui/src/stores/reliability.ts b/webui/src/stores/reliability.ts
new file mode 100644
index 0000000..ad975bd
--- /dev/null
+++ b/webui/src/stores/reliability.ts
@@ -0,0 +1,227 @@
+import { defineStore } from 'pinia'
+
+import { AdminApiError, adminFetch } from '@/lib/api'
+import { seriesUrl } from '@/lib/range'
+import { ratioSeries } from '@/lib/series'
+import { useDashboardStore } from '@/stores/dashboard'
+import { useFiltersStore } from '@/stores/filters'
+import type { AdminPerfResponse, AdminPerfRow, AdminSeriesResponse, HistoryWindow } from '@/types/api'
+
+/**
+ * hourOrDayWindow clamps an arbitrary HistoryWindow/span pair (usually the
+ * global filters store's current range) down to the hour/day-only window
+ * every Reliability metric accepts (redesign-plan.md section 1.3.iv's
+ * metric x kind matrix: provider attempt/fail/timeout/fover and total
+ * rej/r402 are BOTH "(h/d)" only — neither family has a month bucket at
+ * all, matching their own 48h/35d TTLs, section 1.2). 'hour' and 'day' pass
+ * through unchanged; 'month' (the 3mo/6mo/12mo global ranges) falls back to
+ * a fixed 30-day day-window default — a deliberate, documented choice
+ * rather than an arbitrary derived span, and comfortably within
+ * HISTORY_MAX_SPAN.day (35, lib/range.ts).
+ */
+export function hourOrDayWindow(window: HistoryWindow, span: number): { window: Extract<HistoryWindow, 'hour' | 'day'>; span: number } {
+  if (window === 'hour') return { window: 'hour', span }
+  if (window === 'day') return { window: 'day', span }
+  return { window: 'day', span: 30 }
+}
+
+/** One provider's own error-rate series — a 0-1 ratio per bucket, or null where that bucket had zero attempts (never a fabricated 0%, mirroring lib/provider-rate.ts's own providerSuccessRate convention). */
+export interface ProviderRatioSeries {
+  scope: string
+  points: (number | null)[]
+}
+
+/**
+ * errorRateSeries joins two SAME-SHAPE AdminSeriesResponse results
+ * (attempt and fail, fetched with the identical scope list/window/span/
+ * offset) by scope, then delegates the actual per-bucket division to
+ * WP-D's shared lib/series.ts ratioSeries (redesign-plan.md section 3.4:
+ * "TimeSeriesChart for error rate per provider (lib/series.ts ratioSeries
+ * fail/attempt per bucket)") — this function's own job is only the
+ * scope-matching join AdminSeriesResponse's two independent responses
+ * need, not the division itself, so there is exactly one place the ratio
+ * math lives. A scope present in `attempts` but missing from `fails`
+ * (should not happen — both requests share the same scope list — but
+ * defensively handled) is treated as all-zero failures, matching
+ * ratioSeries' own "missing point reads as 0" convention.
+ */
+export function errorRateSeries(attempts: AdminSeriesResponse, fails: AdminSeriesResponse): ProviderRatioSeries[] {
+  const failByScope = new Map(fails.series.map((s) => [s.scope, s.points]))
+  return attempts.series.map((a) => ({
+    scope: a.scope,
+    points: ratioSeries(failByScope.get(a.scope) ?? new Array<number>(a.points.length).fill(0), a.points),
+  }))
+}
+
+/**
+ * RELIABILITY_SERIES_COLORS cycles through main.css's four existing
+ * --chart-* tokens (assets/main.css is owned by WP-E — this store does not
+ * add a fifth) to color the per-provider error-rate/timeout/failover
+ * overlay charts: with more than four configured providers, colors repeat
+ * — a known, documented limitation rather than a silent one, since adding
+ * a genuinely distinct fifth hue is out of this work package's file scope.
+ */
+export const RELIABILITY_SERIES_COLORS = ['--chart-requests', '--chart-tokens-in', '--chart-tokens-out', '--chart-cost'] as const
+
+/** seriesColor picks one of RELIABILITY_SERIES_COLORS by index, cycling. */
+export function seriesColor(index: number): string {
+  return RELIABILITY_SERIES_COLORS[index % RELIABILITY_SERIES_COLORS.length]
+}
+
+/** One plain (non-ratio) metric series, e.g. failovers/timeouts per provider, or the fleet-wide rej/r402 total. */
+export interface CountSeries {
+  scope: string
+  points: number[]
+}
+
+/**
+ * useReliabilityStore fetches the Reliability page's own on-demand series
+ * (redesign-plan.md section 3.3/3.4) — NOT part of the 5s dashboard poll
+ * (Q12 DECISIONS: "new endpoints on demand or 60s"), refetched by the page
+ * itself on mount and whenever the global filters range changes. Provider
+ * scopes are read from useDashboardStore's already-polled overview
+ * (overview.providers) rather than a second providers listing fetch.
+ */
+export const useReliabilityStore = defineStore('reliability', {
+  state: () => ({
+    buckets: [] as string[],
+    /** The hour/day window hourOrDayWindow actually resolved for the current buckets/series — ReliabilityPage.vue's formatBucketLabel calls need this, not filters.window, whenever a month-range clamp was applied. */
+    windowUsed: 'day' as Extract<HistoryWindow, 'hour' | 'day'>,
+    /** Per-provider fail/attempt ratio, one entry per configured provider. */
+    errorRate: [] as ProviderRatioSeries[],
+    /** Per-provider timeout count series (metric `timeout`). */
+    timeouts: [] as CountSeries[],
+    /** Per-provider failover count series (metric `fover`) — a provider's OWN candidates that were failed away FROM, per accountExtras.failoverFrom's own doc comment (redesign-plan.md section 2b). */
+    failovers: [] as CountSeries[],
+    /** Fleet-wide total rejections/minute-window-denied series (metric `rej`, scope `total`). */
+    rejections: [] as number[],
+    /** Fleet-wide total 402 unpriced-refusal series (metric `r402`, scope `total`). */
+    unpriced: [] as number[],
+    loading: false,
+    lastUpdated: null as Date | null,
+    error: '',
+    /** reqId guards against an out-of-order response overwriting a newer one (latest-request-wins, stores/catalog.ts's own convention) — a range change mid-flight no longer gets silently dropped by an `if (this.loading) return` guard (P2 item 6). */
+    reqId: 0,
+
+    // --- selected-provider performance series (N3/redesign-plan.md
+    // section 3.3: "performance series=1 for the selected provider") ---
+    /** GET /admin/api/performance?kind=provider&series=1's own bucket labels for the currently selected provider — separate from `buckets`/`windowUsed` above since fetchProviderPerf runs independently of fetch() and could in principle resolve against a different window (a fast provider switch mid-range-change). */
+    providerPerfBuckets: [] as string[],
+    providerPerfWindowUsed: 'day' as Extract<HistoryWindow, 'hour' | 'day'>,
+    /** One AdminPerfRow per bucket (its own `id` is the bucket string, not the provider name — AdminPerfResponse's own doc comment) — p50Ms/p95Ms/failures per bucket for ReliabilityPage.vue's selected-provider chart. */
+    providerPerfPoints: [] as AdminPerfRow[],
+    /** AdminFeaturesView.latencyStats, as this SPECIFIC response reported it — ReliabilityPage.vue already reads dashboard.overview.features.latencyStats to decide whether to fetch at all, but keeping the response's own copy here avoids a stale read if the config toggles between fetches. */
+    providerPerfLatencyEnabled: false,
+    providerPerfLoading: false,
+    providerPerfError: '',
+    /** Same latest-request-wins guard as `reqId` above, scoped to fetchProviderPerf's own independent fetch lifecycle. */
+    providerPerfReqId: 0,
+  }),
+  actions: {
+    async fetch(): Promise<void> {
+      const requestId = ++this.reqId
+      this.loading = true
+      try {
+        const filters = useFiltersStore()
+        const dashboard = useDashboardStore()
+        const providerNames = (dashboard.overview?.providers ?? []).map((p) => p.name)
+
+        if (providerNames.length === 0) {
+          if (requestId !== this.reqId) return
+          this.buckets = []
+          this.windowUsed = hourOrDayWindow(filters.window, filters.span).window
+          this.errorRate = []
+          this.timeouts = []
+          this.failovers = []
+          this.rejections = []
+          this.unpriced = []
+          this.lastUpdated = new Date()
+          this.error = ''
+          return
+        }
+
+        const { window, span } = hourOrDayWindow(filters.window, filters.span)
+        const scopes = providerNames.map((name) => `provider:${name}`)
+
+        const [attemptRes, failRes, timeoutRes, foverRes, rejRes, r402Res] = await Promise.all([
+          adminFetch<AdminSeriesResponse>(seriesUrl({ scope: scopes, metric: 'attempt', window, span })),
+          adminFetch<AdminSeriesResponse>(seriesUrl({ scope: scopes, metric: 'fail', window, span })),
+          adminFetch<AdminSeriesResponse>(seriesUrl({ scope: scopes, metric: 'timeout', window, span })),
+          adminFetch<AdminSeriesResponse>(seriesUrl({ scope: scopes, metric: 'fover', window, span })),
+          adminFetch<AdminSeriesResponse>(seriesUrl({ scope: ['total'], metric: 'rej', window, span })),
+          adminFetch<AdminSeriesResponse>(seriesUrl({ scope: ['total'], metric: 'r402', window, span })),
+        ])
+        if (requestId !== this.reqId) return
+
+        this.buckets = attemptRes.buckets
+        this.windowUsed = window
+        this.errorRate = errorRateSeries(attemptRes, failRes)
+        this.timeouts = timeoutRes.series
+        this.failovers = foverRes.series
+        this.rejections = rejRes.series[0]?.points ?? []
+        this.unpriced = r402Res.series[0]?.points ?? []
+        this.lastUpdated = new Date()
+        this.error = ''
+      } catch (err) {
+        if (requestId !== this.reqId) return
+        if (err instanceof AdminApiError && (err.status === 401 || err.status === 403)) return
+        this.error = err instanceof Error ? err.message : String(err)
+      } finally {
+        if (requestId === this.reqId) this.loading = false
+      }
+    },
+
+    /**
+     * fetchProviderPerf (N3 fix, verify-redesign-final.md — plan §3.3's
+     * "performance series=1 for the selected provider" was never wired
+     * up) reads GET /admin/api/performance?kind=provider&series=1 for
+     * ONE provider — per-bucket p50/p95 latency and failure counts,
+     * matching this same store's hourOrDayWindow clamp. Only fetches
+     * when BOTH `provider` is non-empty (ReliabilityPage.vue passes ''
+     * for "All providers") AND admin.stats.latency is on
+     * (dashboard.overview.features.latencyStats) — series=1 payload is
+     * genuinely useless without latency (attempts/failures alone do not
+     * justify a second on-demand round trip Q12 would rather avoid), so
+     * this short-circuits to the empty state instead of firing a request
+     * neither the page nor the reader will use, mirroring fetch()'s own
+     * zero-providers short-circuit above.
+     */
+    async fetchProviderPerf(provider: string): Promise<void> {
+      const requestId = ++this.providerPerfReqId
+      const dashboard = useDashboardStore()
+      const latencyStatsEnabled = dashboard.overview?.features.latencyStats ?? false
+
+      if (!provider || !latencyStatsEnabled) {
+        if (requestId !== this.providerPerfReqId) return
+        this.providerPerfBuckets = []
+        this.providerPerfPoints = []
+        this.providerPerfLatencyEnabled = false
+        this.providerPerfError = ''
+        this.providerPerfLoading = false
+        return
+      }
+
+      this.providerPerfLoading = true
+      try {
+        const filters = useFiltersStore()
+        const { window, span } = hourOrDayWindow(filters.window, filters.span)
+        const q = new URLSearchParams({ kind: 'provider', window, span: String(span), series: '1' })
+        q.append('id', provider)
+        const res = await adminFetch<AdminPerfResponse>(`/admin/api/performance?${q.toString()}`)
+        if (requestId !== this.providerPerfReqId) return
+
+        this.providerPerfBuckets = res.buckets ?? []
+        this.providerPerfWindowUsed = window
+        this.providerPerfPoints = res.points ?? []
+        this.providerPerfLatencyEnabled = res.latencyEnabled
+        this.providerPerfError = ''
+      } catch (err) {
+        if (requestId !== this.providerPerfReqId) return
+        if (err instanceof AdminApiError && (err.status === 401 || err.status === 403)) return
+        this.providerPerfError = err instanceof Error ? err.message : String(err)
+      } finally {
+        if (requestId === this.providerPerfReqId) this.providerPerfLoading = false
+      }
+    },
+  },
+})
diff --git a/webui/src/stores/spend.spec.ts b/webui/src/stores/spend.spec.ts
new file mode 100644
index 0000000..a10995d
--- /dev/null
+++ b/webui/src/stores/spend.spec.ts
@@ -0,0 +1,400 @@
+import { createPinia, setActivePinia } from 'pinia'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@/lib/api', async () => {
+  const actual = await vi.importActual<typeof import('@/lib/api')>('@/lib/api')
+  return { ...actual, adminFetch: vi.fn() }
+})
+
+import { AdminApiError, adminFetch } from '@/lib/api'
+import { isSpendBy, isSpendMetric, MODEL_BREAKDOWN_TOP_N, useSpendStore } from '@/stores/spend'
+import { useAuthStore } from '@/stores/auth'
+import { useDashboardStore } from '@/stores/dashboard'
+import { useFiltersStore } from '@/stores/filters'
+import type { AdminOverviewResponse, AdminSeriesResponse, AdminTotalsResponse, AdminUsageModelsResponse } from '@/types/api'
+
+const mockedAdminFetch = vi.mocked(adminFetch)
+
+function seriesFor(scope: string[], value = 10): AdminSeriesResponse {
+  return {
+    metric: 'cost',
+    window: 'day',
+    span: 2,
+    offset: 0,
+    buckets: ['20260922', '20260923'],
+    series: scope.map((s) => ({ scope: s, points: [value, value] })),
+    unknown: [],
+  }
+}
+
+function rankingWith(ids: string[]): AdminUsageModelsResponse {
+  return {
+    metric: 'cost',
+    window: 'day',
+    span: 2,
+    detail: true,
+    offset: 0,
+    models: ids.map((id, i) => ({ id, value: 100 - i, requests: 100 - i, tokensIn: 1, tokensOut: 1, costMicroUsd: 1, free: false })),
+  }
+}
+
+/** mockRoutes wires adminFetch's mock by matching the route prefix — the four concerns this store fetches (models ranking, series, totals, and again totals for drilldown) all hit different admin.go routes. */
+function mockRoutes(handlers: { series?: (url: string) => AdminSeriesResponse; totals?: (url: string) => AdminTotalsResponse; models?: (url: string) => AdminUsageModelsResponse }): void {
+  mockedAdminFetch.mockImplementation((async (path: string) => {
+    if (path.startsWith('/admin/api/usage/models')) return handlers.models ? handlers.models(path) : rankingWith([])
+    if (path.startsWith('/admin/api/usage/series')) return handlers.series ? handlers.series(path) : seriesFor(['total'], 0)
+    if (path.startsWith('/admin/api/usage/totals')) return handlers.totals ? handlers.totals(path) : { kind: 'group', window: 'day', span: 2, offset: 0, metrics: [], rows: [] }
+    throw new Error(`unexpected path ${path}`)
+  }) as typeof adminFetch)
+}
+
+beforeEach(() => {
+  setActivePinia(createPinia())
+  mockedAdminFetch.mockReset()
+  useAuthStore().submit('test-admin-key')
+})
+
+describe('SPEND_BY / SPEND_METRICS guards', () => {
+  it('isSpendBy accepts model/provider/group and rejects anything else', () => {
+    expect(isSpendBy('model')).toBe(true)
+    expect(isSpendBy('provider')).toBe(true)
+    expect(isSpendBy('group')).toBe(true)
+    expect(isSpendBy('bogus')).toBe(false)
+  })
+
+  it('isSpendMetric accepts cost/req/tokin/tokout and rejects anything else', () => {
+    expect(isSpendMetric('cost')).toBe(true)
+    expect(isSpendMetric('tokout')).toBe(true)
+    expect(isSpendMetric('bogus')).toBe(false)
+  })
+})
+
+describe('useSpendStore.fetchModelRanking', () => {
+  it('populates modelRanking on success', async () => {
+    mockRoutes({ models: () => rankingWith(['a/one', 'a/two']) })
+    const spend = useSpendStore()
+    await spend.fetchModelRanking()
+    expect(spend.modelRanking.map((m) => m.id)).toEqual(['a/one', 'a/two'])
+  })
+
+  it('is a no-op while unauthenticated', async () => {
+    setActivePinia(createPinia())
+    mockRoutes({})
+    const spend = useSpendStore()
+    await spend.fetchModelRanking()
+    expect(spend.modelRanking).toEqual([])
+  })
+})
+
+// P3 item 21: PricingHealthTable.vue's "unpriced first" ordering needs a
+// ranking sorted by TRAFFIC (req), independent of whatever metric the
+// Spend breakdown chart currently sorts by — sorting by `cost` (the
+// default `this.metric`) cuts the top-100 ranking off BY COST, and an
+// unpriced model bills $0, so it is one of the first rows a cost-sorted
+// cutoff drops.
+describe('useSpendStore.fetchPricingHealthRanking', () => {
+  it('always requests metric=req, regardless of the currently-selected Spend metric', async () => {
+    let requestedUrl = ''
+    mockRoutes({
+      models: (url) => {
+        requestedUrl = url
+        return rankingWith(['a/one'])
+      },
+    })
+    const spend = useSpendStore()
+    spend.$patch({ metric: 'cost' }) // deliberately NOT req
+    await spend.fetchPricingHealthRanking()
+    expect(requestedUrl).toBe('/admin/api/usage/models?metric=req&window=day&span=7&limit=100&detail=1')
+    expect(spend.pricingHealthRanking.map((m) => m.id)).toEqual(['a/one'])
+  })
+})
+
+describe('useSpendStore.fetchBreakdown: by=model, scope=all', () => {
+  it('fetches total + top-N model series and computes other = total - sum(top)', async () => {
+    mockRoutes({
+      models: () => rankingWith(['a/one', 'a/two']),
+      series: (url) => {
+        if (url.includes('scope=total') && !url.includes('scope=model')) return seriesFor(['total'], 100)
+        return seriesFor(['model:a/one', 'model:a/two'], 20)
+      },
+    })
+    const spend = useSpendStore()
+    await spend.fetchModelRanking()
+    await spend.fetchBreakdown()
+
+    expect(spend.totalPoints).toEqual([100, 100])
+    expect(spend.breakdown.map((s) => s.scope)).toEqual(['model:a/one', 'model:a/two'])
+    // 100 - (20 + 20) = 60 per bucket.
+    expect(spend.otherPoints).toEqual([60, 60])
+  })
+
+  it('caps the charted series at MODEL_BREAKDOWN_TOP_N even with a larger ranking', async () => {
+    const ids = Array.from({ length: 25 }, (_, i) => `a/model-${i}`)
+    mockRoutes({
+      models: () => rankingWith(ids),
+      series: (url) => {
+        if (url.includes('scope=model')) {
+          const requested = [...url.matchAll(/scope=model%3A([^&]+)/g)].map((m) => `model:${decodeURIComponent(m[1]!)}`)
+          expect(requested.length).toBeLessThanOrEqual(MODEL_BREAKDOWN_TOP_N)
+          return seriesFor(requested, 1)
+        }
+        return seriesFor(['total'], 1000)
+      },
+    })
+    const spend = useSpendStore()
+    await spend.fetchModelRanking()
+    await spend.fetchBreakdown()
+    expect(spend.breakdown).toHaveLength(MODEL_BREAKDOWN_TOP_N)
+  })
+})
+
+describe('useSpendStore.fetchBreakdown: by=provider, scope=all', () => {
+  it('sums the ranking models by provider prefix', async () => {
+    mockRoutes({
+      models: () => rankingWith(['openai/gpt-5', 'openai/gpt-5-mini', 'anthropic/claude']),
+      series: (url) => {
+        if (url.includes('scope=model')) {
+          return seriesFor(['model:openai/gpt-5', 'model:openai/gpt-5-mini', 'model:anthropic/claude'], 10)
+        }
+        return seriesFor(['total'], 30)
+      },
+    })
+    const spend = useSpendStore()
+    spend.setSelection({ by: 'provider' })
+    await spend.fetchModelRanking()
+    await spend.fetchBreakdown()
+
+    expect(spend.breakdown).toEqual(
+      expect.arrayContaining([
+        { scope: 'openai', points: [20, 20] },
+        { scope: 'anthropic', points: [10, 10] },
+      ]),
+    )
+    expect(spend.otherPoints).toBeNull()
+  })
+})
+
+describe('useSpendStore.fetchBreakdown: by=group, scope=all', () => {
+  it('fetches the group id list from totals, then a series per group', async () => {
+    mockRoutes({
+      totals: () => ({ kind: 'group', window: 'day', span: 2, offset: 0, metrics: ['cost'], rows: [{ id: 'friends', values: { cost: 40 } }, { id: 'eng', values: { cost: 60 } }] }),
+      series: (url) => {
+        if (url.includes('scope=group')) return seriesFor(['group:friends', 'group:eng'], 5)
+        return seriesFor(['total'], 100)
+      },
+    })
+    const spend = useSpendStore()
+    spend.setSelection({ by: 'group' })
+    await spend.fetchModelRanking()
+    await spend.fetchBreakdown()
+
+    expect(spend.breakdown.map((s) => s.scope).sort()).toEqual(['group:eng', 'group:friends'])
+    expect(spend.otherPoints).toBeNull()
+  })
+})
+
+describe('useSpendStore.fetchBreakdown: scope narrowed to a single group/user', () => {
+  it('renders exactly one series for the narrowed scope, ignoring `by`', async () => {
+    useFiltersStore().setFilters({ scope: 'group:friends' })
+    mockRoutes({ series: () => seriesFor(['group:friends'], 42) })
+    const spend = useSpendStore()
+    await spend.fetchBreakdown()
+
+    expect(spend.breakdown).toEqual([{ scope: 'group:friends', points: [42, 42] }])
+    expect(spend.totalPoints).toEqual([42, 42])
+    expect(spend.otherPoints).toBeNull()
+  })
+})
+
+describe('useSpendStore.fetchBreakdown: scope narrowed to a provider', () => {
+  it('derives a single provider-summed series from the ranking, pre-filtered to that provider', async () => {
+    useFiltersStore().setFilters({ scope: 'provider:openai' })
+    mockRoutes({
+      models: () => rankingWith(['openai/gpt-5', 'anthropic/claude']),
+      series: (url) => {
+        expect(url).toContain('scope=model%3Aopenai%2Fgpt-5')
+        expect(url).not.toContain('anthropic')
+        return seriesFor(['model:openai/gpt-5'], 7)
+      },
+    })
+    const spend = useSpendStore()
+    await spend.fetchModelRanking()
+    await spend.fetchBreakdown()
+
+    expect(spend.breakdown).toEqual([{ scope: 'provider:openai', points: [7, 7] }])
+  })
+})
+
+describe('useSpendStore.fetchBreakdown: comparison', () => {
+  it('fetches an offset total series only when cmpSpec.requested', async () => {
+    useFiltersStore().setFilters({ cmp: 'prev' })
+    mockRoutes({
+      models: () => rankingWith([]),
+      series: (url) => {
+        if (url.includes('offset=')) return seriesFor(['total'], 5)
+        return seriesFor(['total'], 50)
+      },
+    })
+    const spend = useSpendStore()
+    await spend.fetchModelRanking()
+    await spend.fetchBreakdown()
+
+    expect(spend.comparisonPoints).toEqual([5, 5])
+  })
+
+  it('leaves comparisonPoints null when cmp is none', async () => {
+    mockRoutes({ models: () => rankingWith([]) })
+    const spend = useSpendStore()
+    await spend.fetchModelRanking()
+    await spend.fetchBreakdown()
+    expect(spend.comparisonPoints).toBeNull()
+  })
+})
+
+describe('useSpendStore.fetchBurndown', () => {
+  it('fetches a day-window total series spanning the current UTC day-of-month', async () => {
+    mockRoutes({
+      series: (url) => {
+        expect(url).toContain('window=day')
+        expect(url).toContain('scope=total')
+        return seriesFor(['total'], 3)
+      },
+    })
+    const spend = useSpendStore()
+    await spend.fetchBurndown()
+    expect(spend.burndownPoints).toEqual([3, 3])
+  })
+
+  it('reports burndownAvailable false and skips the fetch for a provider scope', async () => {
+    useFiltersStore().setFilters({ scope: 'provider:openai' })
+    mockRoutes({})
+    const spend = useSpendStore()
+    expect(spend.burndownAvailable).toBe(false)
+    await spend.fetchBurndown()
+    expect(mockedAdminFetch).not.toHaveBeenCalled()
+    expect(spend.burndownPoints).toEqual([])
+  })
+
+  it('resolves the fleet-wide budget from the sum of configured group budgets', async () => {
+    mockRoutes({ series: () => seriesFor(['total'], 1) })
+    useDashboardStore().overview = {
+      version: '1',
+      replica: 'r',
+      instance: 'i',
+      warnings: [],
+      providers: [],
+      groups: [{ name: 'friends', memberCount: 1, limits: { costPerMonthUSD: 10 } }],
+      aliases: [],
+      redis: { configured: false, lastErrAt: '0001-01-01T00:00:00Z' },
+      cache: { enabled: false },
+      retry: { enabled: false },
+      features: { userModelStats: false, latencyStats: false, cacheStats: false, lastSeen: false, failover: false },
+      pricing: { override: 0, builtin: 0, litellm: 0, free: 0, unpriced: 0 },
+    } satisfies AdminOverviewResponse
+    const spend = useSpendStore()
+    await spend.fetchBurndown()
+    expect(spend.burndownBudgetMicros).toBe(10_000_000)
+  })
+})
+
+describe('useSpendStore.fetchDrilldown', () => {
+  it('requests kind=group at the top level (drill empty)', async () => {
+    mockRoutes({
+      totals: (url) => {
+        expect(url).toContain('kind=group')
+        expect(url).not.toContain('group=')
+        return { kind: 'group', window: 'day', span: 2, offset: 0, metrics: ['cost'], rows: [{ id: 'friends', values: { cost: 1 } }] }
+      },
+    })
+    const spend = useSpendStore()
+    await spend.fetchDrilldown()
+    expect(spend.drilldownRows).toEqual([{ id: 'friends', values: { cost: 1 } }])
+    expect(spend.drilldownDisabled).toBe(false)
+  })
+
+  it('requests kind=user&group=X once drilled into a group', async () => {
+    mockRoutes({
+      totals: (url) => {
+        expect(url).toContain('kind=user')
+        expect(url).toContain('group=friends')
+        return { kind: 'user', window: 'day', span: 2, offset: 0, metrics: ['cost'], rows: [{ id: 'alice', values: { cost: 1 } }] }
+      },
+    })
+    const spend = useSpendStore()
+    spend.setSelection({ drill: 'group:friends' })
+    await spend.fetchDrilldown()
+    expect(spend.drilldownRows).toEqual([{ id: 'alice', values: { cost: 1 } }])
+  })
+
+  it('requests kind=usermodel&user=Y once drilled into a user', async () => {
+    mockRoutes({
+      totals: (url) => {
+        expect(url).toContain('kind=usermodel')
+        expect(url).toContain('user=alice')
+        return { kind: 'usermodel', window: 'day', span: 2, offset: 0, metrics: ['cost'], rows: [] }
+      },
+    })
+    const spend = useSpendStore()
+    spend.setSelection({ drill: 'user:alice' })
+    await spend.fetchDrilldown()
+    expect(spend.drilldownDisabled).toBe(false)
+  })
+
+  // P1 item 2: usermodel only accepts day/month (no hour bucket at all).
+  // The two tests above both pass with the default global range (7d ->
+  // window=day) regardless of whether a clamp exists at all — this is
+  // EXACTLY how the original bug (a bare, unclamped `window=hour` 400ing
+  // server-side) went unnoticed: the previous spec never exercised an
+  // hour-resolution global range against this request. This test asserts
+  // the EXACT window/span the URL carries, not just that it contains
+  // "kind=usermodel".
+  it('clamps an hour-resolution global range (24h) to day/month for kind=usermodel, never window=hour', async () => {
+    useFiltersStore().setFilters({ range: '24h' })
+    let requestedUrl = ''
+    mockRoutes({
+      totals: (url) => {
+        requestedUrl = url
+        return { kind: 'usermodel', window: 'day', span: 2, offset: 0, metrics: ['cost'], rows: [] }
+      },
+    })
+    const spend = useSpendStore()
+    spend.$patch({ drill: 'user:alice' })
+    await spend.fetchDrilldown()
+    expect(requestedUrl).toBe('/admin/api/usage/totals?kind=usermodel&window=day&span=7&user=alice')
+  })
+
+  it('sets drilldownDisabled on a 404 (admin.stats.userModel off) rather than surfacing an error', async () => {
+    mockedAdminFetch.mockImplementation((async (path: string) => {
+      if (path.startsWith('/admin/api/usage/totals')) throw new AdminApiError('user-model statistics are not enabled', 404)
+      throw new Error(`unexpected path ${path}`)
+    }) as typeof adminFetch)
+    // $patch, not setSelection: setSelection also fires a full refresh()
+    // cascade (including fetchModelRanking), which this test's mock does
+    // not answer — only the drilldown fetch itself is under test here.
+    const spend = useSpendStore()
+    spend.$patch({ drill: 'user:alice' })
+    await spend.fetchDrilldown()
+    expect(spend.drilldownDisabled).toBe(true)
+    expect(spend.error).toBe('')
+  })
+})
+
+describe('useSpendStore.setSelection', () => {
+  it('applies by/metric/drill together and triggers exactly one refresh', async () => {
+    mockRoutes({})
+    const spend = useSpendStore()
+    const refreshSpy = vi.spyOn(spend, 'refresh')
+    spend.setSelection({ by: 'provider', metric: 'req', drill: 'group:eng' })
+    expect(spend.by).toBe('provider')
+    expect(spend.metric).toBe('req')
+    expect(spend.drill).toBe('group:eng')
+    await vi.waitFor(() => expect(refreshSpy).toHaveBeenCalledTimes(1))
+  })
+
+  it('is a no-op (no refresh) when nothing actually changes', () => {
+    const spend = useSpendStore()
+    const refreshSpy = vi.spyOn(spend, 'refresh')
+    spend.setSelection({ by: 'model', metric: 'cost', drill: '' })
+    expect(refreshSpy).not.toHaveBeenCalled()
+  })
+})
diff --git a/webui/src/stores/spend.ts b/webui/src/stores/spend.ts
new file mode 100644
index 0000000..cc8ce87
--- /dev/null
+++ b/webui/src/stores/spend.ts
@@ -0,0 +1,495 @@
+import { defineStore } from 'pinia'
+
+import { AdminApiError, adminFetch } from '@/lib/api'
+import { currentMonthDaySpan } from '@/lib/burndown'
+import { sumGroupBudgetMicros } from '@/lib/kpi'
+import { createVisibilityPoller, type VisibilityPoller } from '@/lib/polling'
+import { dayOrMonthWindow, seriesUrl, totalsUrl } from '@/lib/range'
+import type { TotalsUrlParams } from '@/lib/range'
+import { other, stackTopN, sumByProvider, type Series } from '@/lib/series'
+import { useAuthStore } from '@/stores/auth'
+import { useDashboardStore } from '@/stores/dashboard'
+import { useFiltersStore } from '@/stores/filters'
+import type { AdminSeriesResponse, AdminTotalsResponse, AdminUsageModelsResponse, HistoryMetric, HistoryWindow } from '@/types/api'
+
+/** SPEND_BY is the Spend page's breakdown-dimension selector (redesign-plan.md section 3.1's `by` page param). */
+export const SPEND_BY = ['model', 'provider', 'group'] as const
+export type SpendBy = (typeof SPEND_BY)[number]
+
+/** isSpendBy is SPEND_BY's own runtime type guard, mirroring lib/range.ts's isRangeKey — the only place a hash-restored `by` value is checked against untrusted input. */
+export function isSpendBy(value: string): value is SpendBy {
+  return (SPEND_BY as readonly string[]).includes(value)
+}
+
+/** SPEND_METRICS is the Spend page's metric selector, in the plan's own display order (section 3.1: "metric=cost|req|tokin|tokout") — the same four values HistoryMetric already names, reused rather than redeclared. */
+export const SPEND_METRICS: HistoryMetric[] = ['cost', 'req', 'tokin', 'tokout']
+
+export const SPEND_METRIC_LABEL: Record<HistoryMetric, string> = {
+  cost: 'Cost',
+  req: 'Requests',
+  tokin: 'Tokens in',
+  tokout: 'Tokens out',
+}
+
+/** isSpendMetric guards a hash-restored `metric` param against HistoryMetric's own union. */
+export function isSpendMetric(value: string): value is HistoryMetric {
+  return (SPEND_METRICS as readonly string[]).includes(value)
+}
+
+/** How many of the by=model breakdown's ranked models get their OWN charted series before the remainder folds into "other" (redesign-plan.md section 3.3: "series for top 10 models"). */
+export const MODEL_BREAKDOWN_TOP_N = 10
+
+/**
+ * MODEL_RANKING_LIMIT is the shared model-ranking fetch's own limit —
+ * redesign-plan.md's own usageModelsMaxLimit ceiling (section 0 ground
+ * truth: "limit<=100"). ONE ranking fetch at this size serves three
+ * different Spend cards: the by=model chart (top MODEL_BREAKDOWN_TOP_N of
+ * these), PricingHealthTable (every row), and CostAvoidedCard's
+ * reference-model picker — rather than each fetching its own.
+ */
+const MODEL_RANKING_LIMIT = 100
+
+/** GET /admin/api/usage/series accepts at most this many `scope` params per request (redesign-plan.md section 1.3.iv: "scope repeated 1..100") — the by=provider/by=group breakdown fetches cap their own model/group id lists at this so a large fleet never trips the server's own 400. */
+const MAX_SERIES_SCOPES = 100
+
+/** How often the Spend page's own data (breakdown, ranking, burn-down, drilldown) re-polls while visible — slower than the 5s dashboard poll (stores/dashboard.ts), matching stores/history.ts's own REFRESH_MS for the identical reason: history buckets move on the timescale of the window itself, not every request. */
+const REFRESH_MS = 60_000
+
+/**
+ * useSpendStore drives the Spend page (redesign-plan.md section 3.3,
+ * replacing stores/history.ts): the cost/req/tokens breakdown chart (by
+ * model, provider, or group), the model ranking that breakdown and two
+ * other Spend cards (PricingHealthTable, CostAvoidedCard) all share, the
+ * current-month burn-down line, and the group -> user -> model attribution
+ * drilldown. Every fetch reads the GLOBAL filters store (range/cmp/scope)
+ * directly rather than taking them as action parameters — the same reason
+ * any Pinia store reads another store from inside an action (stores/
+ * dashboard.ts reads useAuthStore()) — so SpendPage.vue only needs to call
+ * refresh() again when a global filter OR this store's own `by`/`metric`/
+ * `drill` selection changes, never thread values through by hand.
+ *
+ * SCOPE NARROWING (filters.scope): when narrowed to a single group or user
+ * (`group:x`/`user:x`), the breakdown chart shows that ONE scope's own
+ * series directly — the `by` dimension has nothing left to break down once
+ * the reader has already picked one entity, and AttributionDrilldown below
+ * it is exactly the tool for descending further within it. When narrowed
+ * to a provider (`provider:x`), the breakdown is derived the same way
+ * by=provider already is (lib/series.ts's sumByProvider), pre-filtered to
+ * that one provider's own models — cost/req/tokin/tokout has no direct
+ * `provider:{name}` series scope (redesign-plan.md section 1.3.iv's metric
+ * x kind table). The burn-down line has no meaningful reading for a
+ * provider scope at all (a provider carries no configured budget) and is
+ * left empty in that case (`burndownAvailable` getter below) rather than a
+ * fabricated one.
+ */
+export const useSpendStore = defineStore('spend', {
+  state: () => ({
+    by: 'model' as SpendBy,
+    metric: 'cost' as HistoryMetric,
+    /** '' (top level, group list), 'group:{name}' (user list within that group), or 'user:{name}' (model list for that user) — AttributionDrilldown.vue's own breadcrumb state, mirrored from the `drill` page param (SpendPage.vue owns syncing it both ways). */
+    drill: '',
+
+    // --- breakdown chart (TimeSeriesChart, by/scope-driven) ---
+    buckets: [] as string[],
+    /** The charted breakdown series (top-N models, providers, or groups — or a single series when filters.scope narrows to one entity). Never includes the synthesized "other" bucket; see `otherPoints`. */
+    breakdown: [] as Series[],
+    /** by=model only: total minus the sum of the charted top-N (lib/series.ts's `other`) — null for every other `by`/scope combination, where nothing is left out of the chart. */
+    otherPoints: null as number[] | null,
+    totalPoints: [] as number[],
+    /** The same total, shifted back by filters.cmpSpec.offset buckets — null unless filters.cmpSpec.requested. */
+    comparisonPoints: null as number[] | null,
+    /**
+     * comparisonUnavailableReason (P3 item 19, Q5's "show a reason"): set
+     * when a comparison WAS requested (filters.cmpSpec.requested) but this
+     * store could not build one anyway — currently only the provider-scope
+     * case (fetchComparison's own doc comment: no direct series scope for
+     * cost/req/tokin/tokout on a `provider:{name}` scope, and doubling
+     * every provider-scope request through sumByProvider was not worth it
+     * for a reference overlay). Null whenever a comparison was not
+     * requested at all, or was requested and DID build successfully — a
+     * reader only needs this note when the dashed line they asked for is
+     * silently missing, not as a blanket status message.
+     */
+    comparisonUnavailableReason: null as string | null,
+
+    // --- model ranking: the by=model chart and CostAvoidedCard's reference-model picker ---
+    modelRanking: [] as AdminUsageModelsResponse['models'],
+    /**
+     * pricingHealthRanking (P3 item 21) is a SEPARATE ranking, always
+     * sorted by `req` — PricingHealthTable.vue's own "unpriced first"
+     * ordering needs the models with the most TRAFFIC, not whichever
+     * metric the reader currently has the Spend breakdown sorted by
+     * (`this.metric`). With more than MODEL_RANKING_LIMIT served models,
+     * sorting by `cost` (the default metric) cuts the ranking off at 100
+     * models ranked BY COST — and an unpriced model bills $0, so it is
+     * one of the FIRST rows dropped by that cutoff, defeating "unpriced
+     * first" for the operator who most needs to see it. Sorting by `req`
+     * instead still has a cutoff (a model with vanishingly few requests
+     * AND no price could still fall outside the top 100), but it no
+     * longer discards a row specifically BECAUSE it is unpriced.
+     */
+    pricingHealthRanking: [] as AdminUsageModelsResponse['models'],
+
+    // --- burn-down (BurnDownChart) ---
+    burndownBuckets: [] as string[],
+    /** Raw per-day cost (micro-USD), NOT yet cumulative — BurnDownChart.vue runs lib/burndown.ts's own `cumulative` over this, keeping the running-sum step in one place rather than duplicated between the store and the component. */
+    burndownPoints: [] as number[],
+    /** The scope's own configured cost/month budget in micro-USD, or null when none is configured (or the scope has no budget concept — see `burndownAvailable`). */
+    burndownBudgetMicros: null as number | null,
+
+    // --- attribution drilldown (AttributionDrilldown) ---
+    drilldownRows: [] as AdminTotalsResponse['rows'],
+    drilldownMetrics: [] as string[],
+    /** True once GET /admin/api/usage/totals reported this exact drill level as unavailable (usermodel with admin.stats.userModel off, adminTotalsResponse's own 404) — AttributionDrilldown.vue renders the hint naming the config key instead of an empty table. */
+    drilldownDisabled: false,
+
+    loading: false,
+    error: '',
+    /** breakdownReqId/rankingReqId/burndownReqId/drilldownReqId are FOUR independent latest-request-wins counters (stores/history.ts's own seriesReqId precedent), one per concern — unlike history.ts's tabs, every one of these fetches concurrently on a single Spend page render, so a single shared counter would make an in-flight ranking fetch spuriously discard a still-relevant breakdown fetch (or vice versa) merely for starting first. */
+    breakdownReqId: 0,
+    rankingReqId: 0,
+    pricingHealthReqId: 0,
+    burndownReqId: 0,
+    drilldownReqId: 0,
+    poller: undefined as VisibilityPoller | undefined,
+  }),
+  getters: {
+    /** burndownAvailable is false only for a provider-narrowed scope (see this store's own doc comment) — BurnDownChart.vue renders "not available for this scope" instead of an empty chart. */
+    burndownAvailable: (): boolean => burndownScopeParam(useFiltersStore().scope) !== null,
+  },
+  actions: {
+    /** setSelection applies by/metric/drill as one atomic change (stores/history.ts's own setSelection precedent) and fires exactly one refresh(), rather than each field's own setter independently clearing state and refetching. */
+    setSelection(next: { by?: SpendBy; metric?: HistoryMetric; drill?: string }): void {
+      let changed = false
+      if (next.by !== undefined && next.by !== this.by) {
+        this.by = next.by
+        changed = true
+      }
+      if (next.metric !== undefined && next.metric !== this.metric) {
+        this.metric = next.metric
+        changed = true
+      }
+      if (next.drill !== undefined && next.drill !== this.drill) {
+        this.drill = next.drill
+        changed = true
+      }
+      if (!changed) return
+      void this.refresh()
+    },
+    /**
+     * refresh re-fetches every section this store owns against the
+     * CURRENT by/metric/drill selection and the current global filters —
+     * the one action both the 60s poller and any selection/filter change
+     * call. fetchBreakdown is sequenced AFTER fetchModelRanking (not run
+     * in the same Promise.all) because by=model/by=provider both read
+     * `this.modelRanking` to decide which ids to chart — starting them
+     * concurrently would race fetchBreakdown against a still-in-flight (or
+     * still-empty, on first load) ranking. fetchBurndown/fetchDrilldown
+     * depend on neither and run fully in parallel with that chain.
+     */
+    async refresh(): Promise<void> {
+      const auth = useAuthStore()
+      if (!auth.isAuthenticated) return
+      await Promise.all([
+        this.fetchModelRanking().then(() => this.fetchBreakdown()),
+        this.fetchPricingHealthRanking(),
+        this.fetchBurndown(),
+        this.fetchDrilldown(),
+      ])
+    },
+    async fetchModelRanking(): Promise<void> {
+      const filters = useFiltersStore()
+      const requestId = ++this.rankingReqId
+      try {
+        const res = await adminFetch<AdminUsageModelsResponse>(
+          `/admin/api/usage/models?metric=${this.metric}&window=${filters.window}&span=${filters.span}&limit=${MODEL_RANKING_LIMIT}&detail=1`,
+        )
+        if (requestId !== this.rankingReqId) return
+        this.modelRanking = res.models
+      } catch (err) {
+        if (requestId !== this.rankingReqId) return
+        if (isAuthRejection(err)) return
+        this.error = messageOf(err)
+      }
+    },
+    /** fetchPricingHealthRanking is pricingHealthRanking's own fetch — always metric=req, independent of `this.metric` (see that field's own doc comment, P3 item 21). Runs in parallel with fetchModelRanking in refresh(), not chained after it: neither depends on the other's result. */
+    async fetchPricingHealthRanking(): Promise<void> {
+      const filters = useFiltersStore()
+      const requestId = ++this.pricingHealthReqId
+      try {
+        const res = await adminFetch<AdminUsageModelsResponse>(
+          `/admin/api/usage/models?metric=req&window=${filters.window}&span=${filters.span}&limit=${MODEL_RANKING_LIMIT}&detail=1`,
+        )
+        if (requestId !== this.pricingHealthReqId) return
+        this.pricingHealthRanking = res.models
+      } catch (err) {
+        if (requestId !== this.pricingHealthReqId) return
+        if (isAuthRejection(err)) return
+        this.error = messageOf(err)
+      }
+    },
+    async fetchBreakdown(): Promise<void> {
+      const filters = useFiltersStore()
+      const requestId = ++this.breakdownReqId
+      this.loading = true
+      try {
+        if (filters.scope === 'all') {
+          await this.fetchBreakdownFleetWide(filters.window, filters.span, requestId)
+        } else if (filters.scope.startsWith('group:') || filters.scope.startsWith('user:')) {
+          await this.fetchBreakdownSingleScope(filters.scope, filters.window, filters.span, requestId)
+        } else {
+          // provider:{name} — no direct cost/req/tokin/tokout series scope
+          // (see this store's own doc comment); derive from the model
+          // ranking's own ids, pre-filtered to that one provider.
+          await this.fetchBreakdownProviderScope(filters.scope.slice('provider:'.length), filters.window, filters.span, requestId)
+        }
+        if (requestId !== this.breakdownReqId) return
+        this.error = ''
+        if (filters.cmpSpec.requested) {
+          await this.fetchComparison(filters.scope, filters.window, filters.span, filters.cmpSpec.offset, requestId)
+        } else {
+          this.comparisonPoints = null
+          this.comparisonUnavailableReason = null
+        }
+      } catch (err) {
+        if (requestId !== this.breakdownReqId) return
+        if (isAuthRejection(err)) return
+        this.error = messageOf(err)
+      } finally {
+        if (requestId === this.breakdownReqId) this.loading = false
+      }
+    },
+    /**
+     * fetchBreakdownFleetWide honors `this.by` exactly (model/provider/
+     * group breakdown) — the ordinary, unscoped Spend view. The fleet-wide
+     * TOTAL is always fetched in its own single-scope request first (never
+     * folded into the breakdown request itself): by=provider/by=group can
+     * legitimately need up to MAX_SERIES_SCOPES ids on their own, and
+     * mixing 'total' into that same request would risk tipping it over
+     * the server's own scope-count cap.
+     */
+    async fetchBreakdownFleetWide(window: HistoryWindow, span: number, requestId: number): Promise<void> {
+      const totalRes = await this.fetchSeries(['total'], this.metric, window, span, 0)
+      if (requestId !== this.breakdownReqId) return
+      this.buckets = totalRes.buckets
+      const total = totalRes.series.find((s) => s.scope === 'total')?.points ?? new Array<number>(totalRes.buckets.length).fill(0)
+      this.totalPoints = total
+
+      if (this.by === 'model') {
+        const ids = this.modelRanking.slice(0, MODEL_BREAKDOWN_TOP_N).map((m) => `model:${m.id}`)
+        if (ids.length === 0) {
+          this.breakdown = []
+          this.otherPoints = other(total, [])
+          return
+        }
+        const res = await this.fetchSeries(ids, this.metric, window, span, 0)
+        if (requestId !== this.breakdownReqId) return
+        const top = stackTopN(res.series, MODEL_BREAKDOWN_TOP_N)
+        this.breakdown = top
+        this.otherPoints = other(total, top)
+        return
+      }
+
+      if (this.by === 'provider') {
+        const ids = this.modelRanking.slice(0, MAX_SERIES_SCOPES).map((m) => `model:${m.id}`)
+        if (ids.length === 0) {
+          this.breakdown = []
+          this.otherPoints = null
+          return
+        }
+        const res = await this.fetchSeries(ids, this.metric, window, span, 0)
+        if (requestId !== this.breakdownReqId) return
+        this.breakdown = sumByProvider(res.series)
+        this.otherPoints = null
+        return
+      }
+
+      // by === 'group': one series per currently configured group, from
+      // GET /admin/api/usage/totals?kind=group (the authoritative group
+      // list) for the id list, then a real time series per group id.
+      const groupsRes = await adminFetch<AdminTotalsResponse>(totalsUrl({ kind: 'group', window, span, metrics: [this.metric] }))
+      if (requestId !== this.breakdownReqId) return
+      const groupIds = groupsRes.rows.slice(0, MAX_SERIES_SCOPES).map((r) => `group:${r.id}`)
+      if (groupIds.length === 0) {
+        this.breakdown = []
+        this.otherPoints = null
+        return
+      }
+      const res = await this.fetchSeries(groupIds, this.metric, window, span, 0)
+      if (requestId !== this.breakdownReqId) return
+      this.breakdown = res.series
+      this.otherPoints = null
+    },
+    /** fetchBreakdownSingleScope renders exactly one line — the narrowed group/user itself — ignoring `by` (nothing left to break down within one already-chosen entity). */
+    async fetchBreakdownSingleScope(scope: string, window: HistoryWindow, span: number, requestId: number): Promise<void> {
+      const res = await this.fetchSeries([scope], this.metric, window, span, 0)
+      if (requestId !== this.breakdownReqId) return
+      this.buckets = res.buckets
+      const points = res.series.find((s) => s.scope === scope)?.points ?? new Array<number>(res.buckets.length).fill(0)
+      this.breakdown = [{ scope, points }]
+      this.otherPoints = null
+      this.totalPoints = points
+    },
+    /** fetchBreakdownProviderScope sums the ranking's own model ids under this one provider (lib/series.ts's sumByProvider, applied to a pre-filtered set) — see this store's own doc comment on why a provider scope cannot use a direct series scope for cost/req/tokin/tokout. */
+    async fetchBreakdownProviderScope(providerName: string, window: HistoryWindow, span: number, requestId: number): Promise<void> {
+      const ids = this.modelRanking
+        .filter((m) => m.id.startsWith(`${providerName}/`))
+        .slice(0, MAX_SERIES_SCOPES)
+        .map((m) => `model:${m.id}`)
+      if (ids.length === 0) {
+        this.buckets = []
+        this.breakdown = []
+        this.otherPoints = null
+        this.totalPoints = []
+        return
+      }
+      const res = await this.fetchSeries(ids, this.metric, window, span, 0)
+      if (requestId !== this.breakdownReqId) return
+      this.buckets = res.buckets
+      const [summed] = sumByProvider(res.series)
+      const points = summed?.points ?? new Array<number>(res.buckets.length).fill(0)
+      this.breakdown = [{ scope: `provider:${providerName}`, points }]
+      this.otherPoints = null
+      this.totalPoints = points
+    },
+    async fetchComparison(scope: string, window: HistoryWindow, span: number, offset: number, requestId: number): Promise<void> {
+      const totalScope = scope === 'all' ? 'total' : scope.startsWith('provider:') ? null : scope
+      if (totalScope === null) {
+        // A provider scope's comparison line would need the same
+        // sumByProvider derivation as the primary series — skipped rather
+        // than doubling every provider-scope request; the dashed line
+        // simply does not render (TimeSeriesChart's own
+        // `comparisonDatasets` defaults to empty). Q5 requires a reason
+        // when a requested comparison is unavailable (P3 item 19) — this
+        // used to leave the reader guessing why "vs previous period" was
+        // pressed but no dashed line appeared.
+        this.comparisonPoints = null
+        this.comparisonUnavailableReason = 'Comparison is not available for a single-provider scope.'
+        return
+      }
+      const res = await this.fetchSeries([totalScope], this.metric, window, span, offset)
+      if (requestId !== this.breakdownReqId) return
+      this.comparisonPoints = res.series.find((s) => s.scope === totalScope)?.points ?? null
+      this.comparisonUnavailableReason = null
+    },
+    async fetchSeries(scope: string[], metric: string, window: HistoryWindow, span: number, offset: number): Promise<AdminSeriesResponse> {
+      return adminFetch<AdminSeriesResponse>(seriesUrl({ scope, metric, window, span, offset: offset || undefined }))
+    },
+    async fetchBurndown(): Promise<void> {
+      const filters = useFiltersStore()
+      const requestId = ++this.burndownReqId
+      const scope = burndownScopeParam(filters.scope)
+      if (scope === null) {
+        this.burndownBuckets = []
+        this.burndownPoints = []
+        this.burndownBudgetMicros = null
+        return
+      }
+      try {
+        const span = currentMonthDaySpan(new Date())
+        const res = await this.fetchSeries([scope], 'cost', 'day', span, 0)
+        if (requestId !== this.burndownReqId) return
+        this.burndownBuckets = res.buckets
+        this.burndownPoints = res.series.find((s) => s.scope === scope)?.points ?? new Array<number>(res.buckets.length).fill(0)
+        this.burndownBudgetMicros = burndownBudgetMicros(scope)
+      } catch (err) {
+        if (requestId !== this.burndownReqId) return
+        if (isAuthRejection(err)) return
+        this.error = messageOf(err)
+      }
+    },
+    async fetchDrilldown(): Promise<void> {
+      const filters = useFiltersStore()
+      const requestId = ++this.drilldownReqId
+      const level = drilldownLevel(this.drill)
+      try {
+        // usermodel only accepts day/month (redesign-plan.md section
+        // 1.3.v) — clamped via lib/range.ts's shared dayOrMonthWindow so
+        // an hour-resolution global range (24h/48h) never 400s BEFORE the
+        // server's own 404-when-disabled feature gate has a chance to run
+        // (stats_read.go: the window check runs first), which previously
+        // masked the "enable admin.stats.userModel" hint behind a generic
+        // error even when the feature really was off.
+        const params: TotalsUrlParams =
+          level.kind === 'usermodel'
+            ? { kind: 'usermodel', ...dayOrMonthWindow(filters.window, filters.span), user: level.user }
+            : level.kind === 'user'
+              ? { kind: 'user', window: filters.window, span: filters.span, group: level.group, metrics: ['req', 'tokin', 'tokout', 'cost'] }
+              : { kind: 'group', window: filters.window, span: filters.span, metrics: ['req', 'tokin', 'tokout', 'cost'] }
+        const res = await adminFetch<AdminTotalsResponse>(totalsUrl(params))
+        if (requestId !== this.drilldownReqId) return
+        this.drilldownRows = res.rows
+        this.drilldownMetrics = res.metrics
+        this.drilldownDisabled = false
+      } catch (err) {
+        if (requestId !== this.drilldownReqId) return
+        if (isAuthRejection(err)) return
+        if (err instanceof AdminApiError && err.status === 404) {
+          // usermodel with admin.stats.userModel off (redesign-plan.md
+          // section 1.3.v) — a known, named-in-the-hint state, not an
+          // error the reader needs to see in the status line.
+          this.drilldownRows = []
+          this.drilldownMetrics = []
+          this.drilldownDisabled = true
+          return
+        }
+        this.error = messageOf(err)
+      }
+    },
+    startPolling(): void {
+      if (this.poller) return
+      this.poller = createVisibilityPoller({ intervalMs: REFRESH_MS, tick: () => void this.refresh() })
+      this.poller.start()
+    },
+    stopPolling(): void {
+      this.poller?.stop()
+      this.poller = undefined
+    },
+  },
+})
+
+/** drilldownLevel derives AttributionDrilldown's current GET /admin/api/usage/totals request shape from the `drill` breadcrumb state (see useSpendStore's own state doc comment on `drill`). */
+function drilldownLevel(drill: string): { kind: 'group' } | { kind: 'user'; group: string } | { kind: 'usermodel'; user: string } {
+  if (drill === '') return { kind: 'group' }
+  if (drill.startsWith('group:')) return { kind: 'user', group: drill.slice('group:'.length) }
+  return { kind: 'usermodel', user: drill.slice('user:'.length) }
+}
+
+/** burndownScopeParam maps the global scope filter to the /usage/series scope this store's burn-down line requests — null for a provider scope, which has no cost series and no budget concept (see useSpendStore's own doc comment). */
+function burndownScopeParam(filtersScope: string): string | null {
+  if (filtersScope === 'all') return 'total'
+  if (filtersScope.startsWith('group:') || filtersScope.startsWith('user:')) return filtersScope
+  return null
+}
+
+/**
+ * burndownBudgetMicros resolves the configured cost/month budget (micro-
+ * USD) for the burn-down line's own scope: the fleet-wide sum-of-group
+ * budgets (Q2/DECISIONS: lib/kpi.ts's sumGroupBudgetMicros) for `total`,
+ * or that one group's/user's own configured costPerMonthUSD limit
+ * otherwise — read from stores/dashboard.ts's already-polled overview/
+ * usage data rather than a second network round trip.
+ */
+function burndownBudgetMicros(scope: string): number | null {
+  const dashboard = useDashboardStore()
+  if (scope === 'total') {
+    const total = sumGroupBudgetMicros(dashboard.overview?.groups ?? [])
+    return total > 0 ? total : null
+  }
+  if (scope.startsWith('group:')) {
+    const name = scope.slice('group:'.length)
+    const usd = dashboard.overview?.groups.find((g) => g.name === name)?.limits?.costPerMonthUSD
+    return usd && usd > 0 ? Math.round(usd * 1_000_000) : null
+  }
+  const name = scope.slice('user:'.length)
+  const usd = dashboard.usage?.users.find((u) => u.id === name)?.limits?.costPerMonthUSD
+  return usd && usd > 0 ? Math.round(usd * 1_000_000) : null
+}
+
+function isAuthRejection(err: unknown): boolean {
+  return err instanceof AdminApiError && (err.status === 401 || err.status === 403)
+}
+
+function messageOf(err: unknown): string {
+  return err instanceof Error ? err.message : String(err)
+}
diff --git a/webui/src/types/api.ts b/webui/src/types/api.ts
index 6d79155..0b13755 100644
--- a/webui/src/types/api.ts
+++ b/webui/src/types/api.ts
@@ -78,6 +78,9 @@ export interface AdminProvenanceView {
   tokens: number
 }
 
+/** The three discovery circuit-breaker states AdminProviderView.healthState and AdminCatalogProvider.healthState both carry (see AdminProviderView.healthState's own doc comment). Named so both interfaces reference the same union instead of two copies drifting apart. */
+export type ProviderHealthState = 'closed' | 'open' | 'half-open'
+
 export interface AdminProviderView {
   name: string
   type: string
@@ -113,7 +116,7 @@ export interface AdminProviderView {
    * fine still reads 'open' here. A provider with discovery disabled, or
    * one that has never failed a refresh, always reads 'closed'.
    */
-  healthState: 'closed' | 'open' | 'half-open'
+  healthState: ProviderHealthState
   /**
    * openUntil is when this provider's breaker will next attempt a
    * half-open probe (admin.go: adminProviderView.OpenUntil). The unset
@@ -215,6 +218,31 @@ export interface AdminAliasView {
   modelMeta: AdminModelMetaView
 }
 
+/**
+ * Which admin-stats features this deployment has opt-in enabled
+ * (admin.go: adminFeaturesView, AdminConfig.Stats — llmgateway.go). Every
+ * new-endpoint store/page gates its own fetch and empty-state copy on
+ * these rather than guessing from data shape: a false userModelStats, for
+ * instance, means GET /admin/api/usage/totals?kind=usermodel 404s, not
+ * that it happens to return no rows yet.
+ */
+export interface AdminFeaturesView {
+  userModelStats: boolean
+  latencyStats: boolean
+  cacheStats: boolean
+  lastSeen: boolean
+  failover: boolean
+}
+
+/** Model-count breakdown by billing price source across the catalog (admin.go: adminPricingSummaryView) — the Home page's "N unpriced models" warning reads `unpriced` directly. */
+export interface AdminPricingSummary {
+  override: number
+  builtin: number
+  litellm: number
+  free: number
+  unpriced: number
+}
+
 /** GET /admin/api/overview (admin.go: adminOverviewResponse). */
 export interface AdminOverviewResponse {
   version: string
@@ -246,6 +274,8 @@ export interface AdminOverviewResponse {
   redis: AdminRedisView
   cache: AdminCacheView
   retry: AdminRetryView
+  features: AdminFeaturesView
+  pricing: AdminPricingSummary
 }
 
 export interface AdminUsageEntryView {
@@ -295,6 +325,14 @@ export interface AdminUsageEntryView {
    */
   rejectionsPerDay: number
   storeDown?: boolean
+  /**
+   * Unix seconds this scope last made a request, fleet-wide (admin.go:
+   * adminUsageEntryView.LastSeen — the last-seen counter family,
+   * throttled per-replica to one write per 60s). 0 or omitted means
+   * never seen, or admin.stats.lastSeen is off (AdminFeaturesView.
+   * lastSeen) — never render 0 as an epoch date.
+   */
+  lastSeen?: number
 }
 
 /** GET /admin/api/usage (admin.go: adminUsageResponse). */
@@ -310,18 +348,11 @@ export type HistoryMetric = 'req' | 'tokin' | 'tokout' | 'cost'
 /** The three window values GET /admin/api/usage/history accepts. */
 export type HistoryWindow = 'hour' | 'day' | 'month'
 
-export interface UsageHistoryPoint {
-  bucket: string
-  value: number
-}
-
-/** GET /admin/api/usage/history (admin.go: usageHistoryResponse). */
-export interface UsageHistoryResponse {
-  scope: string
-  metric: string
-  window: string
-  points: UsageHistoryPoint[]
-}
+// UsageHistoryPoint/UsageHistoryResponse (GET /admin/api/usage/history)
+// were removed (P3 item 25, dead code): the redesigned shell reads
+// GET /admin/api/usage/series instead (AdminSeriesResponse below) —
+// grep confirms no remaining importer since stores/history.ts (+its own
+// spec) was deleted (redesign-plan.md section 3.5).
 
 /**
  * One ranked model in GET /admin/api/usage/models (admin.go:
@@ -343,6 +374,17 @@ export interface UsageHistoryResponse {
  * present 0 means known-free" convention, never infer either from a value
  * being falsy).
  */
+/**
+ * Which billing rule actually priced a model (admin.go/pricing.go:
+ * billingPriceSource) — an explicit per-model override, the built-in
+ * LiteLLM-derived table, a live LiteLLM lookup, a configured free model
+ * (modelMeta.free), or unpriced (billed as 0, no rule matched). This is
+ * the BILLING truth, distinct from a ':free' suffix's display-only
+ * relabeling (routes_unified.go) — a ':free' model still reports its
+ * real priceSource here even though it displays as free.
+ */
+export type PriceSource = 'override' | 'builtin' | 'litellm' | 'free' | 'unpriced'
+
 export interface AdminUsageModelEntry {
   id: string
   value: number
@@ -351,6 +393,13 @@ export interface AdminUsageModelEntry {
   tokensOut?: number
   costMicroUsd?: number
   free?: boolean
+  /** Cache hits/savings for this model today — present only when `detail=1` AND AdminFeaturesView.cacheStats is on (admin.go). cacheSavedMicroUsd is micro-USD, same unit as costMicroUsd. */
+  cacheHits?: number
+  cacheSavedMicroUsd?: number
+  /** Count of 402 (unpriced-refusal) responses for this model today — `detail=1` only (admin.go). */
+  r402?: number
+  /** This model's billing price source — `detail=1` only (admin.go). */
+  priceSource?: PriceSource
 }
 
 /**
@@ -384,6 +433,13 @@ export interface AdminUsageModelsResponse {
    */
   detail?: boolean
   models: AdminUsageModelEntry[]
+  /**
+   * How many buckets before the most recent one this ranking's span was
+   * shifted back by (admin.go: parseUsageModelsOffset) — 0 for "ending
+   * now", the ordinary case every pre-offset caller still gets. Always
+   * echoed back, mirroring `span`'s own convention above.
+   */
+  offset: number
 }
 
 /** One MCP-server or agent target's current-window request counters (admin.go: adminTargetCountersView) — requests only, no tokens or cost. */
@@ -518,3 +574,212 @@ export interface AdminEventsResponse {
   capacity: number
   degraded?: boolean
 }
+/**
+ * GET /admin/api/usage/series (admin.go: adminSeriesResponse — phase 2
+ * redesign). One or more scopes' bucketed time series for a single
+ * metric, aligned on the SAME `buckets` array — every entry in `series`
+ * has exactly `buckets.length` points, index-for-index. `unknown` names
+ * every requested scope id the server could not resolve (never throws
+ * for one bad id among several valid ones); `series` never nil.
+ */
+export interface AdminSeriesResponse {
+  metric: string
+  window: HistoryWindow
+  span: number
+  offset: number
+  /** Oldest first — the same chronological order formatBucketLabel (lib/format.ts) already expects. */
+  buckets: string[]
+  series: { scope: string; points: number[] }[]
+  unknown: string[]
+}
+
+/** The five aggregation kinds GET /admin/api/usage/totals accepts (admin.go: adminTotalsResponse.Kind). */
+export type TotalsKind = 'user' | 'group' | 'usermodel' | 'modeluser' | 'targetcaller'
+
+/**
+ * GET /admin/api/usage/totals (admin.go: adminTotalsResponse — phase 2
+ * redesign). A ranked table of ids (users, groups, user×model pairs,
+ * model×user pairs, or target×caller pairs) with one or more summed
+ * metrics each. Rows with every requested metric at 0 are dropped
+ * server-side; `truncated` is set only when `limit` cut off further,
+ * non-zero rows.
+ */
+export interface AdminTotalsResponse {
+  kind: TotalsKind
+  window: HistoryWindow
+  span: number
+  offset: number
+  metrics: string[]
+  /** id is a bare user/group/model id for kind 'user'/'group', or a composite id ("targetcaller": "mcp/fetch/alice") for the compound kinds — see admin.go's own id-building for the exact join rule per kind. */
+  rows: { id: string; values: Record<string, number> }[]
+  truncated?: boolean
+}
+
+/** The two `kind` values GET /admin/api/performance accepts, and the two windows it supports — a strict subset of HistoryWindow (no 'month': performance is a live-operations view, not a monthly rollup). */
+export type PerfKind = 'provider' | 'model'
+export type PerfWindow = Extract<HistoryWindow, 'hour' | 'day'>
+
+/**
+ * One provider's or model's performance row (admin.go: adminPerfRow).
+ * Percentile fields (p50/p95/p99Ms, ttfbP50/95Ms) are present only when
+ * AdminFeaturesView.latencyStats is on AND this id has at least one
+ * observation in the requested span — undefined never means "0ms".
+ * Attempts/failures are always present (admin.stats.latency is not
+ * required for them). `overflow` marks a row whose slowest bucket
+ * exceeded the latency histogram's own ceiling (metrics.go) — its
+ * percentile fields, if present, are a floor, not an exact value.
+ */
+export interface AdminPerfRow {
+  id: string
+  p50Ms?: number
+  p95Ms?: number
+  p99Ms?: number
+  ttfbP50Ms?: number
+  ttfbP95Ms?: number
+  count: number
+  attempts: number
+  failures: number
+  timeouts?: number
+  failovers?: number
+  overflow?: boolean
+}
+
+/**
+ * GET /admin/api/performance (admin.go: adminPerfResponse — phase 2
+ * redesign). `rows` is the ranked-by-id table (the default view);
+ * `buckets`/`points` are populated only when the request asked for
+ * `series=1` against a single id, one AdminPerfRow per bucket (its own
+ * `id` field is then the bucket string, not the provider/model id).
+ * `rows` is optional: the server omits it (`omitempty`) on an empty
+ * result (a quiet span or a fresh gateway) rather than sending `[]` —
+ * every read site must default to `[]`.
+ */
+export interface AdminPerfResponse {
+  kind: PerfKind
+  window: PerfWindow
+  span: number
+  offset: number
+  rows?: AdminPerfRow[]
+  buckets?: string[]
+  points?: AdminPerfRow[]
+  latencyEnabled: boolean
+}
+
+/**
+ * One provider's one model's resolved catalog entry (admin.go:
+ * adminCatalogModel — phase 2 redesign). `priceSource`/`displayFree`
+ * mirror AdminUsageModelEntry's own detail fields, but computed for
+ * EVERY catalog model, not just ones with observed traffic — the Models
+ * page's pricing-health table joins this against the usage ranking.
+ *
+ * `inputPerMTokUsd`/`outputPerMTokUsd` are the ACTUAL BILLED rate for
+ * `priceSource` (Go's own billingPriceSource, pricing.go) — the exact
+ * price a real request against this model gets charged, never a
+ * separately-resolved display price. Both are undefined for
+ * `priceSource: 'free'` or `'unpriced'` (nothing to report), and set for
+ * every other source. `contextTokens` is a SEPARATE, display-only
+ * resolution (admin.go's buildAdminModelMetaView — the same one GET
+ * /admin/api/overview's own AdminModelMetaView carries), since a
+ * context window is not a billing concept. N1 (verify-redesign-
+ * final.md): an earlier version filled the two price fields from that
+ * same display resolution instead, so a `pricing:` override with no
+ * separate modelMeta/discovery price reported `priceSource: 'override'`
+ * alongside undefined prices — CostAvoidedCard's pickReferenceModel
+ * (lib/cost-avoided.ts) and PricingHealthTable both read these fields
+ * assuming they agree with `priceSource`, and broke for exactly that
+ * model.
+ */
+export interface AdminCatalogModel {
+  id: string
+  model: string
+  contextTokens?: number
+  inputPerMTokUsd?: number
+  outputPerMTokUsd?: number
+  priceSource: PriceSource
+  /** True for a ':free' suffix model (routes_unified.go) — display-only relabeling; billing still follows `priceSource` unchanged. */
+  displayFree?: boolean
+  aliases?: string[]
+}
+
+/** One provider's full catalog listing (admin.go: adminCatalogProvider — phase 2 redesign), on-demand only (never part of the 5s overview poll). */
+export interface AdminCatalogProvider {
+  lastRefresh: string
+  openUntil: string
+  name: string
+  type: string
+  healthState: ProviderHealthState
+  models: AdminCatalogModel[]
+  discoveryEnabled: boolean
+}
+
+/** GET /admin/api/catalog (admin.go: adminCatalogResponse — phase 2 redesign). On-demand/stale-cached, never polled every 5s (Q12). */
+export interface AdminCatalogResponse {
+  providers: AdminCatalogProvider[]
+  aliases: AdminAliasView[]
+}
+
+/**
+ * One configured user's consumer-directory row (admin.go:
+ * adminConsumerUser — phase 2 redesign). `source` is 'inline' (defined
+ * directly in the plugin config) or 'file' (loaded from users.file);
+ * `providers`/`models` are this user's OWN personal grant, distinct from
+ * anything their group(s) already allow.
+ */
+export interface AdminConsumerUser {
+  limits?: LimitsConfig
+  name: string
+  source: 'inline' | 'file'
+  groups: string[]
+  providers?: string[]
+  models?: string[]
+  admin?: boolean
+}
+
+/** How many of a provider's models a group can reach vs. how many that provider has (admin.go: adminModelAccessCount) — the Access Matrix's per-cell "n/m models" reading. */
+export interface AdminModelAccessCount {
+  allowed: number
+  total: number
+}
+
+/**
+ * One configured group's consumer-directory + access row (admin.go:
+ * adminConsumerGroup — phase 2 redesign). `allowedProviders` is never
+ * nil (empty means every configured provider); `modelAccess` is keyed by
+ * provider name.
+ */
+export interface AdminConsumerGroup {
+  limits?: LimitsConfig
+  name: string
+  providers?: string[]
+  models?: string[]
+  mcpServers?: string[]
+  agents?: string[]
+  passthroughPaths?: string[]
+  allowedProviders: string[]
+  modelAccess: Record<string, AdminModelAccessCount>
+  memberCount: number
+}
+
+/** GET /admin/api/consumers (admin.go: adminConsumersResponse — phase 2 redesign). `usersFile` is the configured path only, never its contents (Risks, redesign-plan.md section 6). */
+export interface AdminConsumersResponse {
+  users: AdminConsumerUser[]
+  groups: AdminConsumerGroup[]
+  usersFile?: string
+}
+
+/**
+ * GET /admin/api/config (admin.go: adminConfigResponse — phase 2
+ * redesign). `config` is the FULL plugin config after redactConfig's
+ * recursive walk: every apiKey/password literal replaced with
+ * "[redacted]", an "env:NAME"/"file:/path" indirection kept verbatim,
+ * and every baseUrl/url stripped of embedded userinfo credentials — safe
+ * to render as-is (Config page's ConfigTree.vue), never re-sanitized
+ * client-side.
+ */
+export interface AdminConfigResponse {
+  config: Record<string, unknown>
+  warnings: string[]
+  features: AdminFeaturesView
+  version: string
+}
+