 A=d[k];let P=!1;if(p(A,w,b,d,h,m)&&(P=!0),P){g.add(k),S=!0;break}}if(!S)return!1}return!0}function c(d,h,p,m){return h.size===0?!0:d instanceof Set?u([...d],[...h],p,m):!1}return Hv.isMatchWith=n,Hv}var T_;function DA(){if(T_)return qv;T_=1;const e=P4();function t(r,n){return e.isMatchWith(r,n,()=>{})}return qv.isMatch=t,qv}var N_;function E4(){if(N_)return Mv;N_=1;const e=k4(),t=DA();function r(n){return n=e.cloneDeep(n),i=>t.isMatch(i,n)}return Mv.matches=r,Mv}var Gv={},Yv={},Xv={},I_;function O4(){if(I_)return Xv;I_=1;const e=zy(),t=TA(),r=NA();function n(i,a){return r.cloneDeepWith(i,(s,u,c,d)=>{const h=a==null?void 0:a(s,u,c,d);if(h!==void 0)return h;if(typeof i=="object"){if(e.getTag(i)==="[object Object]"&&typeof i.constructor!="function"){const p={};return d.set(i,p),r.copyProperties(p,i,c,d),p}switch(Object.prototype.toString.call(i)){case t.numberTag:case t.stringTag:case t.booleanTag:{const p=new i.constructor(i==null?void 0:i.valueOf());return r.copyProperties(p,i),p}case t.argumentsTag:{const p={};return r.copyProperties(p,i),p.length=i.length,p[Symbol.iterator]=i[Symbol.iterator],p}default:return}}})}return Xv.cloneDeepWith=n,Xv}var R_;function A4(){if(R_)return Yv;R_=1;const e=O4();function t(r){return e.cloneDeepWith(r)}return Yv.cloneDeep=t,Yv}var Jv={},Qv={},D_;function MA(){if(D_)return Qv;D_=1;const e=/^(?:0|[1-9]\d*)$/;function t(r,n=Number.MAX_SAFE_INTEGER){switch(typeof r){case"number":return Number.isInteger(r)&&r>=0&&r<n;case"symbol":return!1;case"string":return e.test(r)}}return Qv.isIndex=t,Qv}var Zv={},M_;function C4(){if(M_)return Zv;M_=1;const e=zy();function t(r){return r!==null&&typeof r=="object"&&e.getTag(r)==="[object Arguments]"}return Zv.isArguments=t,Zv}var $_;function j4(){if($_)return Jv;$_=1;const e=SA(),t=Dy(),r=MA(),n=C4();function i(a,s){let u;if(Array.isArray(s)?u=s:typeof s=="string"&&e.isDeepKey(s)&&(a==null?void 0:a[s])==null?u=t.toPath(s):u=[s],u.length===0)return!1;let c=a;for(let d=0;d<u.length;d++){const h=u[d];if((c==null||!Object.hasOwn(c,h))&&!((Array.isArray(c)||n.isArguments(c))&&r.isIndex(h)&&h<c.length))return!1;c=c[h]}return!0}return Jv.has=i,Jv}var L_;function T4(){if(L_)return Gv;L_=1;const e=Ry(),t=My(),r=DA(),n=A4(),i=j4();function a(s,u){switch(typeof s){case"object":Object.is(s==null?void 0:s.valueOf(),-0)&&(s="-0");break;case"number":s=e.toKey(s);break}return u=n.cloneDeep(u),function(c){const d=t.get(c,s);return d===void 0?i.has(c,s):u===void 0?d===void 0:r.isMatch(d,u)}}return Gv.matchesProperty=a,Gv}var z_;function N4(){if(z_)return Rv;z_=1;const e=CA(),t=w4(),r=E4(),n=T4();function i(a){if(a==null)return e.identity;switch(typeof a){case"function":return a;case"object":return Array.isArray(a)&&a.length===2?n.matchesProperty(a[0],a[1]):r.matches(a);case"string":case"symbol":case"number":return t.property(a)}}return Rv.iteratee=i,Rv}var em={},tm={},rm={},U_;function I4(){if(U_)return rm;U_=1;function e(t){return Number.isSafeInteger(t)&&t>=0}return rm.isLength=e,rm}var B_;function $A(){if(B_)return tm;B_=1;const e=I4();function t(r){return r!=null&&typeof r!="function"&&e.isLength(r.length)}return tm.isArrayLike=t,tm}var nm={},F_;function R4(){if(F_)return nm;F_=1;function e(t){return typeof t=="object"&&t!==null}return nm.isObjectLike=e,nm}var W_;function D4(){if(W_)return em;W_=1;const e=$A(),t=R4();function r(n){return t.isObjectLike(n)&&e.isArrayLike(n)}return em.isArrayLikeObject=r,em}var q_;function M4(){if(q_)return jv;q_=1;const e=g4(),t=y4(),r=CA(),n=N4(),i=D4();function a(s,u=r.identity){return i.isArrayLikeObject(s)?e.uniqBy(Array.from(s),t.ary(n.iteratee(u),1)):[]}return jv.uniqBy=a,jv}var im,H_;function $4(){return H_||(H_=1,im=M4().uniqBy),im}var L4=$4();const K_=ai(L4);function z4(e,t,r){return t===!0?K_(e,r):typeof t=="function"?K_(e,t):e}var am={exports:{}},om={},sm={exports:{}},lm={};/**
 * @license React
 * use-sync-external-store-shim.production.js
 *
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */var V_;function U4(){if(V_)return lm;V_=1;var e=cs();function t(p,m){return p===m&&(p!==0||1/p===1/m)||p!==p&&m!==m}var r=typeof Object.is=="function"?Object.is:t,n=e.useState,i=e.useEffect,a=e.useLayoutEffect,s=e.useDebugValue;function u(p,m){var g=m(),b=n({inst:{value:g,getSnapshot:m}}),w=b[0].inst,S=b[1];return a(function(){w.value=g,w.getSnapshot=m,c(w)&&S({inst:w})},[p,g,m]),i(function(){return c(w)&&S({inst:w}),p(function(){c(w)&&S({inst:w})})},[p]),s(g),g}function c(p){var m=p.getSnapshot;p=p.value;try{var g=m();return!r(p,g)}catch{return!0}}function d(p,m){return m()}var h=typeof window>"u"||typeof window.document>"u"||typeof window.document.createElement>"u"?d:u;return lm.useSyncExternalStore=e.useSyncExternalStore!==void 0?e.useSyncExternalStore:h,lm}var G_;function B4(){return G_||(G_=1,sm.exports=U4()),sm.exports}/**
 * @license React
 * use-sync-external-store-shim/with-selector.production.js
 *
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */var Y_;function F4(){if(Y_)return om;Y_=1;var e=cs(),t=B4();function r(d,h){return d===h&&(d!==0||1/d===1/h)||d!==d&&h!==h}var n=typeof Object.is=="function"?Object.is:r,i=t.useSyncExternalStore,a=e.useRef,s=e.useEffect,u=e.useMemo,c=e.useDebugValue;return om.useSyncExternalStoreWithSelector=function(d,h,p,m,g){var b=a(null);if(b.current===null){var w={hasValue:!1,value:null};b.current=w}else w=b.current;b=u(function(){function k(j){if(!A){if(A=!0,P=j,j=m(j),g!==void 0&&w.hasValue){var M=w.value;if(g(M,j))return C=M}return C=j}if(M=C,n(P,j))return M;var F=m(j);return g!==void 0&&g(M,F)?(P=j,M):(P=j,C=F)}var A=!1,P,C,N=p===void 0?null:p;return[function(){return k(h())},N===null?void 0:function(){return k(N())}]},[h,p,m,g]);var S=i(d,b[0],b[1]);return s(function(){w.hasValue=!0,w.value=S},[S]),c(S),S},om}var X_;function W4(){return X_||(X_=1,am.exports=F4()),am.exports}var q4=W4(),Uy=x.createContext(null),H4=e=>e,at=()=>{var e=x.useContext(Uy);return e?e.store.dispatch:H4},ld=()=>{},K4=()=>ld,V4=(e,t)=>e===t;function ve(e){var t=x.useContext(Uy),r=x.useMemo(()=>t?n=>{if(n!=null)return e(n)}:ld,[t,e]);return q4.useSyncExternalStoreWithSelector(t?t.subscription.addNestedSub:K4,t?t.store.getState:ld,t?t.store.getState:ld,r,V4)}function G4(e,t=`expected a function, instead received ${typeof e}`){if(typeof e!="function")throw new TypeError(t)}function Y4(e,t=`expected an object, instead received ${typeof e}`){if(typeof e!="object")throw new TypeError(t)}function X4(e,t="expected all items to be functions, instead received the following types: "){if(!e.every(r=>typeof r=="function")){const r=e.map(n=>typeof n=="function"?`function ${n.name||"unnamed"}()`:typeof n).join(", ");throw new TypeError(`${t}[${r}]`)}}var J_=e=>Array.isArray(e)?e:[e];function J4(e){const t=Array.isArray(e[0])?e[0]:e;return X4(t,"createSelector expects all input-selectors to be functions, but received the following types: "),t}function Q4(e,t){const r=[],{length:n}=e;for(let i=0;i<n;i++)r.push(e[i].apply(null,t));return r}var Z4=class{constructor(e){this.value=e}deref(){return this.value}},eU=typeof WeakRef<"u"?WeakRef:Z4,tU=0,Q_=1;function qc(){return{s:tU,v:void 0,o:null,p:null}}function LA(e,t={}){let r=qc();const{resultEqualityCheck:n}=t;let i,a=0;function s(){var p;let u=r;const{length:c}=arguments;for(let m=0,g=c;m<g;m++){const b=arguments[m];if(typeof b=="function"||typeof b=="object"&&b!==null){let w=u.o;w===null&&(u.o=w=new WeakMap);const S=w.get(b);S===void 0?(u=qc(),w.set(b,u)):u=S}else{let w=u.p;w===null&&(u.p=w=new Map);const S=w.get(b);S===void 0?(u=qc(),w.set(b,u)):u=S}}const d=u;let h;if(u.s===Q_)h=u.v;else if(h=e.apply(null,arguments),a++,n){const m=((p=i==null?void 0:i.deref)==null?void 0:p.call(i))??i;m!=null&&n(m,h)&&(h=m,a!==0&&a--),i=typeof h=="object"&&h!==null||typeof h=="function"?new eU(h):h}return d.s=Q_,d.v=h,h}return s.clearCache=()=>{r=qc(),s.resetResultsCount()},s.resultsCount=()=>a,s.resetResultsCount=()=>{a=0},s}function rU(e,...t){const r=typeof e=="function"?{memoize:e,memoizeOptions:t}:e,n=(...i)=>{let a=0,s=0,u,c={},d=i.pop();typeof d=="object"&&(c=d,d=i.pop()),G4(d,`createSelector expects an output function after the inputs, but received: [${typeof d}]`);const h={...r,...c},{memoize:p,memoizeOptions:m=[],argsMemoize:g=LA,argsMemoizeOptions:b=[]}=h,w=J_(m),S=J_(b),k=J4(i),A=p(function(){return a++,d.apply(null,arguments)},...w),P=g(function(){s++;const N=Q4(k,arguments);return u=A.apply(null,N),u},...S);return Object.assign(P,{resultFunc:d,memoizedResultFunc:A,dependencies:k,dependencyRecomputations:()=>s,resetDependencyRecomputations:()=>{s=0},lastResult:()=>u,recomputations:()=>a,resetRecomputations:()=>{a=0},memoize:p,argsMemoize:g})};return Object.assign(n,{withTypes:()=>n}),n}var L=rU(LA),nU=Object.assign((e,t=L)=>{Y4(e,`createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof e}`);const r=Object.keys(e),n=r.map(a=>e[a]);return t(n,(...a)=>a.reduce((s,u,c)=>(s[r[c]]=u,s),{}))},{withTypes:()=>nU}),um={},cm={},Z_;function iU(){if(Z_)return cm;Z_=1;function e(t,r=1){const n=[],i=Math.floor(r),a=(s,u)=>{for(let c=0;c<s.length;c++){const d=s[c];Array.isArray(d)&&u<i?a(d,u+1):n.push(d)}};return a(t,0),n}return cm.flatten=e,cm}var dm={},eS;function zA(){if(eS)return dm;eS=1;const e=IA(),t=$A(),r=RA(),n=MA();function i(a,s,u){return r.isObject(u)&&(typeof s=="number"&&t.isArrayLike(u)&&n.isIndex(s)&&s<u.length||typeof s=="string"&&s in u)?e.isEqualsSameValueZero(u[s],a):!1}return dm.isIterateeCall=i,dm}var fm={},hm={},tS;function aU(){if(tS)return hm;tS=1;function e(r){return typeof r=="symbol"?1:r===null?2:r===void 0?3:r!==r?4:0}const t=(r,n,i)=>{if(r!==n){const a=e(r),s=e(n);if(a===s&&a===0){if(r<n)return i==="desc"?1:-1;if(r>n)return i==="desc"?-1:1}return i==="desc"?s-a:a-s}return 0};return hm.compareValues=t,hm}var pm={},vm={},rS;function UA(){if(rS)return vm;rS=1;function e(t){return typeof t=="symbol"||t instanceof Symbol}return vm.isSymbol=e,vm}var nS;function oU(){if(nS)return pm;nS=1;const e=UA(),t=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,r=/^\w*$/;function n(i,a){return Array.isArray(i)?!1:typeof i=="number"||typeof i=="boolean"||i==null||e.isSymbol(i)?!0:typeof i=="string"&&(r.test(i)||!t.test(i))||a!=null&&Object.hasOwn(a,i)}return pm.isKey=n,pm}var iS;function sU(){if(iS)return fm;iS=1;const e=Dy(),t=aU(),r=oU();function n(i,a,s,u){if(i==null)return[];s=u?void 0:s,Array.isArray(i)||(i=Object.values(i)),Array.isArray(a)||(a=a==null?[null]:[a]),a.length===0&&(a=[null]),Array.isArray(s)||(s=s==null?[]:[s]),s=s.map(p=>String(p));const c=(p,m)=>{let g=p;for(let b=0;b<m.length&&g!=null;++b)g=g[m[b]];return g},d=(p,m)=>m==null||p==null?m:typeof p=="object"&&"key"in p?Object.hasOwn(m,p.key)?m[p.key]:c(m,p.path):typeof p=="function"?p(m):Array.isArray(p)?c(m,p):typeof m=="object"?m[p]:m,h=a.map(p=>(Array.isArray(p)&&p.length===1&&(p=p[0]),p==null||typeof p=="function"||Array.isArray(p)||r.isKey(p)?p:{key:p,path:e.toPath(p)}));return i.map(p=>({original:p,criteria:h.map(m=>d(m,p))})).slice().sort((p,m)=>{for(let g=0;g<h.length;g++){const b=t.compareValues(p.criteria[g],m.criteria[g],s[g]);if(b!==0)return b}return 0}).map(p=>p.original)}return fm.orderBy=n,fm}var aS;function lU(){if(aS)return um;aS=1;const e=iU(),t=zA(),r=sU();function n(i,...a){const s=a.length;return s>1&&t.isIterateeCall(i,a[0],a[1])?a=[]:s>2&&t.isIterateeCall(a[0],a[1],a[2])&&(a=[a[0]]),r.orderBy(i,e.flatten(a),["asc"])}return um.sortBy=n,um}var mm,oS;function uU(){return oS||(oS=1,mm=lU().sortBy),mm}var cU=uU();const Tf=ai(cU);var BA=e=>e.legend.settings,dU=e=>e.legend.size,fU=e=>e.legend.payload;L([fU,BA],(e,t)=>{var{itemSorter:r}=t,n=e.flat(1);return r?Tf(n,r):n});var Hc=1;function hU(){var e=arguments.length>0&&arguments[0]!==void 0?arguments[0]:[],[t,r]=x.useState({height:0,left:0,top:0,width:0}),n=x.useCallback(i=>{if(i!=null){var a=i.getBoundingClientRect(),s={height:a.height,left:a.left,top:a.top,width:a.width};(Math.abs(s.height-t.height)>Hc||Math.abs(s.left-t.left)>Hc||Math.abs(s.top-t.top)>Hc||Math.abs(s.width-t.width)>Hc)&&r({height:s.height,left:s.left,top:s.top,width:s.width})}},[t.width,t.height,t.top,t.left,...e]);return[t,n]}function zt(e){return`Minified Redux error #${e}; visit https://redux.js.org/Errors?code=${e} for the full message or use the non-minified dev environment for full errors. `}var pU=typeof Symbol=="function"&&Symbol.observable||"@@observable",sS=pU,gm=()=>Math.random().toString(36).substring(7).split("").join("."),vU={INIT:`@@redux/INIT${gm()}`,REPLACE:`@@redux/REPLACE${gm()}`,PROBE_UNKNOWN_ACTION:()=>`@@redux/PROBE_UNKNOWN_ACTION${gm()}`},Od=vU;function By(e){if(typeof e!="object"||e===null)return!1;let t=e;for(;Object.getPrototypeOf(t)!==null;)t=Object.getPrototypeOf(t);return Object.getPrototypeOf(e)===t||Object.getPrototypeOf(e)===null}function FA(e,t,r){if(typeof e!="function")throw new Error(zt(2));if(typeof t=="function"&&typeof r=="function"||typeof r=="function"&&typeof arguments[3]=="function")throw new Error(zt(0));if(typeof t=="function"&&typeof r>"u"&&(r=t,t=void 0),typeof r<"u"){if(typeof r!="function")throw new Error(zt(1));return r(FA)(e,t)}let n=e,i=t,a=new Map,s=a,u=0,c=!1;function d(){s===a&&(s=new Map,a.forEach((S,k)=>{s.set(k,S)}))}function h(){if(c)throw new Error(zt(3));return i}function p(S){if(typeof S!="function")throw new Error(zt(4));if(c)throw new Error(zt(5));let k=!0;d();const A=u++;return s.set(A,S),function(){if(k){if(c)throw new Error(zt(6));k=!1,d(),s.delete(A),a=null}}}function m(S){if(!By(S))throw new Error(zt(7));if(typeof S.type>"u")throw new Error(zt(8));if(typeof S.type!="string")throw new Error(zt(17));if(c)throw new Error(zt(9));try{c=!0,i=n(i,S)}finally{c=!1}return(a=s).forEach(A=>{A()}),S}function g(S){if(typeof S!="function")throw new Error(zt(10));n=S,m({type:Od.REPLACE})}function b(){const S=p;return{subscribe(k){if(typeof k!="object"||k===null)throw new Error(zt(11));function A(){const C=k;C.next&&C.next(h())}return A(),{unsubscribe:S(A)}},[sS](){return this}}}return m({type:Od.INIT}),{dispatch:m,subscribe:p,getState:h,replaceReducer:g,[sS]:b}}function mU(e){Object.keys(e).forEach(t=>{const r=e[t];if(typeof r(void 0,{type:Od.INIT})>"u")throw new Error(zt(12));if(typeof r(void 0,{type:Od.PROBE_UNKNOWN_ACTION()})>"u")throw new Error(zt(13))})}function WA(e){const t=Object.keys(e),r={};for(let a=0;a<t.length;a++){const s=t[a];typeof e[s]=="function"&&(r[s]=e[s])}const n=Object.keys(r);let i;try{mU(r)}catch(a){i=a}return function(s={},u){if(i)throw i;let c=!1;const d={};for(let h=0;h<n.length;h++){const p=n[h],m=r[p],g=s[p],b=m(g,u);if(typeof b>"u")throw u&&u.type,new Error(zt(14));d[p]=b,c=c||b!==g}return c=c||n.length!==Object.keys(s).length,c?d:s}}function Ad(...e){return e.length===0?t=>t:e.length===1?e[0]:e.reduce((t,r)=>(...n)=>t(r(...n)))}function gU(...e){return t=>(r,n)=>{const i=t(r,n);let a=()=>{throw new Error(zt(15))};const s={getState:i.getState,dispatch:(c,...d)=>a(c,...d)},u=e.map(c=>c(s));return a=Ad(...u)(i.dispatch),{...i,dispatch:a}}}function qA(e){return By(e)&&"type"in e&&typeof e.type=="string"}var HA=Symbol.for("immer-nothing"),lS=Symbol.for("immer-draftable"),ir=Symbol.for("immer-state");function on(e,...t){throw new Error(`[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`)}var Pr=Object,rs=Pr.getPrototypeOf,Cd="constructor",Nf="prototype",Tg="configurable",jd="enumerable",ud="writable",ql="value",ti=e=>!!e&&!!e[ir];function dn(e){var t;return e?KA(e)||Rf(e)||!!e[lS]||!!((t=e[Cd])!=null&&t[lS])||Df(e)||Mf(e):!1}var yU=Pr[Nf][Cd].toString(),uS=new WeakMap;function KA(e){if(!e||!Fy(e))return!1;const t=rs(e);if(t===null||t===Pr[Nf])return!0;const r=Pr.hasOwnProperty.call(t,Cd)&&t[Cd];if(r===Object)return!0;if(!Wo(r))return!1;let n=uS.get(r);return n===void 0&&(n=Function.toString.call(r),uS.set(r,n)),n===yU}function If(e,t,r=!0){lu(e)===0?(r?Reflect.ownKeys(e):Pr.keys(e)).forEach(i=>{t(i,e[i],e)}):e.forEach((n,i)=>t(i,n,e))}function lu(e){const t=e[ir];return t?t.type_:Rf(e)?1:Df(e)?2:Mf(e)?3:0}var cS=(e,t,r=lu(e))=>r===2?e.has(t):Pr[Nf].hasOwnProperty.call(e,t),Ng=(e,t,r=lu(e))=>r===2?e.get(t):e[t],Td=(e,t,r,n=lu(e))=>{n===2?e.set(t,r):n===3?e.add(r):e[t]=r};function wU(e,t){return e===t?e!==0||1/e===1/t:e!==e&&t!==t}var Rf=Array.isArray,Df=e=>e instanceof Map,Mf=e=>e instanceof Set,Fy=e=>typeof e=="object",Wo=e=>typeof e=="function",ym=e=>typeof e=="boolean";function bU(e){const t=+e;return Number.isInteger(t)&&String(t)===e}var Yn=e=>e.copy_||e.base_,Wy=e=>e.modified_?e.copy_:e.base_;function Ig(e,t){if(Df(e))return new Map(e);if(Mf(e))return new Set(e);if(Rf(e))return Array[Nf].slice.call(e);const r=KA(e);if(t===!0||t==="class_only"&&!r){const n=Pr.getOwnPropertyDescriptors(e);delete n[ir];let i=Reflect.ownKeys(n);for(let a=0;a<i.length;a++){const s=i[a],u=n[s];u[ud]===!1&&(u[ud]=!0,u[Tg]=!0),(u.get||u.set)&&(n[s]={[Tg]:!0,[ud]:!0,[jd]:u[jd],[ql]:e[s]})}return Pr.create(rs(e),n)}else{const n=rs(e);if(n!==null&&r)return{...e};const i=Pr.create(n);return Pr.assign(i,e)}}function qy(e,t=!1){return $f(e)||ti(e)||!dn(e)||(lu(e)>1&&Pr.defineProperties(e,{set:Kc,add:Kc,clear:Kc,delete:Kc}),Pr.freeze(e),t&&If(e,(r,n)=>{qy(n,!0)},!1)),e}function xU(){on(2)}var Kc={[ql]:xU};function $f(e){return e===null||!Fy(e)?!0:Pr.isFrozen(e)}var Nd="MapSet",Rg="Patches",dS="ArrayMethods",VA={};function Ma(e){const t=VA[e];return t||on(0,e),t}var fS=e=>!!VA[e],Hl,GA=()=>Hl,_U=(e,t)=>({drafts_:[],parent_:e,immer_:t,canAutoFreeze_:!0,unfinalizedDrafts_:0,handledSet_:new Set,processedForPatches_:new Set,mapSetPlugin_:fS(Nd)?Ma(Nd):void 0,arrayMethodsPlugin_:fS(dS)?Ma(dS):void 0});function hS(e,t){t&&(e.patchPlugin_=Ma(Rg),e.patches_=[],e.inversePatches_=[],e.patchListener_=t)}function Dg(e){Mg(e),e.drafts_.forEach(SU),e.drafts_=null}function Mg(e){e===Hl&&(Hl=e.parent_)}var pS=e=>Hl=_U(Hl,e);function SU(e){const t=e[ir];t.type_===0||t.type_===1?t.revoke_():t.revoked_=!0}function vS(e,t){t.unfinalizedDrafts_=t.drafts_.length;const r=t.drafts_[0];if(e!==void 0&&e!==r){r[ir].modified_&&(Dg(t),on(4)),dn(e)&&(e=mS(t,e));const{patchPlugin_:i}=t;i&&i.generateReplacementPatches_(r[ir].base_,e,t)}else e=mS(t,r);return kU(t,e,!0),Dg(t),t.patches_&&t.patchListener_(t.patches_,t.inversePatches_),e!==HA?e:void 0}function mS(e,t){if($f(t))return t;const r=t[ir];if(!r)return Id(t,e.handledSet_,e);if(!Lf(r,e))return t;if(!r.modified_)return r.base_;if(!r.finalized_){const{callbacks_:n}=r;if(n)for(;n.length>0;)n.pop()(e);JA(r,e)}return r.copy_}function kU(e,t,r=!1){!e.parent_&&e.immer_.autoFreeze_&&e.canAutoFreeze_&&qy(t,r)}function YA(e){e.finalized_=!0,e.scope_.unfinalizedDrafts_--}var Lf=(e,t)=>e.scope_===t,PU=[];function XA(e,t,r,n){const i=Yn(e),a=e.type_;if(n!==void 0&&Ng(i,n,a)===t){Td(i,n,r,a);return}if(!e.draftLocations_){const u=e.draftLocations_=new Map;If(i,(c,d)=>{if(ti(d)){const h=u.get(d)||[];h.push(c),u.set(d,h)}})}const s=e.draftLocations_.get(t)??PU;for(const u of s)Td(i,u,r,a)}function EU(e,t,r){e.callbacks_.push(function(i){var u;const a=t;if(!a||!Lf(a,i))return;(u=i.mapSetPlugin_)==null||u.fixSetContents(a);const s=Wy(a);XA(e,a.draft_??a,s,r),JA(a,i)})}function JA(e,t){var n;if(e.modified_&&!e.finalized_&&(e.type_===3||e.type_===1&&e.allIndicesReassigned_||(((n=e.assigned_)==null?void 0:n.size)??0)>0)){const{patchPlugin_:i}=t;if(i){const a=i.getPath(e);a&&i.generatePatches_(e,a,t)}YA(e)}}function OU(e,t,r){const{scope_:n}=e;if(ti(r)){const i=r[ir];Lf(i,n)&&i.callbacks_.push(function(){cd(e);const s=Wy(i);XA(e,r,s,t)})}else dn(r)&&e.callbacks_.push(function(){const a=Yn(e);e.type_===3?a.has(r)&&Id(r,n.handledSet_,n):Ng(a,t,e.type_)===r&&n.drafts_.length>1&&(e.assigned_.get(t)??!1)===!0&&e.copy_&&Id(Ng(e.copy_,t,e.type_),n.handledSet_,n)})}function Id(e,t,r){return!r.immer_.autoFreeze_&&r.unfinalizedDrafts_<1||ti(e)||t.has(e)||!dn(e)||$f(e)||(t.add(e),If(e,(n,i)=>{if(ti(i)){const a=i[ir];if(Lf(a,r)){const s=Wy(a);Td(e,n,s,e.type_),YA(a)}}else dn(i)&&Id(i,t,r)})),e}function AU(e,t){const r=Rf(e),n={type_:r?1:0,scope_:t?t.scope_:GA(),modified_:!1,finalized_:!1,assigned_:void 0,parent_:t,base_:e,draft_:null,copy_:null,revoke_:null,isManual_:!1,callbacks_:void 0};let i=n,a=Rd;r&&(i=[n],a=Kl);const{revoke:s,proxy:u}=Proxy.revocable(i,a);return n.draft_=u,n.revoke_=s,[u,n]}var Rd={get(e,t){if(t===ir)return e;let r=e.scope_.arrayMethodsPlugin_;const n=e.type_===1&&typeof t=="string";if(n&&r!=null&&r.isArrayOperationMethod(t))return r.createMethodInterceptor(e,t);const i=Yn(e);if(!cS(i,t,e.type_))return CU(e,i,t);const a=i[t];if(e.finalized_||!dn(a)||n&&e.operationMethod&&(r!=null&&r.isMutatingArrayMethod(e.operationMethod))&&bU(t))return a;if(a===wm(e.base_,t)){cd(e);const s=e.type_===1?+t:t,u=Lg(e.scope_,a,e,s);return e.copy_[s]=u}return a},has(e,t){return t in Yn(e)},ownKeys(e){return Reflect.ownKeys(Yn(e))},set(e,t,r){const n=QA(Yn(e),t);if(n!=null&&n.set)return n.set.call(e.draft_,r),!0;if(!e.modified_){const i=wm(Yn(e),t),a=i==null?void 0:i[ir];if(a&&a.base_===r)return e.copy_[t]=r,e.assigned_.set(t,!1),!0;if(wU(r,i)&&(r!==void 0||cS(e.base_,t,e.type_)))return!0;cd(e),$g(e)}return e.copy_[t]===r&&(r!==void 0||t in e.copy_)||Number.isNaN(r)&&Number.isNaN(e.copy_[t])||(e.copy_[t]=r,e.assigned_.set(t,!0),OU(e,t,r)),!0},deleteProperty(e,t){return cd(e),wm(e.base_,t)!==void 0||t in e.base_?(e.assigned_.set(t,!1),$g(e)):e.assigned_.delete(t),e.copy_&&delete e.copy_[t],!0},getOwnPropertyDescriptor(e,t){const r=Yn(e),n=Reflect.getOwnPropertyDescriptor(r,t);return n&&{[ud]:!0,[Tg]:e.type_!==1||t!=="length",[jd]:n[jd],[ql]:r[t]}},defineProperty(){on(11)},getPrototypeOf(e){return rs(e.base_)},setPrototypeOf(){on(12)}},Kl={};for(let e in Rd){let t=Rd[e];Kl[e]=function(){const r=arguments;return r[0]=r[0][0],t.apply(this,r)}}Kl.deleteProperty=function(e,t){return Kl.set.call(this,e,t,void 0)};Kl.set=function(e,t,r){return Rd.set.call(this,e[0],t,r,e[0])};function wm(e,t){const r=e[ir];return(r?Yn(r):e)[t]}function CU(e,t,r){var i;const n=QA(t,r);return n?ql in n?n[ql]:(i=n.get)==null?void 0:i.call(e.draft_):void 0}function QA(e,t){if(!(t in e))return;let r=rs(e);for(;r;){const n=Object.getOwnPropertyDescriptor(r,t);if(n)return n;r=rs(r)}}function $g(e){e.modified_||(e.modified_=!0,e.parent_&&$g(e.parent_))}function cd(e)
